fidl_fuchsia_sysmem2__common/
fidl_fuchsia_sysmem2__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub const CPU_USAGE_READ: u32 = 1;
12
13pub const CPU_USAGE_READ_OFTEN: u32 = 2;
14
15pub const CPU_USAGE_WRITE: u32 = 4;
16
17pub const CPU_USAGE_WRITE_OFTEN: u32 = 8;
18
19pub const DISPLAY_USAGE_CURSOR: u32 = 2;
20
21pub const DISPLAY_USAGE_LAYER: u32 = 1;
22
23/// The max length in bytes of the `name` request field in
24/// [`fuchsia.sysmem2/Allocator.SetDebugClientInfo`] and
25/// [`fuchsia.sysmem2/Node.SetDebugClientInfo`].
26pub const MAX_CLIENT_NAME_LENGTH: i32 = 256;
27
28/// The maximum size of
29/// [`fuchsia.sysmem2/BufferCollectionConstraints.image_format_constraints`].
30pub const MAX_COUNT_BUFFER_COLLECTION_CONSTRAINTS_IMAGE_FORMAT_CONSTRAINTS: u32 = 64;
31
32/// The maximum entries that can be in the
33/// [`fuchsia.sysmem2/BufferCollectionInfo.buffers`] field.
34pub const MAX_COUNT_BUFFER_COLLECTION_INFO_BUFFERS: u32 = 128;
35
36/// The maximum size of
37/// [`fuchsia.sysmem2/BufferMemoryConstraints.permitted_heaps`].
38pub const MAX_COUNT_BUFFER_MEMORY_CONSTRAINTS_PERMITTED_HEAPS: u32 = 64;
39
40/// The maximum number of token children of an OR group that can be created per
41/// call to [`fuchsia.sysmem2/BufferCollectionTokenGroup.CreateChildrenSync`].
42///
43/// Actually creating this many children isn't recommended in most typical
44/// scenarios, but isn't prevented, for testing reasons, and just in case an
45/// unusual scenario needs it. Mitigation of potentially high time complexity in
46/// sysmem will limit the actual number of group child combinations considered
47/// in aggregation attempts to a separate maximum that is not settable via
48/// sysmem protocols. The maximum number of total nodes in a sysmem token tree
49/// is limited to a separate maximum that is not settable via these protocols.
50pub const MAX_COUNT_CREATE_CHILDREN: i32 = 64;
51
52pub const MAX_COUNT_DUPLICATES: u32 = 64;
53
54/// The maximum size of [`fuchsia.sysmem2/ImageFormatConstraints.color_spaces`].
55pub const MAX_COUNT_IMAGE_FORMAT_CONSTRAINTS_COLOR_SPACES: u32 = 32;
56
57/// The maximum size of
58/// [`fuchsia.sysmem2/ImageFormatConstraints.pixel_format_and_modifiers`].
59pub const MAX_COUNT_PIXEL_FORMAT_AND_MODIFIERS: u32 = 64;
60
61pub const MAX_HEAPS_COUNT: u32 = 32;
62
63pub const MAX_RANGES_COUNT: u32 = 128;
64
65pub const NONE_USAGE: u32 = 1;
66
67pub const NONE_USAGE_PERMIT_ALLOCATION: u32 = 2;
68
69pub const VIDEO_USAGE_CAPTURE: u32 = 8;
70
71pub const VIDEO_USAGE_DECRYPTOR_OUTPUT: u32 = 16;
72
73pub const VIDEO_USAGE_HW_DECODER: u32 = 1;
74
75pub const VIDEO_USAGE_HW_DECODER_INTERNAL: u32 = 32;
76
77pub const VIDEO_USAGE_HW_ENCODER: u32 = 2;
78
79pub const VULKAN_BUFFER_USAGE_INDEX_BUFFER: u32 = 4194304;
80
81pub const VULKAN_BUFFER_USAGE_INDIRECT_BUFFER: u32 = 16777216;
82
83pub const VULKAN_BUFFER_USAGE_STORAGE_BUFFER: u32 = 2097152;
84
85pub const VULKAN_BUFFER_USAGE_STORAGE_TEXEL_BUFFER: u32 = 524288;
86
87pub const VULKAN_BUFFER_USAGE_TRANSFER_DST: u32 = 131072;
88
89pub const VULKAN_BUFFER_USAGE_TRANSFER_SRC: u32 = 65536;
90
91pub const VULKAN_BUFFER_USAGE_UNIFORM_BUFFER: u32 = 1048576;
92
93pub const VULKAN_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER: u32 = 262144;
94
95pub const VULKAN_BUFFER_USAGE_VERTEX_BUFFER: u32 = 8388608;
96
97pub const VULKAN_IMAGE_USAGE_COLOR_ATTACHMENT: u32 = 16;
98
99pub const VULKAN_IMAGE_USAGE_INPUT_ATTACHMENT: u32 = 128;
100
101pub const VULKAN_IMAGE_USAGE_SAMPLED: u32 = 4;
102
103pub const VULKAN_IMAGE_USAGE_STENCIL_ATTACHMENT: u32 = 32;
104
105pub const VULKAN_IMAGE_USAGE_STORAGE: u32 = 8;
106
107pub const VULKAN_IMAGE_USAGE_TRANSFER_DST: u32 = 2;
108
109pub const VULKAN_IMAGE_USAGE_TRANSFER_SRC: u32 = 1;
110
111pub const VULKAN_IMAGE_USAGE_TRANSIENT_ATTACHMENT: u32 = 64;
112
113/// `INACCESSIBLE` is only for cases where there is no CPU access to the
114/// buffers.
115///
116/// Device-local memory that isn't reachable from the CPU is `CoherencyDomain`
117/// `INACCESSIBLE`, even if it's possible to cause a device (physical or
118/// virtual) to copy the data from the `INACCESSIBLE` buffers to buffers that
119/// are visible to the CPU. In other words, INACCESSIBLE does not imply secure,
120/// but secure implies INACCESSIBLE.
121///
122/// `CPU` means producers must ensure that a consumer can read the produced data
123/// with the CPU without the consumer needing to do additional cache ops not
124/// already performed (as needed) by the producer.
125///
126/// `RAM` means producers must ensure that the produced data is entirely present
127/// in RAM, without any dirty CPU cache lines, and a consumer must invalidate
128/// (or flush and invalidate, typically) the CPU cache before reading data with
129/// the CPU. The `RAM` domain can be faster than the `CPU` domain when all
130/// access is via HW DMA, since in that case no CPU cache ops are required,
131/// since no participant is actually reading/writing using the CPU.
132#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
133pub enum CoherencyDomain {
134    Cpu,
135    Ram,
136    Inaccessible,
137    #[doc(hidden)]
138    __SourceBreaking {
139        unknown_ordinal: u32,
140    },
141}
142
143/// Pattern that matches an unknown `CoherencyDomain` member.
144#[macro_export]
145macro_rules! CoherencyDomainUnknown {
146    () => {
147        _
148    };
149}
150
151impl CoherencyDomain {
152    #[inline]
153    pub fn from_primitive(prim: u32) -> Option<Self> {
154        match prim {
155            0 => Some(Self::Cpu),
156            1 => Some(Self::Ram),
157            2 => Some(Self::Inaccessible),
158            _ => None,
159        }
160    }
161
162    #[inline]
163    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
164        match prim {
165            0 => Self::Cpu,
166            1 => Self::Ram,
167            2 => Self::Inaccessible,
168            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
169        }
170    }
171
172    #[inline]
173    pub fn unknown() -> Self {
174        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
175    }
176
177    #[inline]
178    pub const fn into_primitive(self) -> u32 {
179        match self {
180            Self::Cpu => 0,
181            Self::Ram => 1,
182            Self::Inaccessible => 2,
183            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
184        }
185    }
186
187    #[inline]
188    pub fn is_unknown(&self) -> bool {
189        match self {
190            Self::__SourceBreaking { unknown_ordinal: _ } => true,
191            _ => false,
192        }
193    }
194}
195
196/// Regardless of which error code, any client retries should be very limited in
197/// number, if any.
198///
199/// A Error value should never be stored in a zx_status_t, since positive values
200/// in zx_status_t are deprecated.
201#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
202pub enum Error {
203    /// This is not a valid error value in this error enum. The server will
204    /// never send this value as a failure code. This value is not treated as
205    /// "success". In some languages, a locally default-initialized Error
206    /// instance will have this value until it is initialized with a valid
207    /// positive error code.
208    Invalid,
209    /// Unspecified error.
210    ///
211    /// This error code is used when no other error code applies, and the error
212    /// is probably not due to problematic messages sent to the server via the
213    /// channel delivering this error.
214    ///
215    /// This error should be handled by the client as a generic error.
216    ///
217    /// As one example, this error is used when a different client channel has
218    /// closed from the client end unexpectedly (without sending
219    /// [`fuchsia.sysmem2/Node.Release`] first), thereby causing failure of any
220    /// nodes in the same tree or sub-tree. In this usage, the main thing that's
221    /// relevant is it isn't the receiving client's "fault" - no reason to be
222    /// more specific since there's probably nothing the receiving client could
223    /// do about the error, at least not directly.
224    ///
225    /// As another example, this error can be used if a syscall that is normally
226    /// expected to succeed fails unexpectedly, and there's no identified reason
227    /// to "blame" the client.
228    ///
229    /// A client should never require / depend on a particular cause of error
230    /// continuing to result in UNSPECIFIED, as any particular error cause can
231    /// potentially start resulting in a more specific error code in future.
232    Unspecified,
233    /// A required field wasn't set or a specified value was invalid. See the
234    /// log for more info.
235    ///
236    /// This is also used when a message is received from the client in the
237    /// wrong order or in some way inconsistent with protocol rules.
238    ProtocolDeviation,
239    /// A client-specified object or ID was not found.
240    NotFound,
241    /// The object handle doesn't have sufficient rights to perform the request.
242    HandleAccessDenied,
243    /// The allocation could not be satisfied due to lack of available memory.
244    ///
245    /// The memory exhaustion can be specific to the heap that was selected
246    /// during constraints aggregation, so in some cases, this error can happen
247    /// despite normal system RAM not being near exhaustion, depending on
248    /// configured and selected heap(s).
249    NoMemory,
250    /// The request is valid but cannot be satisfied, perhaps due to hardware
251    /// limitations. This happens if participants involved in this allocation
252    /// have incompatible constraints (empty intersection, roughly speaking).
253    /// See the log for more info. In cases where a participant could
254    /// potentially be treated as optional, see [`BufferCollectionTokenGroup`].
255    ///
256    /// This can also happen if there aren't enough buffers in a pre-existing
257    /// collection to satisfy an additional token (including sub-tree of derived
258    /// tokens) created with [`fuchsia.sysmem2/BufferCollection.AttachToken`].
259    ///
260    /// This can also happen if a client's node is under a group and a different
261    /// group child is selected instead.
262    ConstraintsIntersectionEmpty,
263    /// Allocation hasn't been attempted yet. Calling
264    /// [`fuchsia.sysmem2/BufferCollection.WaitForAllBuffersAllocated`] would
265    /// (likely) block.
266    Pending,
267    /// Too many `BufferCollectionTokenGroup` child token selection combinations
268    /// exist and were considered, causing sysmem to give up on allocating
269    /// rather than enumerate the rest.
270    TooManyGroupChildCombinations,
271    #[doc(hidden)]
272    __SourceBreaking { unknown_ordinal: u32 },
273}
274
275/// Pattern that matches an unknown `Error` member.
276#[macro_export]
277macro_rules! ErrorUnknown {
278    () => {
279        _
280    };
281}
282
283impl Error {
284    #[inline]
285    pub fn from_primitive(prim: u32) -> Option<Self> {
286        match prim {
287            0 => Some(Self::Invalid),
288            1 => Some(Self::Unspecified),
289            2 => Some(Self::ProtocolDeviation),
290            3 => Some(Self::NotFound),
291            4 => Some(Self::HandleAccessDenied),
292            5 => Some(Self::NoMemory),
293            6 => Some(Self::ConstraintsIntersectionEmpty),
294            7 => Some(Self::Pending),
295            8 => Some(Self::TooManyGroupChildCombinations),
296            _ => None,
297        }
298    }
299
300    #[inline]
301    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
302        match prim {
303            0 => Self::Invalid,
304            1 => Self::Unspecified,
305            2 => Self::ProtocolDeviation,
306            3 => Self::NotFound,
307            4 => Self::HandleAccessDenied,
308            5 => Self::NoMemory,
309            6 => Self::ConstraintsIntersectionEmpty,
310            7 => Self::Pending,
311            8 => Self::TooManyGroupChildCombinations,
312            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
313        }
314    }
315
316    #[inline]
317    pub fn unknown() -> Self {
318        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
319    }
320
321    #[inline]
322    pub const fn into_primitive(self) -> u32 {
323        match self {
324            Self::Invalid => 0,
325            Self::Unspecified => 1,
326            Self::ProtocolDeviation => 2,
327            Self::NotFound => 3,
328            Self::HandleAccessDenied => 4,
329            Self::NoMemory => 5,
330            Self::ConstraintsIntersectionEmpty => 6,
331            Self::Pending => 7,
332            Self::TooManyGroupChildCombinations => 8,
333            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
334        }
335    }
336
337    #[inline]
338    pub fn is_unknown(&self) -> bool {
339        match self {
340            Self::__SourceBreaking { unknown_ordinal: _ } => true,
341            _ => false,
342        }
343    }
344}
345
346#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
347pub struct PixelFormatAndModifier {
348    /// When specified by a participant in a message to sysmem, this can be any
349    /// `PixelFormat` value that's acceptable to the participant. Specifying
350    /// `kInvalid` is not permitted.
351    ///
352    /// The participant can specify [`fuchsia.images2/PixelFormat.DO_NOT_CARE`]
353    /// if the participant needs to specify `ImageFormatConstraints` without
354    /// constraining the `pixel_format`.
355    pub pixel_format: fidl_fuchsia_images2__common::PixelFormat,
356    /// The participant can specify
357    /// [`fuchsia.images2/PixelFormatModifier.DO_NOT_CARE`] if the participant
358    /// needs to specify `ImageFormatConstraints` without constraining the
359    /// `pixel_format_modifier`.
360    pub pixel_format_modifier: fidl_fuchsia_images2__common::PixelFormatModifier,
361}
362
363impl fidl::Persistable for PixelFormatAndModifier {}
364
365#[derive(Clone, Debug, Default, PartialEq)]
366pub struct AllocatorSetDebugClientInfoRequest {
367    pub name: Option<String>,
368    pub id: Option<u64>,
369    #[doc(hidden)]
370    pub __source_breaking: fidl::marker::SourceBreaking,
371}
372
373impl fidl::Persistable for AllocatorSetDebugClientInfoRequest {}
374
375#[derive(Clone, Debug, Default, PartialEq)]
376pub struct AllocatorValidateBufferCollectionTokenRequest {
377    pub token_server_koid: Option<u64>,
378    #[doc(hidden)]
379    pub __source_breaking: fidl::marker::SourceBreaking,
380}
381
382impl fidl::Persistable for AllocatorValidateBufferCollectionTokenRequest {}
383
384#[derive(Clone, Debug, Default, PartialEq)]
385pub struct AllocatorValidateBufferCollectionTokenResponse {
386    pub is_known: Option<bool>,
387    #[doc(hidden)]
388    pub __source_breaking: fidl::marker::SourceBreaking,
389}
390
391impl fidl::Persistable for AllocatorValidateBufferCollectionTokenResponse {}
392
393/// Constraints on allocated buffers and, optionally, constraints on images
394/// stored in the buffers. These constraints can be specified per-participant.
395/// The sysmem service implements aggregation of constraints from multiple
396/// participants.
397#[derive(Clone, Debug, Default, PartialEq)]
398pub struct BufferCollectionConstraints {
399    /// The `usage` is a hint to sysmem to potentially help choose a more
400    /// optimal [`fuchsia.images2/PixelFormat`] and/or `pixel_format_modifier`
401    /// when multiple compatible options exist.
402    ///
403    /// When aggregating [`fuchsia.sysmem2/BufferCollectionConstraints`], these
404    /// values bitwise-OR.
405    ///
406    /// At least one `usage` bit must be specified (however, it's permitted for
407    /// a [`fuchsia.sysmem2/BufferCollection.SetConstraints`] request to have
408    /// the request `constraints` field not set, in which case `kNoneUsage` is
409    /// the default, along with no constraints from the participant).
410    ///
411    /// When `kNoneUsage` is specified it must be the only set bit, and no VMOs
412    /// will be sent in response to
413    /// [`fuchsia.sysmem2/BufferCollection.WaitForAllBuffersAllocated`].
414    pub usage: Option<BufferUsage>,
415    /// Per-participant number of buffers that the participant may concurrently
416    /// hold for its exclusive use for more than a transient duration (camp on).
417    /// In this context, a "transient" duration is the time it takes to finish
418    /// running a small amount of non-blocking code that finishes transfering
419    /// away ownership of the buffer. Things like reading from storage, waiting
420    /// on hardware that isn't already known to be done, or doing things like
421    /// frame encode or decode are not considered transient durations, even if
422    /// they might sometimes complete quickly.
423    ///
424    /// For example, a video decoder would specify (at least) the maximum number
425    /// of reference frames + 1 frame currently being decoded into. But not 1
426    /// more for the code that runs async and quickly to deliver a previously
427    /// decoded frame, even though that frame can potentially be owned for a
428    /// transient duration concurrent with decode of the next frame.
429    ///
430    /// A participant must not camp on more buffers than specified here (except
431    /// for a transient duration) else processing may get stuck.
432    ///
433    /// When aggregating BufferCollectionConstraints, these values add.
434    ///
435    /// In testing scenarios, camping on more buffers than this for any
436    /// significant duration (one screen refresh period is "significant" in this
437    /// context) may (ideally will) be flagged as a failure.  In testing
438    /// scenarios, the participant may not be provided with more buffers than
439    /// this concurrently.
440    pub min_buffer_count_for_camping: Option<u32>,
441    /// Per-participant minimum number of buffers that are needed for slack
442    /// reasons, for better overlap of processing / better performance.
443    ///
444    /// When aggregating `BufferCollectionConstraints`, these values add.
445    ///
446    /// A participant should typically specify 0 or 1 here - typically 0 is
447    /// appropriate if `min_buffer_count_for_camping` is already enough to keep
448    /// the participant busy 100% of the time when the participant is slightly
449    /// behind, while 1 can be appropriate if 1 more buffer than strictly needed
450    /// for min-camping reasons gives enough slack to stay busy 100% of the time
451    /// (when slightly behind, vs. lower % without the extra buffer).
452    ///
453    /// In testing scenarios, this field may be forced to 0, and all
454    /// participants are expected to continue to work without getting stuck. If
455    /// a buffer is needed for forward progress reasons, that buffer should be
456    /// accounted for in `min_buffer_count_for_camping`.
457    pub min_buffer_count_for_dedicated_slack: Option<u32>,
458    /// Similar to `min_buffer_count_for_dedicated_slack`, except when
459    /// aggregating these values max (instead of add). The value here is not
460    /// shared with any participant's `min_buffer_count_for_dedicated_slack`.
461    ///
462    /// A participant can specify > 0 here if a participant would like to ensure
463    /// there's some slack overall, but doesn't need that slack to be dedicated.
464    ///
465    /// The choice whether to use `min_buffer_count_for_dedicated_slack` or
466    /// `min_buffer_count_for_shared_slack` (or both) will typically be about
467    /// the degree to which the extra slack improves performance.
468    ///
469    /// In testing scenarios, this field may be forced to 0, and all
470    /// participants are expected to continue to work without getting stuck. If
471    /// a buffer is needed for forward progress reasons, that buffer should be
472    /// accounted for in `min_buffer_count_for_camping`.
473    pub min_buffer_count_for_shared_slack: Option<u32>,
474    /// A particularly-picky participant may unfortunately need to demand a
475    /// tight range of `buffer_count`, or even a specific `buffer_count`. This
476    /// field should remain 0 unless a participant really must set this field to
477    /// constrain the overall `BufferCollectionInfo.buffer_count`. Any such
478    /// participant should still fill out the min_buffer_count_for_* fields as
479    /// appropriate.
480    ///
481    /// If this field is un-set, the logical `min_buffer_count` is 0.
482    pub min_buffer_count: Option<u32>,
483    /// A particularly-picky participant may unfortunately need to demand a
484    /// tight range of `buffer_count`, or even a specific `buffer_count`. This
485    /// field should remain 0 unless a participant really must set this field to
486    /// constrain the overall `BufferCollectionInfo.buffer_count`. Any such
487    /// participant should still fill out the min_buffer_count_for_* fields.
488    ///
489    /// If this field is un-set, the logical `max_buffer_count` is 0xFFFFFFFF.
490    pub max_buffer_count: Option<u32>,
491    /// Optional constraints on `BufferCollectionSettings.buffer_settings`.
492    ///
493    /// A participant that intends to set `image_format_constraints` will
494    /// typically specify the minimum buffer size implicitly via
495    /// `image_format_constraints`, and possibly specify only the max buffer
496    /// size via `buffer_memory_constraints`.
497    ///
498    /// If un-set, the client is specifying "don't care" re. any buffer memory
499    /// constraints.
500    pub buffer_memory_constraints: Option<BufferMemoryConstraints>,
501    /// Optional constraints on the image format parameters of an image stored
502    /// in a buffer of the collection. This includes
503    /// [`fuchsia.images2/PixelFormat`] and `pixel_format_modifier` (for tiling
504    /// and the like). These constraints can be specified separately per
505    /// `pixel_format` `pixel_format_modifier` pair. Duplicated `pixel_format`
506    /// `pixel_format_modifier` pairs aren't permitted.
507    ///
508    /// When aggregating, only `pixel_format` `pixel_format_modifier` pairs that
509    /// are specified by all participants with non-zero
510    /// `image_format_constraints` size (and non-null)
511    /// BufferCollectionConstraints) are retained.
512    ///
513    /// A participant can specify `pixel_format`
514    /// [`fuchsia.images2/PixelFormat.DO_NOT_CARE`] and/or
515    /// `pixel_format_modifier`
516    /// [`fuchsia.images2/PixelFormatModifier.DO_NOT_CARE`] to permit any value
517    /// to be selected, but at least one participant must specify a specific
518    /// format for overall allocation to succeed.
519    ///
520    /// In a SetConstraints message, un-set or zero length means no image format
521    /// constraints; a raw buffer can be allocated if no other participants
522    /// specify any `image_format_constraints` entries.
523    pub image_format_constraints: Option<Vec<ImageFormatConstraints>>,
524    #[doc(hidden)]
525    pub __source_breaking: fidl::marker::SourceBreaking,
526}
527
528impl fidl::Persistable for BufferCollectionConstraints {}
529
530#[derive(Clone, Debug, Default, PartialEq)]
531pub struct BufferCollectionTokenDuplicateSyncRequest {
532    pub rights_attenuation_masks: Option<Vec<fidl::Rights>>,
533    #[doc(hidden)]
534    pub __source_breaking: fidl::marker::SourceBreaking,
535}
536
537impl fidl::Persistable for BufferCollectionTokenDuplicateSyncRequest {}
538
539#[derive(Clone, Debug, Default, PartialEq)]
540pub struct BufferCollectionTokenGroupCreateChildrenSyncRequest {
541    pub rights_attenuation_masks: Option<Vec<fidl::Rights>>,
542    #[doc(hidden)]
543    pub __source_breaking: fidl::marker::SourceBreaking,
544}
545
546impl fidl::Persistable for BufferCollectionTokenGroupCreateChildrenSyncRequest {}
547
548#[derive(Clone, Debug, Default, PartialEq)]
549pub struct BufferMemoryConstraints {
550    /// un-set is treated as 1
551    pub min_size_bytes: Option<u64>,
552    /// un-set is treated as 0xFFFFFFFFFFFFFFFF.
553    pub max_size_bytes: Option<u64>,
554    /// When false, physical pages of a buffer VMO can be non-contiguous. When
555    /// true, physical pages of a buffer VMO must be sequentially contiguous. A
556    /// client that doesn't require physically contiguous VMOs must still accept
557    /// physically contiguous VMOs or "physical" VMOs.
558    pub physically_contiguous_required: Option<bool>,
559    /// If true, the participant requires secure memory.
560    ///
561    /// When aggregating `BufferCollectionConstraints`, these values boolean-OR.
562    pub secure_required: Option<bool>,
563    /// When true (or when `BufferMemoryConstraints` is not present), the
564    /// participant is ok with sysmem selecting the CPU domain.
565    ///
566    /// If the CPU domain is selected, participants must ensure the CPU can read
567    /// or write data to the buffer without cache operations outside of the
568    /// participant.
569    ///
570    /// In other words, if a producer participant DMAs data directly to RAM on a
571    /// non-cache-coherent architecture such as arm, the producer must ensure
572    /// the CPU cache is clean wrt. the buffer before the DMA write, and
573    /// invalidate the CPU cache after the DMA write and before indicating that
574    /// the buffer is ready to any other participant. If a consumer participant
575    /// DMAs data directly from RAM on a non-cache-coherent architecture such as
576    /// arm, the consumer must flush the CPU cache wrt the buffer before the DMA
577    /// read.
578    ///
579    /// CPU-only participants that don't do any DMA can just write and read the
580    /// buffers (when they should) without needing to do any CPU cache ops.
581    pub cpu_domain_supported: Option<bool>,
582    /// When true, the participant is ok with sysmem selecting the RAM domain.
583    ///
584    /// If the RAM domain is selected, producer data must be available in RAM
585    /// (with CPU cache state such that the RAM data won't get corrupted by a
586    /// dirty CPU cache line writing incorrect data to RAM), and a consumer
587    /// reading using the CPU must invalidate CPU cache before reading (the
588    /// producer doesn't guarantee zero stale "clean" cache lines).
589    ///
590    /// In other words, if a producer participant uses the CPU to write data on
591    /// a non-cache-coherent architecture such as arm, the producer must flush
592    /// the data to RAM before indicating to another participant that the buffer
593    /// is ready. If a consumer participant uses the CPU to read data on a
594    /// non-cache-coherent architecture such as arm, the participant must
595    /// invalidate (typically flush+invalidate with knowledge that no cache
596    /// lines are dirty) the CPU cache before reading the buffer.
597    ///
598    /// RAM-only participants that don't do any CPU accesses to a buffer can
599    /// just do DMA to/from the buffers (when they should) without needing to
600    /// do any CPU cache ops.
601    pub ram_domain_supported: Option<bool>,
602    /// When true, the participant is ok with sysmem selecting the INACCESSIBLE
603    /// domain.
604    ///
605    /// If the INACCESSIBLE domain is selected, CPU reads and writes of the data
606    /// are prevented. Attempts to read/write the data with the CPU may result
607    /// in UB and/or process termination.
608    ///
609    /// If the INACCESSIBLE domain is selected, participants must only operate
610    /// on the data using DMAs performed by HW, or platform-specific DMA-like
611    /// requests to a secure environment (which will do the needed CPU cache ops
612    /// similar to how a RAM domain participant would operate).
613    ///
614    /// Secure heaps only support INACCESSIBLE domain, and will fail allocation
615    /// if any participant with `BufferUsage` other than `NONE_USAGE` does not
616    /// set inaccessible_domain_supported to true.
617    ///
618    /// When the INACCESSIBLE domain is selected, participants (outside of
619    /// secure/DRM environments) should not attempt to map buffers, and should
620    /// not attempt to perform any CPU cache ops. In this respect, this domain
621    /// is similar to RAM domain with all participants only doing DMA and no
622    /// participant(s) doing CPU accesses.
623    pub inaccessible_domain_supported: Option<bool>,
624    /// Which heaps are acceptable to the participant. Participants that don't
625    /// care which heap memory is allocated on should leave this field un-set. A
626    /// secure heap is only selected if all participants explicitly indicate
627    /// that the secure heap is acceptable via `heap_permitted`, or specify
628    /// `NONE_USAGE`.
629    pub permitted_heaps: Option<Vec<Heap>>,
630    #[doc(hidden)]
631    pub __source_breaking: fidl::marker::SourceBreaking,
632}
633
634impl fidl::Persistable for BufferMemoryConstraints {}
635
636/// These are memory-related settings for all buffers of a buffer collection.
637#[derive(Clone, Debug, Default, PartialEq)]
638pub struct BufferMemorySettings {
639    /// This field will always be set by sysmem.
640    pub size_bytes: Option<u64>,
641    /// This field will always be set by sysmem.
642    pub is_physically_contiguous: Option<bool>,
643    /// This field will always be set by sysmem.
644    pub is_secure: Option<bool>,
645    /// This field will always be set by sysmem.
646    pub coherency_domain: Option<CoherencyDomain>,
647    /// The specific heap from which buffers are allocated.
648    ///
649    /// This field will always be set by sysmem.
650    pub heap: Option<Heap>,
651    #[doc(hidden)]
652    pub __source_breaking: fidl::marker::SourceBreaking,
653}
654
655impl fidl::Persistable for BufferMemorySettings {}
656
657/// Describes how a client will access the contents of a buffer.
658#[derive(Clone, Debug, Default, PartialEq)]
659pub struct BufferUsage {
660    /// If the client sets this field, the client should not set any other
661    /// fields in the same table instance. The only valid bit in this field is
662    /// `NONE_USAGE` which must be set if this field is set. The point of this
663    /// field and the one bit set in this field is to essentially prove that the
664    /// client really means they aren't going to use the buffers, so don't need
665    /// any VMOs (didn't just fail to fill out the table).
666    pub none: Option<u32>,
667    /// If set, holds CPU usage bits. See `CPU_USAGE_*` flags in usages.fidl.
668    pub cpu: Option<u32>,
669    /// If set, holds vulkan usage bits. See `VULKAN_IMAGE_*` and
670    /// `VULKAN_BUFFER_*` bits in usages.fidl. The `VULKAN_USAGE_*` bit
671    /// definitions/names are deprecated.
672    pub vulkan: Option<u32>,
673    /// If set, holds display usage bits. See `DISPLAY_USAGE_*` bits in
674    /// usages.fidl.
675    pub display: Option<u32>,
676    /// If set, holds video usage bits. See `VIDEO_USAGE_*` bits in usages.fidl.
677    pub video: Option<u32>,
678    #[doc(hidden)]
679    pub __source_breaking: fidl::marker::SourceBreaking,
680}
681
682impl fidl::Persistable for BufferUsage {}
683
684/// This type is fidl::Persist()'ed in the sysmem_config.persistent_fidl file
685/// within the sysmem domain config by the assembly tool, and read by the sysmem
686/// driver.
687///
688/// Normally json[5] would be preferable for config, but we generate this config
689/// in rust using FIDL types (to avoid repetition and to take advantage of FIDL
690/// rust codegen), and there's no json schema for FIDL types.
691///
692/// Currently there is no mechanism to change anything in this config at runtime
693/// or from boot to boot. This config is static per run of the assembly tool.
694///
695/// See src/lib/assembly/config_schema/src/platform_config/sysmem_config.rs for
696/// aspects of sysmem config which are specified directly inline in board info
697/// or assembly platform config. The two parts of sysmem config don't
698/// (currently) overlap. The config here is for aspects of sysmem config which
699/// would be too verbose for direct inclusion in board info or assembly platform
700/// config. In addition, some/most of the pixel format cost entries are
701/// programmatically generated (as of this comment).
702///
703/// Prior to aggregation by assembly tool, there are multiple .persistent_fidl
704/// files each storing its own Config instance. The board info and assembly
705/// platform config lists the input persistent_fidl files, with board info
706/// logically before assembly platform config. The overall list of files is
707/// processed, which allows later files to override/replace info in prior files.
708///
709/// Because this type is only intended for use with persistent fidl, where the
710/// length of a serialized instance isn't bounded, we don't bound the internal
711/// vector element counts.
712#[derive(Clone, Debug, Default, PartialEq)]
713pub struct Config {
714    /// This is the ordered list of FormatCost entries which will be considered
715    /// by sysmem when breaking ties among formats supported by all participants
716    /// of a buffer collection.
717    ///
718    /// During config aggregation, if a later entry has matching FormatCostKey,
719    /// the earlier entry is omitted/removed. This allows later files to
720    /// override entries in earlier files, and allows files specified in
721    /// assembly platform config to override entries in files specified in the
722    /// board info.
723    ///
724    /// This vector will normally not have any two entries with matching
725    /// pixel_format, pixel_format_modifier, and buffer_usage_bits in the Config
726    /// instance loaded from sysmem_config.persistent_fidl by sysmem. If somehow
727    /// two entries do match in those fields, sysmem can ignore all but one of
728    /// the entries chosen arbitrarily.
729    pub format_costs: Option<Vec<FormatCostEntry>>,
730    #[doc(hidden)]
731    pub __source_breaking: fidl::marker::SourceBreaking,
732}
733
734impl fidl::Persistable for Config {}
735
736#[derive(Clone, Debug, Default, PartialEq)]
737pub struct DynamicSecureHeap {
738    pub heap: Option<Heap>,
739    #[doc(hidden)]
740    pub __source_breaking: fidl::marker::SourceBreaking,
741}
742
743impl fidl::Persistable for DynamicSecureHeap {}
744
745/// A FormatCostEntry can be used to influence which PixelFormatAndModifier is
746/// chosen for a buffer collection, optionally taking BufferUsage into account.
747///
748/// The default cost is f32::MAX, so any specified cost with a non-MAX value
749/// will prefer the specified format over any formats that don't have any
750/// FormatCost entry.
751///
752/// Entries which have the same pixel_format, pixel_format_modifier, and
753/// required_usage_bits as a previous entry will override that previous entry.
754/// For matching purposes, an absent pixel_format_modifier matches LINEAR, and
755/// an absent required_buffer_usage_bits matches all-0 usage bits.
756///
757/// Board info sysmem_defaults entries are logically before platform sysmem
758/// entries.
759///
760/// Sysmem uses the resulting aggregated list of FormatCostEntry(s) when
761/// breaking ties among the set of formats which are supported by all
762/// participants of a buffer collection. For each mutually-supported format,
763/// entries with non-matching format are ignored, and entries with extra
764/// buffer_usage_bits set are ignored. Among the remaining entries, the entry
765/// with the most usage bits in common with the aggregated participant usages is
766/// selected to determine the cost (if a tie, the later entry wins). Then the
767/// format with the lowest cost is chosen. If it's still a tie (equal cost), the
768/// tie is broken arbitrarily but not randomly.
769///
770/// This is not intended as a mechanism to disallow selection of a format that
771/// is supported by all participants of a buffer collection. If a participant
772/// claims support for a format but fails to handle that format correctly, it
773/// should be fixed to handle that format correctly or changed to stop claiming
774/// support for that format.
775///
776/// This mechanism is intended to influence format selection toward more
777/// efficient formats with better performance, lower memory bandwidth usage,
778/// etc, for a given set of usage bits, taking into account quirks that may be
779/// unique to a given board or overall platform config.
780#[derive(Clone, Debug, Default, PartialEq)]
781pub struct FormatCostEntry {
782    /// Must be set. If two entries have logically equal key (after field
783    /// defaults are applied), the later entry will override the earlier entry.
784    pub key: Option<FormatCostKey>,
785    /// Must be set. Lower costs win, but see also FormatCostKey fields re.
786    /// filtering entries by format and usage bits first.
787    ///
788    /// When two entries (each with format supported by all the participants of
789    /// a buffer collection) have different costs, the lower cost entry (and its
790    /// format) is chosen.
791    ///
792    /// For non-test scenarios, only use cost values > 0.0 (typically at least
793    /// 1.0 as of this comment), with 0.0 and negative values reserved for
794    /// testing.
795    pub cost: Option<f32>,
796    #[doc(hidden)]
797    pub __source_breaking: fidl::marker::SourceBreaking,
798}
799
800impl fidl::Persistable for FormatCostEntry {}
801
802/// Entries which have the same pixel_format, pixel_format_modifier, and
803/// required_usage_bits as a previous entry will override that previous entry.
804/// For matching purposes, an absent pixel_format_modifier matches LINEAR, and
805/// an absent required_buffer_usage_bits matches all-0 usage bits.
806#[derive(Clone, Debug, Default, PartialEq)]
807pub struct FormatCostKey {
808    /// The pixel_format and pixel_format_modifier are the format to which this
809    /// FormatCost entry applies.
810    ///
811    /// Must be set.
812    pub pixel_format: Option<fidl_fuchsia_images2__common::PixelFormat>,
813    /// The pixel_format and pixel_format_modifier are the format to which this
814    /// FormatCost entry applies.
815    ///
816    /// Un-set is equivalent to LINEAR.
817    pub pixel_format_modifier: Option<fidl_fuchsia_images2__common::PixelFormatModifier>,
818    /// If set, this entry is only considered if the buffer collection has at
819    /// least these usage bits set.
820    ///
821    /// The buffer collection has an aggregated BufferUsage which is the union
822    /// of per-participant BufferUsage bits. FormatCost entries with additional
823    /// set bits are ignored. Among the rest, the one with matching format and
824    /// the most usage bits set determines the cost of that format for that
825    /// buffer collection.
826    ///
827    /// Then the lowest-cost format is chosen for that buffer collection among
828    /// the formats that are mutually suppored by all the participants of that
829    /// buffer collection.
830    ///
831    /// The main intent of this field is to allow "waving off" a format that
832    /// works, but doesn't perform well, for a particular combination of usages.
833    /// In that case the cost can be set high when the problematic combination
834    /// of usage bits is set. The format will still be chosen if this format is
835    /// the only mutually-supported format among the participants of the buffer
836    /// collection.
837    ///
838    /// Un-set is equivalent to zero usage bits set, meaning the entry applies
839    /// to the format unless another entry with more specific usage applies.
840    ///
841    /// It can be reasonable in some cases for all entries to omit this field,
842    /// when/if format selection based on format cost alone, ignoring usage, is
843    /// sufficient.
844    pub buffer_usage_bits: Option<BufferUsage>,
845    #[doc(hidden)]
846    pub __source_breaking: fidl::marker::SourceBreaking,
847}
848
849impl fidl::Persistable for FormatCostKey {}
850
851/// This is the root of the persistent fidl in a format costs file. The format
852/// costs files are read by the assembly tool and merged into the single
853/// sysmem_config.persistent_fidl file in the sysmem domain config (see Config
854/// above).
855///
856/// Normally json[5] would be preferable for config, but we generate this config
857/// in rust using FIDL types (to avoid repetition and to take advantage of FIDL
858/// rust codegen), and there's no json schema for FIDL types.
859///
860/// While the resulting sysmem_config.persistent_fidl is a single file that can
861/// contain multiple aspects of sysmem config, in contrast a format costs file
862/// contains only format costs. We don't mind having more separate files during
863/// the build, but it's nice to get sysmem's domain config down to a single file
864/// on-device.
865#[derive(Clone, Debug, Default, PartialEq)]
866pub struct FormatCosts {
867    /// This is a chunk of entries that'll end up in
868    /// ['fuchsia.sysmem2.Config.format_costs'] (see above) unless overriden by
869    /// later entries (either in this same vector or in later-processed files
870    /// during aggregation by the assembly tool).
871    pub format_costs: Option<Vec<FormatCostEntry>>,
872    #[doc(hidden)]
873    pub __source_breaking: fidl::marker::SourceBreaking,
874}
875
876impl fidl::Persistable for FormatCosts {}
877
878/// A reference to a heap instance.
879///
880/// A given heap instance can have more than one `Heap` which can be used to
881/// refer to the heap instance. Comparing `Heap` tables without knowledge of
882/// these `Heap` aliases is not a reliable way to determine if two `Heap` tables
883/// refer to the same heap (matching means yes, but not matching means maybe).
884/// Allowing heap aliases makes renaming `Heap.type`(s) easier.
885#[derive(Clone, Debug, Default, PartialEq)]
886pub struct Heap {
887    /// The type of the heap, specified using a bind string defined per the
888    /// schema and mechanism described in comments in the
889    /// fuchsia.sysmem.heap.bind file.
890    ///
891    /// Examples:
892    /// * "fuchsia.sysmem.heap.HEAP_TYPE.SYSTEM_RAM"
893    /// * "fuchsia.goldfish.platform.sysmem.heap.HEAP_TYPE.HOST_VISIBLE"
894    pub heap_type: Option<String>,
895    /// The uint64 id of the heap. This is only required to be unique per (type,
896    /// boot) tuple. In other words, a given heap id is only meaningful within
897    /// the current boot of the machine (not across boots), and only within the
898    /// `Heap.type`.
899    ///
900    /// For `Heap.type`(s) that refer to a singleton heap, a participant
901    /// specifying the singleton heap in
902    /// [`fuchsia.sysmem2.BufferMemoryConstraints.permitted_heaps`] can leave
903    /// this field un-set, or set it to zero. Sysmem will always fill out this
904    /// field for the heap indicated in
905    /// [`fuchsia.sysmem2.BufferMemmorySettings.heap`] (for a singleton heap the
906    /// `id` field will be set to 0 by sysmem).
907    pub id: Option<u64>,
908    #[doc(hidden)]
909    pub __source_breaking: fidl::marker::SourceBreaking,
910}
911
912impl fidl::Persistable for Heap {}
913
914/// Describes constraints on layout of image data in buffers.
915#[derive(Clone, Debug, Default, PartialEq)]
916pub struct ImageFormatConstraints {
917    /// The [`fuchsia.images2/PixelFormat`] for which the following constraints
918    /// apply.
919    ///
920    /// The `pixel_format` and `pixel_format_modifier` fields together are
921    /// treated by the server as one additional `pixel_format_and_modifiers`
922    /// entry.
923    ///
924    /// A participant may have more than one
925    /// [`fuchsia.sysmem2/PixelFormatAndModifier`] that's supported.
926    ///
927    /// * If image constraints are the same for different
928    ///   `PixelFormatAndModifier`s, the participant may list additional
929    ///   `PixelFormatAndModifier`s for which the constraints apply in the
930    ///   `pixel_format_and_modifiers` field. This reduces the overall number of
931    ///   `ImageFormatConstraints` that need to be sent, without changing the
932    ///   meaning (vs for example sending a bunch of separate
933    ///   `ImageFormatConstraints` that only differ by the `pixel_format` and
934    ///   `pixel_format_modifier` which overall specify the same list of
935    ///   `PixelFormatAndModifier`s).
936    /// * If image constraints differ for different `PixelFormatAndModifier`s,
937    ///   the participant can convey this using a separate
938    ///   `ImageFormatConstraints` entry in `image_format_constraints` for each
939    ///   set of `PixelFormatAndModifier`s that have different image
940    ///   constraints.
941    /// * It's ok for a participant to have two `image_format_constraints`
942    ///   entries that only differ in their pixel_format_and_modifiers, but this
943    ///   is isn't the most compact way to represent that situation since the
944    ///   two entries could be combined by specifying two
945    ///   `PixelFormatAndModifier`s within a single `ImageFormatConstraints`.
946    ///
947    /// It's not uncommon for the other fields of `ImageFormatConstraints` to
948    /// vary by `pixel_format` or by `pixel_format_modifier` - for example for a
949    /// linear format to support smaller max size than a tiled format.
950    ///
951    /// See also
952    /// [`fuchsia.sysmem2/ImageFormatConstraints.pixel_format_and_modifiers`].
953    ///
954    /// Thie field must be set to a value other than
955    /// [`fuchsia.images2/PixelFormat.INVALID`] unless
956    /// `pixel_format_and_modifiers` is non-empty. In other words, there must be
957    /// at least one `PixelFormatAndModifier` per `ImageFormatConstraints`. If
958    /// `pixel_format_modifier` is set, this field must also be set.
959    ///
960    /// The participant can specify [`fuchsia.images2/PixelFormat.DO_NOT_CARE`]
961    /// if the participant needs to specify `ImageFormatConstraints` without
962    /// constraining the `pixel_format`.
963    pub pixel_format: Option<fidl_fuchsia_images2__common::PixelFormat>,
964    /// The pixel format modifier for which the following constraints apply.
965    ///
966    /// The `pixel_format` and `pixel_format_modifier` fields together are
967    /// treated by the server as one additional `pixel_format_and_modifiers`
968    /// entry.
969    ///
970    /// This is a [`fuchsia.images2/PixelFormatModifier`] that's acceptable to
971    /// the participant in combination with the `pixel_format`.
972    ///
973    /// See also `pixel_format_and_modifiers`.
974    ///
975    /// If `pixel_format` is set but `pixel_format_modifier` is un-set, the
976    /// default depends on other fields:
977    ///
978    /// * If `pixel_format` is [`fuchsia.images2/PixelFormat.DO_NOT_CARE`], the
979    ///   pixel format modifier is implicitly
980    ///   [`fuchsia.images2/PixelFormatModifier.DO_NOT_CARE`].
981    /// * else if `BufferCollectionConstraints.usage` isn't `NONE`, the pixel
982    ///   format modifier is implicitly
983    ///   [`fuchsia.images2/PixelFormatModifier.LINEAR`].
984    /// * else the pixel format modifier is implicitly
985    ///   [`fuchsia.images2/PixelFormatModifier.DO_NOT_CARE`].
986    pub pixel_format_modifier: Option<fidl_fuchsia_images2__common::PixelFormatModifier>,
987    /// Empty is an error. Duplicate entries are an error. Arbitrary ordering is
988    /// not an error.
989    ///
990    /// The client can specify a single entry
991    /// [`fuchsia.sysmem2/ColorSpace.DO_NOT_CARE`] if the client doesn't want to
992    /// constrain which `ColorSpace` is chosen. At least one participant must
993    /// specify at least one `ColorSpace` value other than
994    /// `ColorSpace.DO_NOT_CARE`, or allocation will fail.
995    pub color_spaces: Option<Vec<fidl_fuchsia_images2__common::ColorSpace>>,
996    /// Minimum permitted size in pixels.
997    ///
998    /// For example a video decoder participant may set this field to the
999    /// minimum size that might potentially be specified by a stream. In
1000    /// contrast, `required_min_size` would be set to the current size specified
1001    /// by the stream. While `min_size` aggregates by taking the max,
1002    /// `required_min_size` aggregates by taking the min.
1003    ///
1004    /// When sending to sysmem, this field can be un-set if the participant is
1005    /// prepared to deal with the smallest possible non-zero image layout
1006    /// limited only by the constraints implicitly imposed by the `pixel_format`
1007    /// and `pixel_format_modifier`. Or this field can be set to the actual
1008    /// minimum size the participant can handle.
1009    ///
1010    /// Producers should set `min_size` and set both width and height to the
1011    /// actual non-zero smallest width and height that the producer might
1012    /// generate. For example, a video decoder can set the size of a single
1013    /// macroblock here.
1014    ///
1015    /// When receiving from sysmem, this field will always be set, and neither
1016    /// width nor height will be 0, because at least one participant must
1017    /// specify a non-zero minimum size (where both width and height aren't
1018    /// zero).
1019    ///
1020    /// See also `required_min_size`.
1021    pub min_size: Option<fidl_fuchsia_math__common::SizeU>,
1022    /// Maximum size in pixels. For example Scenic may set this field (directly
1023    /// or via sub-participants) to the maximum size that can be composited.
1024    ///
1025    /// Sending to sysmem, un-set is treated as 0xFFFFFFFF, 0xFFFFFFFF.
1026    ///
1027    /// Receiving from sysmem, this field will always be set. For width and
1028    /// height separately, if there is no enforced max, that sub-field will be
1029    /// 0xFFFFFFFF.
1030    ///
1031    /// See also `required_max_size`.
1032    pub max_size: Option<fidl_fuchsia_math__common::SizeU>,
1033    /// The minimum number of bytes per row, including any padding beyond the
1034    /// last image data in a row.
1035    ///
1036    /// This is sometimes called the "stride in bytes" or the "line to line
1037    /// offset". For single-plane formats, this is the number of bytes per row
1038    /// of pixels. For multi-plane formats, this is the number of bytes per row
1039    /// of samples in plane 0 (for example, the number of bytes per row of luma
1040    /// samples in the case of a multi-plane YUV format). For multi-plane
1041    /// formats, the bytes per row in planes other than plane 0 is format
1042    /// specific, but always a specific relationship to the plane 0 bytes per
1043    /// row.
1044    ///
1045    /// When sending `ImageFormatConstraints` to sysmem, setting this field is
1046    /// optional. Not setting this field is recommended unless the participant
1047    /// needs to force the `bytes_per_row` to be larger than the minimum value
1048    /// implied by `min_size.width`, the "stride bytes per width pixel" of the
1049    /// `pixel_format` plus `pixel_format_modifier` (see also
1050    /// `ImageFormatStrideBytesPerWidthPixel`), and `bytes_per_row_divisor`.
1051    ///
1052    /// When this structure is received from sysmem, this field will always be
1053    /// set (when the parent structure is present), and will always be at least
1054    /// the value implied by `min_size.width`, the "stride bytes per width
1055    /// pixel" of the `pixel_format` plus `pixel_format_modifier`, and
1056    /// `bytes_per_row_divisor`.
1057    ///
1058    /// Some producer participants may prefer to simply set
1059    /// `ImageFormat.bytes_per_row` to
1060    /// `ImageFormatConstraints.min_bytes_per_row` since sysmem is guaranteeing
1061    /// that `min_bytes_per_row` is compatible with an image of width
1062    /// `min_size.width`. However, producer participants that need to have
1063    /// `size.width` > `min_size.width` can get a corresponding
1064    /// `min_bytes_per_row` from `ImageFormatMinimumRowBytes` (in C++), or can
1065    /// just calculate the `bytes_per_row` directly.
1066    pub min_bytes_per_row: Option<u32>,
1067    /// The maximum number of bytes per row, including any padding beyond the
1068    /// last image data in a row.
1069    ///
1070    /// When sent to sysmem, must be >= the value implied by `max_size.width`,
1071    /// "stride bytes per width pixel", and `bytes_per_row_divisor`, or
1072    /// constraints aggregation will fail. Un-set means the participant doesn't
1073    /// need/want to set a strict max.
1074    ///
1075    /// Sending to sysmem, un-set is treated as 0xFFFFFFFF.
1076    ///
1077    /// When received from sysmem, this field will always be set. If the max is
1078    /// effectively infinite, the value will be 0xFFFFFFFF (not zero).
1079    pub max_bytes_per_row: Option<u32>,
1080    /// The maximum number of pixels.
1081    ///
1082    /// The max image area in pixels is limited indirectly via
1083    /// [`fuchsia.sysmem/BufferMemoryConstraints.max_size_bytes`] and the
1084    /// resulting [`fuchsia.sysmem/BufferSettings.size_bytes`], and can also be
1085    /// enforced directly via this field.
1086    ///
1087    /// In contrast to the [`fuchsia.sysmem2/ImageFormatConstraints.max_size`]
1088    /// field which limits width and height separately, this field limits the
1089    /// total number of pixels.
1090    ///
1091    /// In contrast to
1092    /// [`fuchsia.sysmem/BufferMemoryConstraints.max_size_bytes`], this field
1093    /// doesn't limit the number of non-pixel padding bytes after each row of
1094    /// pixels, and doesn't limit the number of non-pixel bytes in the case of
1095    /// tiled `pixel_format_modifier`.
1096    ///
1097    /// Very narrow or very short image aspect ratios can have worse performance
1098    /// per pixel in comparison to more typical aspect ratios. Padding and/or
1099    /// memory bandwidth overheads tend to increase for extreme aspect ratios.
1100    /// Participants can indicate lack of support for very narrow or very short
1101    /// dimensions using ['fuchsia.sysmem/ImageFormatConstraints.min_size`].
1102    ///
1103    /// Sending to sysmem, un-set is treated as 0xFFFFFFFF.
1104    ///
1105    /// Receiving from sysmem, this field will always be set, and can be set to
1106    /// 0xFFFFFFFF.
1107    pub max_width_times_height: Option<u64>,
1108    /// Alignment requirements on the image `size`.
1109    ///
1110    /// * `size.width % size_alignment.width` must be 0.
1111    /// * `size.height % size_alignment.height` must be 0.
1112    ///
1113    /// Un-set is treated as 1, 1.
1114    pub size_alignment: Option<fidl_fuchsia_math__common::SizeU>,
1115    /// Alignment requirements on `display_rect`.
1116    ///
1117    /// * `display_rect.x % display_rect_alignment.width` must be 0.
1118    /// * `display_rect.y % display_rect_alignment.height` must be 0.
1119    /// * `display_rect.width % display_rect_alignment.width` must be 0.
1120    /// * `display_rect.height % display_rect_alignment.height` must be 0.
1121    ///
1122    /// Un-set is treated as 1, 1.
1123    pub display_rect_alignment: Option<fidl_fuchsia_math__common::SizeU>,
1124    /// These fields can be used to ensure the aggregated constraints have
1125    /// `min_size` and `max_size` such that both `required_min_size` and
1126    /// `required_max_size` (and anything in between that satisfies alignment
1127    /// requirements) are permitted values of `ImageFormat.size`.
1128    ///
1129    /// For example, a producer video decoder doesn't want to constrain the
1130    /// allowed `ImageFormat.size`, as a compressed stream can change dimensions
1131    /// mid-stream, but the producer video decoder needs to ensure that the
1132    /// aggregated constraints allow for at least the current dimensions of
1133    /// uncompressed frames at the current position in the stream.
1134    ///
1135    /// As another example, an initiator that's intending to decode video may
1136    /// know what the maximum expected size of frames in the stream(s) can be,
1137    /// so by setting `required_max_size`, can ensure that the allocated buffers
1138    /// are large enough to support that max `size`. In addition on successful
1139    /// allocation the initiator also knows that the consumer participants are
1140    /// ok with receiving up to that max `size`.
1141    ///
1142    /// It's much more common for a producer or initiator to set these fields
1143    /// than for a consumer to set these fields.
1144    ///
1145    /// While `min_size` and `max_size` aggregate by effectively taking the
1146    /// intersection, the `required_min_size` and `required_max_size` aggregate
1147    /// by effectively taking the union.
1148    ///
1149    /// This field aggregates by taking the min per component, and
1150    /// required_max_size aggregates by taking the max per component.
1151    ///
1152    /// Un-set is treated as 0xFFFFFFFF, 0xFFFFFFFF.
1153    pub required_min_size: Option<fidl_fuchsia_math__common::SizeU>,
1154    /// See also `required_min_size`. Un-set is treated as 0, 0.
1155    pub required_max_size: Option<fidl_fuchsia_math__common::SizeU>,
1156    /// `fuchsia_images2.ImageFormat.bytes_per_row % bytes_per_row_divisor` must
1157    /// be 0. Un-set is treated as 1.
1158    ///
1159    /// Prefer to use `require_bytes_per_row_at_pixel_boundary` when the intent
1160    /// is to ensure that `bytes_per_row' will be a multiple of the pixel size
1161    /// in bytes.
1162    ///
1163    /// Prefer to use `size_alignment.width` when the intent is to ensure that
1164    /// the width in pixels is aligned. In contrast, this field can specify that
1165    /// the "stride in bytes" (byte offset from start of image to start of row n
1166    /// minus byte offset from start of image to start of row n-1, with result
1167    /// in bytes) needs to be aligned to the specified number of bytes. For
1168    /// example, when `PixelFormat.BGR24` (24 bit color; 3 bytes per pixel) is
1169    /// used, it's not uncommon for a participant to need each row of pixels to
1170    /// start at a 4 byte aligned offset from the start of the image, which can
1171    /// imply some padding bytes at the end of each row of pixels, before the
1172    /// start of the next row of pixels.
1173    ///
1174    /// While any value of `bytes_per_row_divisor` could instead be enforced by
1175    /// setting `size_alignment.width` to the least-common-multiple of the
1176    /// "stride bytes per width pixel" and the stride alignment requirement,
1177    /// enforcing the stride alignment requirement that way can lead to more
1178    /// padding than necessary (implying larger buffer than necessary), and can
1179    /// also result in a "fake" `size.width`; this field exists to avoid that
1180    /// situation. Instead, the stride alignment requirement in bytes is
1181    /// specified directly here.
1182    pub bytes_per_row_divisor: Option<u32>,
1183    /// `vmo_usable_start % start_offset_divisor` must be 0. Un-set is treated
1184    /// as 1.
1185    ///
1186    /// Producer participants are discouraged from setting non-zero image start
1187    /// offset (from the buffer base) unless actually required, as not all
1188    /// participants correctly handle non-zero image start offset.
1189    pub start_offset_divisor: Option<u32>,
1190    /// The (additional) [`fuchsia.sysmem2/PixelFormatAndModifier`]s for which
1191    /// the following constraints apply.
1192    ///
1193    /// As a non-limiting example, if a participant only wants to set a single
1194    /// `PixelFormatAndModifier` for this
1195    /// [`fuchsia.sysmem2/ImageFormatConstraints`], the participant can either
1196    /// (a) use `pixel_format` and `pixel_format_modifier` fields to specify the
1197    /// fields of the one `PixelFormatAndModifier` and leave
1198    /// `pixel_format_and_modifiers` un-set, or (b) leave `pixel_format` and
1199    /// `pixel_format_modifier` fields un-set and put the one
1200    /// `PixelFormatAndModifier` in `pixel_format_and_modifiers`.
1201    ///
1202    /// If `pixel_format` is set, the server will take pixel_format and
1203    /// pixel_format_modifier fields (un-setting them in the process), pack them
1204    /// into a `PixelFormatAndModifier`, and move it into this vector as one
1205    /// additional entry, with an overall size limit of
1206    /// `MAX_COUNT_PIXEL_FORMAT_AND_MODIFIERS + 1`.
1207    ///
1208    /// After the server moves `pixel_format`, `pixel_format_modifier` into one
1209    /// additional entry in this vector, this vector must not be empty. When the
1210    /// resulting list has more than 1 item, the entries in this vector are
1211    /// equivalent to (shorthand for) listing (size) separate
1212    /// `ImageFormatConstraints` entries, one per `pixel_format_and_modifiers`
1213    /// entry, each with one `PixelFormatAndModifier`, where all the separate
1214    /// `ImageFormatConstraints` entries have the same constraints (compared
1215    /// field by field, not including `pixel_format`, `pixel_format_modifier`,
1216    /// or `pixel_format_and_modifiers` fields).
1217    ///
1218    /// In `SetConstraints` message, each entry specifies a
1219    /// `PixelFormatAndModifier` which is acceptable to the participant
1220    /// (assuming the following constraints fields are also satisfied).
1221    ///
1222    /// In the response to `WaitForAllBuffersAllocated`, this field will be
1223    /// un-set and the one chosen `PixelFormatAndModifier` will be indicated
1224    /// using the `pixel_format` and `pixel_format_modifier` fields.
1225    ///
1226    /// All the `PixelFormatAndModifiers` in a `SetConstraints` message from a
1227    /// participant must be unique across all the entries under
1228    /// `image_format_constraints`. If
1229    /// [`fuchsia.images2/PixelFormat.DO_NOT_CARE`] is used in an entry, there
1230    /// must not be any other entry (considering all the entries under
1231    /// `image_format_constraints`) with matching `pixel_format_modifier`. If
1232    /// [`fuchsia.images2/PixelFormatModifier.DO_NOT_CARE`] is used, there must
1233    /// not be any other entry (considering all the entries under
1234    /// `image_format_constraints`) with matching `pixel_format`.
1235    ///
1236    /// A `PixelFormatAndModifier` value with either
1237    /// [`fuchsia.images2/PixelFormat.DO_NOT_CARE`] or
1238    /// [`fuchsia.images2/PixelFormatModifier.DO_NOT_CARE`] (but not both, for
1239    /// purposes of this example) can be combined with a
1240    /// `PixelFormatAndModifier` from a separate participant with the other
1241    /// field indicating "do not care", resulting in a complete
1242    /// `PixelFormatAndModifier` that can succeed allocation. However, at least
1243    /// for now, it's not permitted for a single participant to specify two
1244    /// separate `PixelFormatAndModifier` values which have "do not care" in
1245    /// different fields. This does not prohibit a single
1246    /// `PixelFormatAndModifier` with both `PixelFormat.DO_NOT_CARE` and
1247    /// `PixelFormatModifier.DO_NOT_CARE` (which is only a single
1248    /// `PixelFormatAndModifier` value). If a client really needs to specify
1249    /// some constraints relevant to `pixel_format`(s) with
1250    /// `pixel_format_modifier` `DO_NOT_CARE`, and other constraints relevant to
1251    /// `pixel_format_modifier`(s) with `pixel_format` `DO_NOT_CARE`, the client
1252    /// can do so by duplicating the token and using/driving two separate
1253    /// participants.
1254    ///
1255    /// See also `pixel_format` for more comments relevant to multiple
1256    /// `PixelFormatAndModifier`s in a single `ImageFormatConstraints`.
1257    pub pixel_format_and_modifiers: Option<Vec<PixelFormatAndModifier>>,
1258    /// Iff set and true, bytes_per_row_divisor in the resulting
1259    /// ImageFormatConstraints is guaranteed to be a value which requires
1260    /// bytes_per_row to be an integral number of pixels. This can result in
1261    /// more padding at the end of each row than when this field is not set to
1262    /// true, but ensures that the stride can be expressed as an integral number
1263    /// of pixels.
1264    ///
1265    /// For example, if the chosen `PixelFormat` is `B8G8R8`, if this field is
1266    /// set to true, the resulting bytes_per_row_divisor will be a multiple of
1267    /// 3. In this example, if another participant sets `bytes_per_row_divisor`
1268    /// to 4, the resulting `bytes_per_row_divisor` will be a multiple of 12.
1269    pub require_bytes_per_row_at_pixel_boundary: Option<bool>,
1270    /// If unset, any A channel of any format in this ImageFormatConstraints is
1271    /// is ignored or not ignored according to semantics conveyed out of band.
1272    ///
1273    /// If set to false, the A channel of any format in this
1274    /// ImageFormatConstraints is arbitrary values that don't mean anything.
1275    /// Producers don't need to ensure any particular values in the A channel
1276    /// and consumers should ignore the A channel. This is the same thing as
1277    /// calling the 'A' channel 'X' instead.
1278    ///
1279    /// If set to true, the A channel of any format in this
1280    /// ImageFormatConstraints is set to meaningful values. A producer should
1281    /// fill out the A values, and a consumer should pay attention to the A
1282    /// values as appropriate.
1283    ///
1284    /// If set values of this field don't match for the same pixel format and
1285    /// modifier, that format and modifier will be eliminated from
1286    /// consideration.
1287    ///
1288    /// A participant that knows that the semantics of the A channel are
1289    /// conveyed via out of band means can leave this field un-set, even if the
1290    /// out of band means is already known to specify alpha present or not
1291    /// present, but in this situation it's also ok to fill out this field for
1292    /// informational / debugging purposes.
1293    ///
1294    /// If no participant sets this field, the default is un-set.
1295    ///
1296    /// If the format chosen for allocation doesn't have an A channel, this
1297    /// field will be un-set in the allocation result.
1298    pub is_alpha_present: Option<bool>,
1299    #[doc(hidden)]
1300    pub __source_breaking: fidl::marker::SourceBreaking,
1301}
1302
1303impl fidl::Persistable for ImageFormatConstraints {}
1304
1305#[derive(Clone, Debug, Default, PartialEq)]
1306pub struct NodeSetDebugClientInfoRequest {
1307    pub name: Option<String>,
1308    pub id: Option<u64>,
1309    #[doc(hidden)]
1310    pub __source_breaking: fidl::marker::SourceBreaking,
1311}
1312
1313impl fidl::Persistable for NodeSetDebugClientInfoRequest {}
1314
1315#[derive(Clone, Debug, Default, PartialEq)]
1316pub struct NodeSetDebugTimeoutLogDeadlineRequest {
1317    pub deadline: Option<i64>,
1318    #[doc(hidden)]
1319    pub __source_breaking: fidl::marker::SourceBreaking,
1320}
1321
1322impl fidl::Persistable for NodeSetDebugTimeoutLogDeadlineRequest {}
1323
1324#[derive(Clone, Debug, Default, PartialEq)]
1325pub struct NodeSetNameRequest {
1326    pub priority: Option<u32>,
1327    pub name: Option<String>,
1328    #[doc(hidden)]
1329    pub __source_breaking: fidl::marker::SourceBreaking,
1330}
1331
1332impl fidl::Persistable for NodeSetNameRequest {}
1333
1334#[derive(Clone, Debug, Default, PartialEq)]
1335pub struct NodeGetBufferCollectionIdResponse {
1336    pub buffer_collection_id: Option<u64>,
1337    #[doc(hidden)]
1338    pub __source_breaking: fidl::marker::SourceBreaking,
1339}
1340
1341impl fidl::Persistable for NodeGetBufferCollectionIdResponse {}
1342
1343#[derive(Clone, Debug, Default, PartialEq)]
1344pub struct NodeIsAlternateForResponse {
1345    pub is_alternate: Option<bool>,
1346    #[doc(hidden)]
1347    pub __source_breaking: fidl::marker::SourceBreaking,
1348}
1349
1350impl fidl::Persistable for NodeIsAlternateForResponse {}
1351
1352#[derive(Clone, Debug, Default, PartialEq)]
1353pub struct SecureHeapAndRange {
1354    pub heap: Option<Heap>,
1355    pub range: Option<SecureHeapRange>,
1356    #[doc(hidden)]
1357    pub __source_breaking: fidl::marker::SourceBreaking,
1358}
1359
1360impl fidl::Persistable for SecureHeapAndRange {}
1361
1362#[derive(Clone, Debug, Default, PartialEq)]
1363pub struct SecureHeapAndRangeModification {
1364    pub heap: Option<Heap>,
1365    pub old_range: Option<SecureHeapRange>,
1366    pub new_range: Option<SecureHeapRange>,
1367    #[doc(hidden)]
1368    pub __source_breaking: fidl::marker::SourceBreaking,
1369}
1370
1371impl fidl::Persistable for SecureHeapAndRangeModification {}
1372
1373#[derive(Clone, Debug, Default, PartialEq)]
1374pub struct SecureHeapAndRanges {
1375    /// This is which secure/protected heap.
1376    pub heap: Option<Heap>,
1377    /// The list of physical ranges.  This list must be sorted by
1378    /// physical_address (lower first), and must not have any overlapping
1379    /// ranges.  Ranges that are directly adjacent are allowed (not
1380    /// overlapping).
1381    pub ranges: Option<Vec<SecureHeapRange>>,
1382    #[doc(hidden)]
1383    pub __source_breaking: fidl::marker::SourceBreaking,
1384}
1385
1386impl fidl::Persistable for SecureHeapAndRanges {}
1387
1388#[derive(Clone, Debug, Default, PartialEq)]
1389pub struct SecureHeapProperties {
1390    /// The Heap is repeated here for convenience.
1391    pub heap: Option<Heap>,
1392    /// If true, more than one call to SetPhysicalSecureHeap() for the same
1393    /// heap is allowed.  If false, only one SetPhyscialSecureHeap() call is
1394    /// allowed, and no calls to DeleteSecureHeapPhysicalRange() or
1395    /// ModifySecureHeapPhysicalRange() are allowed.  Even when this is false,
1396    /// the SecureMem server (driver) is still responsible for de-protecting
1397    /// just before warm reboot if protected ranges would not otherwise be
1398    /// cleaned up during a warm reboot.
1399    pub dynamic_protection_ranges: Option<bool>,
1400    /// The granularity of protection ranges.  If the granularity of start is
1401    /// different than granularity of end or length, then this is the max
1402    /// granularity value among those values.
1403    ///
1404    /// This must be a power of 2.  The client must not request ranges that
1405    /// specify smaller granularity.
1406    ///
1407    /// This must be at least zx_system_page_size() even if the HW can do
1408    /// smaller granularity.
1409    pub protected_range_granularity: Option<u32>,
1410    /// The SecureMem server should not count reserved ranges that the SecureMem
1411    /// server uses internally to get from range set A to range set B, if the
1412    /// SecureMem server needs to do any emulation of that sort.  Normally such
1413    /// emulation by the SecureMem server is unnecessary.  If any ranges are
1414    /// reserved by the SecureMem server, those reserved ranges are not
1415    /// available for use by the SecureMem client.
1416    ///
1417    /// If the number of ranges is limited only by available memory, it's ok for
1418    /// the SecureMem server to report 0xFFFFFFFFFFFFFFFF for this value.  The
1419    /// field must still be set.  As usual, the SecureMem server should ensure
1420    /// that SetPhysicalSecureHeapRanges() succeeds or fails atomically (either
1421    /// fully updates or rolls back before completing).
1422    pub max_protected_range_count: Option<u64>,
1423    /// Iff true, ModifySecureHeapPhysicalRange() is implemented.  Calling
1424    /// ModifySecureHeapPhysicalRange() when is_mod_protected_range_available
1425    /// is false is prohibited.  Don't attempt to detect availability of
1426    /// ModifySecureHeapPhysicalRange() by calling it to see if it fails; it
1427    /// may ZX_PANIC().
1428    pub is_mod_protected_range_available: Option<bool>,
1429    #[doc(hidden)]
1430    pub __source_breaking: fidl::marker::SourceBreaking,
1431}
1432
1433impl fidl::Persistable for SecureHeapProperties {}
1434
1435#[derive(Clone, Debug, Default, PartialEq)]
1436pub struct SecureHeapRange {
1437    /// Must be aligned to at least heap_range_granularity.
1438    pub physical_address: Option<u64>,
1439    /// Must be aligned to at least heap_range_granularity.
1440    pub size_bytes: Option<u64>,
1441    #[doc(hidden)]
1442    pub __source_breaking: fidl::marker::SourceBreaking,
1443}
1444
1445impl fidl::Persistable for SecureHeapRange {}
1446
1447#[derive(Clone, Debug, Default, PartialEq)]
1448pub struct SecureMemAddSecureHeapPhysicalRangeRequest {
1449    pub heap_range: Option<SecureHeapAndRange>,
1450    #[doc(hidden)]
1451    pub __source_breaking: fidl::marker::SourceBreaking,
1452}
1453
1454impl fidl::Persistable for SecureMemAddSecureHeapPhysicalRangeRequest {}
1455
1456#[derive(Clone, Debug, Default, PartialEq)]
1457pub struct SecureMemDeleteSecureHeapPhysicalRangeRequest {
1458    pub heap_range: Option<SecureHeapAndRange>,
1459    #[doc(hidden)]
1460    pub __source_breaking: fidl::marker::SourceBreaking,
1461}
1462
1463impl fidl::Persistable for SecureMemDeleteSecureHeapPhysicalRangeRequest {}
1464
1465#[derive(Clone, Debug, Default, PartialEq)]
1466pub struct SecureMemGetPhysicalSecureHeapPropertiesRequest {
1467    pub entire_heap: Option<SecureHeapAndRange>,
1468    #[doc(hidden)]
1469    pub __source_breaking: fidl::marker::SourceBreaking,
1470}
1471
1472impl fidl::Persistable for SecureMemGetPhysicalSecureHeapPropertiesRequest {}
1473
1474#[derive(Clone, Debug, Default, PartialEq)]
1475pub struct SecureMemModifySecureHeapPhysicalRangeRequest {
1476    pub range_modification: Option<SecureHeapAndRangeModification>,
1477    #[doc(hidden)]
1478    pub __source_breaking: fidl::marker::SourceBreaking,
1479}
1480
1481impl fidl::Persistable for SecureMemModifySecureHeapPhysicalRangeRequest {}
1482
1483#[derive(Clone, Debug, Default, PartialEq)]
1484pub struct SecureMemZeroSubRangeRequest {
1485    pub is_covering_range_explicit: Option<bool>,
1486    pub heap_range: Option<SecureHeapAndRange>,
1487    #[doc(hidden)]
1488    pub __source_breaking: fidl::marker::SourceBreaking,
1489}
1490
1491impl fidl::Persistable for SecureMemZeroSubRangeRequest {}
1492
1493#[derive(Clone, Debug, Default, PartialEq)]
1494pub struct SecureMemGetDynamicSecureHeapsResponse {
1495    pub heaps: Option<Vec<DynamicSecureHeap>>,
1496    #[doc(hidden)]
1497    pub __source_breaking: fidl::marker::SourceBreaking,
1498}
1499
1500impl fidl::Persistable for SecureMemGetDynamicSecureHeapsResponse {}
1501
1502#[derive(Clone, Debug, Default, PartialEq)]
1503pub struct SecureMemGetPhysicalSecureHeapPropertiesResponse {
1504    pub properties: Option<SecureHeapProperties>,
1505    #[doc(hidden)]
1506    pub __source_breaking: fidl::marker::SourceBreaking,
1507}
1508
1509impl fidl::Persistable for SecureMemGetPhysicalSecureHeapPropertiesResponse {}
1510
1511#[derive(Clone, Debug, Default, PartialEq)]
1512pub struct SecureMemGetPhysicalSecureHeapsResponse {
1513    pub heaps: Option<Vec<SecureHeapAndRanges>>,
1514    #[doc(hidden)]
1515    pub __source_breaking: fidl::marker::SourceBreaking,
1516}
1517
1518impl fidl::Persistable for SecureMemGetPhysicalSecureHeapsResponse {}
1519
1520/// These settings and constraints apply to all the buffers in the collection.
1521#[derive(Clone, Debug, Default, PartialEq)]
1522pub struct SingleBufferSettings {
1523    /// This field will always be set by sysmem.
1524    pub buffer_settings: Option<BufferMemorySettings>,
1525    /// Buffers holding data that is not uncompressed image data will not have
1526    /// this field set.  Buffers holding data that is uncompressed image data
1527    /// _may_ have this field set.
1528    ///
1529    /// At least for now, changing the PixelFormat requires re-allocating
1530    /// buffers.
1531    ///
1532    /// If un-set, there are no image format constraints.
1533    pub image_format_constraints: Option<ImageFormatConstraints>,
1534    #[doc(hidden)]
1535    pub __source_breaking: fidl::marker::SourceBreaking,
1536}
1537
1538impl fidl::Persistable for SingleBufferSettings {}
1539
1540pub mod allocator_ordinals {
1541    pub const ALLOCATE_NON_SHARED_COLLECTION: u64 = 0x5ca681f025a80e44;
1542    pub const ALLOCATE_SHARED_COLLECTION: u64 = 0x11a19ff51f0b49c1;
1543    pub const BIND_SHARED_COLLECTION: u64 = 0x550916b0dc1d5b4e;
1544    pub const VALIDATE_BUFFER_COLLECTION_TOKEN: u64 = 0x4c5ee91b02a7e68d;
1545    pub const SET_DEBUG_CLIENT_INFO: u64 = 0x6f68f19a3f509c4d;
1546    pub const GET_VMO_INFO: u64 = 0x21a881120aa0ddf9;
1547}
1548
1549pub mod buffer_collection_ordinals {
1550    pub const SYNC: u64 = 0x11ac2555cf575b54;
1551    pub const RELEASE: u64 = 0x6a5cae7d6d6e04c6;
1552    pub const SET_NAME: u64 = 0xb41f1624f48c1e9;
1553    pub const SET_DEBUG_CLIENT_INFO: u64 = 0x5cde8914608d99b1;
1554    pub const SET_DEBUG_TIMEOUT_LOG_DEADLINE: u64 = 0x716b0af13d5c0806;
1555    pub const SET_VERBOSE_LOGGING: u64 = 0x5209c77415b4dfad;
1556    pub const GET_NODE_REF: u64 = 0x5b3d0e51614df053;
1557    pub const IS_ALTERNATE_FOR: u64 = 0x3a58e00157e0825;
1558    pub const GET_BUFFER_COLLECTION_ID: u64 = 0x77d19a494b78ba8c;
1559    pub const SET_WEAK: u64 = 0x22dd3ea514eeffe1;
1560    pub const SET_WEAK_OK: u64 = 0x38a44fc4d7724be9;
1561    pub const ATTACH_NODE_TRACKING: u64 = 0x3f22f2a293d3cdac;
1562    pub const SET_CONSTRAINTS: u64 = 0x1fde0f19d650197b;
1563    pub const WAIT_FOR_ALL_BUFFERS_ALLOCATED: u64 = 0x62300344b61404e;
1564    pub const CHECK_ALL_BUFFERS_ALLOCATED: u64 = 0x35a5fe77ce939c10;
1565    pub const ATTACH_TOKEN: u64 = 0x46ac7d0008492982;
1566    pub const ATTACH_LIFETIME_TRACKING: u64 = 0x3ecb510113116dcf;
1567}
1568
1569pub mod buffer_collection_token_ordinals {
1570    pub const SYNC: u64 = 0x11ac2555cf575b54;
1571    pub const RELEASE: u64 = 0x6a5cae7d6d6e04c6;
1572    pub const SET_NAME: u64 = 0xb41f1624f48c1e9;
1573    pub const SET_DEBUG_CLIENT_INFO: u64 = 0x5cde8914608d99b1;
1574    pub const SET_DEBUG_TIMEOUT_LOG_DEADLINE: u64 = 0x716b0af13d5c0806;
1575    pub const SET_VERBOSE_LOGGING: u64 = 0x5209c77415b4dfad;
1576    pub const GET_NODE_REF: u64 = 0x5b3d0e51614df053;
1577    pub const IS_ALTERNATE_FOR: u64 = 0x3a58e00157e0825;
1578    pub const GET_BUFFER_COLLECTION_ID: u64 = 0x77d19a494b78ba8c;
1579    pub const SET_WEAK: u64 = 0x22dd3ea514eeffe1;
1580    pub const SET_WEAK_OK: u64 = 0x38a44fc4d7724be9;
1581    pub const ATTACH_NODE_TRACKING: u64 = 0x3f22f2a293d3cdac;
1582    pub const DUPLICATE_SYNC: u64 = 0x1c1af9919d1ca45c;
1583    pub const DUPLICATE: u64 = 0x73e78f92ee7fb887;
1584    pub const SET_DISPENSABLE: u64 = 0x228acf979254df8b;
1585    pub const CREATE_BUFFER_COLLECTION_TOKEN_GROUP: u64 = 0x30f8d48e77bd36f2;
1586}
1587
1588pub mod buffer_collection_token_group_ordinals {
1589    pub const SYNC: u64 = 0x11ac2555cf575b54;
1590    pub const RELEASE: u64 = 0x6a5cae7d6d6e04c6;
1591    pub const SET_NAME: u64 = 0xb41f1624f48c1e9;
1592    pub const SET_DEBUG_CLIENT_INFO: u64 = 0x5cde8914608d99b1;
1593    pub const SET_DEBUG_TIMEOUT_LOG_DEADLINE: u64 = 0x716b0af13d5c0806;
1594    pub const SET_VERBOSE_LOGGING: u64 = 0x5209c77415b4dfad;
1595    pub const GET_NODE_REF: u64 = 0x5b3d0e51614df053;
1596    pub const IS_ALTERNATE_FOR: u64 = 0x3a58e00157e0825;
1597    pub const GET_BUFFER_COLLECTION_ID: u64 = 0x77d19a494b78ba8c;
1598    pub const SET_WEAK: u64 = 0x22dd3ea514eeffe1;
1599    pub const SET_WEAK_OK: u64 = 0x38a44fc4d7724be9;
1600    pub const ATTACH_NODE_TRACKING: u64 = 0x3f22f2a293d3cdac;
1601    pub const CREATE_CHILD: u64 = 0x41a0075d419f30c5;
1602    pub const CREATE_CHILDREN_SYNC: u64 = 0x15dea448c536070a;
1603    pub const ALL_CHILDREN_PRESENT: u64 = 0x5c327e4a23391312;
1604}
1605
1606pub mod node_ordinals {
1607    pub const SYNC: u64 = 0x11ac2555cf575b54;
1608    pub const RELEASE: u64 = 0x6a5cae7d6d6e04c6;
1609    pub const SET_NAME: u64 = 0xb41f1624f48c1e9;
1610    pub const SET_DEBUG_CLIENT_INFO: u64 = 0x5cde8914608d99b1;
1611    pub const SET_DEBUG_TIMEOUT_LOG_DEADLINE: u64 = 0x716b0af13d5c0806;
1612    pub const SET_VERBOSE_LOGGING: u64 = 0x5209c77415b4dfad;
1613    pub const GET_NODE_REF: u64 = 0x5b3d0e51614df053;
1614    pub const IS_ALTERNATE_FOR: u64 = 0x3a58e00157e0825;
1615    pub const GET_BUFFER_COLLECTION_ID: u64 = 0x77d19a494b78ba8c;
1616    pub const SET_WEAK: u64 = 0x22dd3ea514eeffe1;
1617    pub const SET_WEAK_OK: u64 = 0x38a44fc4d7724be9;
1618    pub const ATTACH_NODE_TRACKING: u64 = 0x3f22f2a293d3cdac;
1619}
1620
1621pub mod secure_mem_ordinals {
1622    pub const GET_PHYSICAL_SECURE_HEAPS: u64 = 0x38716300592073e3;
1623    pub const GET_DYNAMIC_SECURE_HEAPS: u64 = 0x1190847f99952834;
1624    pub const GET_PHYSICAL_SECURE_HEAP_PROPERTIES: u64 = 0xc6f06889009c7bc;
1625    pub const ADD_SECURE_HEAP_PHYSICAL_RANGE: u64 = 0x35f695b9b6c7217a;
1626    pub const DELETE_SECURE_HEAP_PHYSICAL_RANGE: u64 = 0xeaa58c650264c9e;
1627    pub const MODIFY_SECURE_HEAP_PHYSICAL_RANGE: u64 = 0x60b7448aa1187734;
1628    pub const ZERO_SUB_RANGE: u64 = 0x5b25b7901a385ce5;
1629}
1630
1631mod internal {
1632    use super::*;
1633    unsafe impl fidl::encoding::TypeMarker for CoherencyDomain {
1634        type Owned = Self;
1635
1636        #[inline(always)]
1637        fn inline_align(_context: fidl::encoding::Context) -> usize {
1638            std::mem::align_of::<u32>()
1639        }
1640
1641        #[inline(always)]
1642        fn inline_size(_context: fidl::encoding::Context) -> usize {
1643            std::mem::size_of::<u32>()
1644        }
1645
1646        #[inline(always)]
1647        fn encode_is_copy() -> bool {
1648            false
1649        }
1650
1651        #[inline(always)]
1652        fn decode_is_copy() -> bool {
1653            false
1654        }
1655    }
1656
1657    impl fidl::encoding::ValueTypeMarker for CoherencyDomain {
1658        type Borrowed<'a> = Self;
1659        #[inline(always)]
1660        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1661            *value
1662        }
1663    }
1664
1665    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1666        for CoherencyDomain
1667    {
1668        #[inline]
1669        unsafe fn encode(
1670            self,
1671            encoder: &mut fidl::encoding::Encoder<'_, D>,
1672            offset: usize,
1673            _depth: fidl::encoding::Depth,
1674        ) -> fidl::Result<()> {
1675            encoder.debug_check_bounds::<Self>(offset);
1676            encoder.write_num(self.into_primitive(), offset);
1677            Ok(())
1678        }
1679    }
1680
1681    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CoherencyDomain {
1682        #[inline(always)]
1683        fn new_empty() -> Self {
1684            Self::unknown()
1685        }
1686
1687        #[inline]
1688        unsafe fn decode(
1689            &mut self,
1690            decoder: &mut fidl::encoding::Decoder<'_, D>,
1691            offset: usize,
1692            _depth: fidl::encoding::Depth,
1693        ) -> fidl::Result<()> {
1694            decoder.debug_check_bounds::<Self>(offset);
1695            let prim = decoder.read_num::<u32>(offset);
1696
1697            *self = Self::from_primitive_allow_unknown(prim);
1698            Ok(())
1699        }
1700    }
1701    unsafe impl fidl::encoding::TypeMarker for Error {
1702        type Owned = Self;
1703
1704        #[inline(always)]
1705        fn inline_align(_context: fidl::encoding::Context) -> usize {
1706            std::mem::align_of::<u32>()
1707        }
1708
1709        #[inline(always)]
1710        fn inline_size(_context: fidl::encoding::Context) -> usize {
1711            std::mem::size_of::<u32>()
1712        }
1713
1714        #[inline(always)]
1715        fn encode_is_copy() -> bool {
1716            false
1717        }
1718
1719        #[inline(always)]
1720        fn decode_is_copy() -> bool {
1721            false
1722        }
1723    }
1724
1725    impl fidl::encoding::ValueTypeMarker for Error {
1726        type Borrowed<'a> = Self;
1727        #[inline(always)]
1728        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1729            *value
1730        }
1731    }
1732
1733    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
1734        #[inline]
1735        unsafe fn encode(
1736            self,
1737            encoder: &mut fidl::encoding::Encoder<'_, D>,
1738            offset: usize,
1739            _depth: fidl::encoding::Depth,
1740        ) -> fidl::Result<()> {
1741            encoder.debug_check_bounds::<Self>(offset);
1742            encoder.write_num(self.into_primitive(), offset);
1743            Ok(())
1744        }
1745    }
1746
1747    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
1748        #[inline(always)]
1749        fn new_empty() -> Self {
1750            Self::unknown()
1751        }
1752
1753        #[inline]
1754        unsafe fn decode(
1755            &mut self,
1756            decoder: &mut fidl::encoding::Decoder<'_, D>,
1757            offset: usize,
1758            _depth: fidl::encoding::Depth,
1759        ) -> fidl::Result<()> {
1760            decoder.debug_check_bounds::<Self>(offset);
1761            let prim = decoder.read_num::<u32>(offset);
1762
1763            *self = Self::from_primitive_allow_unknown(prim);
1764            Ok(())
1765        }
1766    }
1767
1768    impl fidl::encoding::ValueTypeMarker for PixelFormatAndModifier {
1769        type Borrowed<'a> = &'a Self;
1770        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1771            value
1772        }
1773    }
1774
1775    unsafe impl fidl::encoding::TypeMarker for PixelFormatAndModifier {
1776        type Owned = Self;
1777
1778        #[inline(always)]
1779        fn inline_align(_context: fidl::encoding::Context) -> usize {
1780            8
1781        }
1782
1783        #[inline(always)]
1784        fn inline_size(_context: fidl::encoding::Context) -> usize {
1785            16
1786        }
1787    }
1788
1789    unsafe impl<D: fidl::encoding::ResourceDialect>
1790        fidl::encoding::Encode<PixelFormatAndModifier, D> for &PixelFormatAndModifier
1791    {
1792        #[inline]
1793        unsafe fn encode(
1794            self,
1795            encoder: &mut fidl::encoding::Encoder<'_, D>,
1796            offset: usize,
1797            _depth: fidl::encoding::Depth,
1798        ) -> fidl::Result<()> {
1799            encoder.debug_check_bounds::<PixelFormatAndModifier>(offset);
1800            // Delegate to tuple encoding.
1801            fidl::encoding::Encode::<PixelFormatAndModifier, D>::encode(
1802                (
1803                    <fidl_fuchsia_images2__common::PixelFormat as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_format),
1804                    <fidl_fuchsia_images2__common::PixelFormatModifier as fidl::encoding::ValueTypeMarker>::borrow(&self.pixel_format_modifier),
1805                ),
1806                encoder, offset, _depth
1807            )
1808        }
1809    }
1810    unsafe impl<
1811            D: fidl::encoding::ResourceDialect,
1812            T0: fidl::encoding::Encode<fidl_fuchsia_images2__common::PixelFormat, D>,
1813            T1: fidl::encoding::Encode<fidl_fuchsia_images2__common::PixelFormatModifier, D>,
1814        > fidl::encoding::Encode<PixelFormatAndModifier, D> for (T0, T1)
1815    {
1816        #[inline]
1817        unsafe fn encode(
1818            self,
1819            encoder: &mut fidl::encoding::Encoder<'_, D>,
1820            offset: usize,
1821            depth: fidl::encoding::Depth,
1822        ) -> fidl::Result<()> {
1823            encoder.debug_check_bounds::<PixelFormatAndModifier>(offset);
1824            // Zero out padding regions. There's no need to apply masks
1825            // because the unmasked parts will be overwritten by fields.
1826            unsafe {
1827                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1828                (ptr as *mut u64).write_unaligned(0);
1829            }
1830            // Write the fields.
1831            self.0.encode(encoder, offset + 0, depth)?;
1832            self.1.encode(encoder, offset + 8, depth)?;
1833            Ok(())
1834        }
1835    }
1836
1837    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1838        for PixelFormatAndModifier
1839    {
1840        #[inline(always)]
1841        fn new_empty() -> Self {
1842            Self {
1843                pixel_format: fidl::new_empty!(fidl_fuchsia_images2__common::PixelFormat, D),
1844                pixel_format_modifier: fidl::new_empty!(
1845                    fidl_fuchsia_images2__common::PixelFormatModifier,
1846                    D
1847                ),
1848            }
1849        }
1850
1851        #[inline]
1852        unsafe fn decode(
1853            &mut self,
1854            decoder: &mut fidl::encoding::Decoder<'_, D>,
1855            offset: usize,
1856            _depth: fidl::encoding::Depth,
1857        ) -> fidl::Result<()> {
1858            decoder.debug_check_bounds::<Self>(offset);
1859            // Verify that padding bytes are zero.
1860            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1861            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1862            let mask = 0xffffffff00000000u64;
1863            let maskedval = padval & mask;
1864            if maskedval != 0 {
1865                return Err(fidl::Error::NonZeroPadding {
1866                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1867                });
1868            }
1869            fidl::decode!(
1870                fidl_fuchsia_images2__common::PixelFormat,
1871                D,
1872                &mut self.pixel_format,
1873                decoder,
1874                offset + 0,
1875                _depth
1876            )?;
1877            fidl::decode!(
1878                fidl_fuchsia_images2__common::PixelFormatModifier,
1879                D,
1880                &mut self.pixel_format_modifier,
1881                decoder,
1882                offset + 8,
1883                _depth
1884            )?;
1885            Ok(())
1886        }
1887    }
1888
1889    impl AllocatorSetDebugClientInfoRequest {
1890        #[inline(always)]
1891        fn max_ordinal_present(&self) -> u64 {
1892            if let Some(_) = self.id {
1893                return 2;
1894            }
1895            if let Some(_) = self.name {
1896                return 1;
1897            }
1898            0
1899        }
1900    }
1901
1902    impl fidl::encoding::ValueTypeMarker for AllocatorSetDebugClientInfoRequest {
1903        type Borrowed<'a> = &'a Self;
1904        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1905            value
1906        }
1907    }
1908
1909    unsafe impl fidl::encoding::TypeMarker for AllocatorSetDebugClientInfoRequest {
1910        type Owned = Self;
1911
1912        #[inline(always)]
1913        fn inline_align(_context: fidl::encoding::Context) -> usize {
1914            8
1915        }
1916
1917        #[inline(always)]
1918        fn inline_size(_context: fidl::encoding::Context) -> usize {
1919            16
1920        }
1921    }
1922
1923    unsafe impl<D: fidl::encoding::ResourceDialect>
1924        fidl::encoding::Encode<AllocatorSetDebugClientInfoRequest, D>
1925        for &AllocatorSetDebugClientInfoRequest
1926    {
1927        unsafe fn encode(
1928            self,
1929            encoder: &mut fidl::encoding::Encoder<'_, D>,
1930            offset: usize,
1931            mut depth: fidl::encoding::Depth,
1932        ) -> fidl::Result<()> {
1933            encoder.debug_check_bounds::<AllocatorSetDebugClientInfoRequest>(offset);
1934            // Vector header
1935            let max_ordinal: u64 = self.max_ordinal_present();
1936            encoder.write_num(max_ordinal, offset);
1937            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1938            // Calling encoder.out_of_line_offset(0) is not allowed.
1939            if max_ordinal == 0 {
1940                return Ok(());
1941            }
1942            depth.increment()?;
1943            let envelope_size = 8;
1944            let bytes_len = max_ordinal as usize * envelope_size;
1945            #[allow(unused_variables)]
1946            let offset = encoder.out_of_line_offset(bytes_len);
1947            let mut _prev_end_offset: usize = 0;
1948            if 1 > max_ordinal {
1949                return Ok(());
1950            }
1951
1952            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1953            // are envelope_size bytes.
1954            let cur_offset: usize = (1 - 1) * envelope_size;
1955
1956            // Zero reserved fields.
1957            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1958
1959            // Safety:
1960            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1961            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1962            //   envelope_size bytes, there is always sufficient room.
1963            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
1964                self.name.as_ref().map(
1965                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
1966                ),
1967                encoder,
1968                offset + cur_offset,
1969                depth,
1970            )?;
1971
1972            _prev_end_offset = cur_offset + envelope_size;
1973            if 2 > max_ordinal {
1974                return Ok(());
1975            }
1976
1977            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1978            // are envelope_size bytes.
1979            let cur_offset: usize = (2 - 1) * envelope_size;
1980
1981            // Zero reserved fields.
1982            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1983
1984            // Safety:
1985            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1986            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1987            //   envelope_size bytes, there is always sufficient room.
1988            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1989                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1990                encoder,
1991                offset + cur_offset,
1992                depth,
1993            )?;
1994
1995            _prev_end_offset = cur_offset + envelope_size;
1996
1997            Ok(())
1998        }
1999    }
2000
2001    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2002        for AllocatorSetDebugClientInfoRequest
2003    {
2004        #[inline(always)]
2005        fn new_empty() -> Self {
2006            Self::default()
2007        }
2008
2009        unsafe fn decode(
2010            &mut self,
2011            decoder: &mut fidl::encoding::Decoder<'_, D>,
2012            offset: usize,
2013            mut depth: fidl::encoding::Depth,
2014        ) -> fidl::Result<()> {
2015            decoder.debug_check_bounds::<Self>(offset);
2016            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2017                None => return Err(fidl::Error::NotNullable),
2018                Some(len) => len,
2019            };
2020            // Calling decoder.out_of_line_offset(0) is not allowed.
2021            if len == 0 {
2022                return Ok(());
2023            };
2024            depth.increment()?;
2025            let envelope_size = 8;
2026            let bytes_len = len * envelope_size;
2027            let offset = decoder.out_of_line_offset(bytes_len)?;
2028            // Decode the envelope for each type.
2029            let mut _next_ordinal_to_read = 0;
2030            let mut next_offset = offset;
2031            let end_offset = offset + bytes_len;
2032            _next_ordinal_to_read += 1;
2033            if next_offset >= end_offset {
2034                return Ok(());
2035            }
2036
2037            // Decode unknown envelopes for gaps in ordinals.
2038            while _next_ordinal_to_read < 1 {
2039                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2040                _next_ordinal_to_read += 1;
2041                next_offset += envelope_size;
2042            }
2043
2044            let next_out_of_line = decoder.next_out_of_line();
2045            let handles_before = decoder.remaining_handles();
2046            if let Some((inlined, num_bytes, num_handles)) =
2047                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2048            {
2049                let member_inline_size =
2050                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
2051                        decoder.context,
2052                    );
2053                if inlined != (member_inline_size <= 4) {
2054                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2055                }
2056                let inner_offset;
2057                let mut inner_depth = depth.clone();
2058                if inlined {
2059                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2060                    inner_offset = next_offset;
2061                } else {
2062                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2063                    inner_depth.increment()?;
2064                }
2065                let val_ref = self
2066                    .name
2067                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
2068                fidl::decode!(
2069                    fidl::encoding::BoundedString<256>,
2070                    D,
2071                    val_ref,
2072                    decoder,
2073                    inner_offset,
2074                    inner_depth
2075                )?;
2076                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2077                {
2078                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2079                }
2080                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2081                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2082                }
2083            }
2084
2085            next_offset += envelope_size;
2086            _next_ordinal_to_read += 1;
2087            if next_offset >= end_offset {
2088                return Ok(());
2089            }
2090
2091            // Decode unknown envelopes for gaps in ordinals.
2092            while _next_ordinal_to_read < 2 {
2093                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2094                _next_ordinal_to_read += 1;
2095                next_offset += envelope_size;
2096            }
2097
2098            let next_out_of_line = decoder.next_out_of_line();
2099            let handles_before = decoder.remaining_handles();
2100            if let Some((inlined, num_bytes, num_handles)) =
2101                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2102            {
2103                let member_inline_size =
2104                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2105                if inlined != (member_inline_size <= 4) {
2106                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2107                }
2108                let inner_offset;
2109                let mut inner_depth = depth.clone();
2110                if inlined {
2111                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2112                    inner_offset = next_offset;
2113                } else {
2114                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2115                    inner_depth.increment()?;
2116                }
2117                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
2118                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2119                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2120                {
2121                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2122                }
2123                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2124                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2125                }
2126            }
2127
2128            next_offset += envelope_size;
2129
2130            // Decode the remaining unknown envelopes.
2131            while next_offset < end_offset {
2132                _next_ordinal_to_read += 1;
2133                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2134                next_offset += envelope_size;
2135            }
2136
2137            Ok(())
2138        }
2139    }
2140
2141    impl AllocatorValidateBufferCollectionTokenRequest {
2142        #[inline(always)]
2143        fn max_ordinal_present(&self) -> u64 {
2144            if let Some(_) = self.token_server_koid {
2145                return 1;
2146            }
2147            0
2148        }
2149    }
2150
2151    impl fidl::encoding::ValueTypeMarker for AllocatorValidateBufferCollectionTokenRequest {
2152        type Borrowed<'a> = &'a Self;
2153        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2154            value
2155        }
2156    }
2157
2158    unsafe impl fidl::encoding::TypeMarker for AllocatorValidateBufferCollectionTokenRequest {
2159        type Owned = Self;
2160
2161        #[inline(always)]
2162        fn inline_align(_context: fidl::encoding::Context) -> usize {
2163            8
2164        }
2165
2166        #[inline(always)]
2167        fn inline_size(_context: fidl::encoding::Context) -> usize {
2168            16
2169        }
2170    }
2171
2172    unsafe impl<D: fidl::encoding::ResourceDialect>
2173        fidl::encoding::Encode<AllocatorValidateBufferCollectionTokenRequest, D>
2174        for &AllocatorValidateBufferCollectionTokenRequest
2175    {
2176        unsafe fn encode(
2177            self,
2178            encoder: &mut fidl::encoding::Encoder<'_, D>,
2179            offset: usize,
2180            mut depth: fidl::encoding::Depth,
2181        ) -> fidl::Result<()> {
2182            encoder.debug_check_bounds::<AllocatorValidateBufferCollectionTokenRequest>(offset);
2183            // Vector header
2184            let max_ordinal: u64 = self.max_ordinal_present();
2185            encoder.write_num(max_ordinal, offset);
2186            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2187            // Calling encoder.out_of_line_offset(0) is not allowed.
2188            if max_ordinal == 0 {
2189                return Ok(());
2190            }
2191            depth.increment()?;
2192            let envelope_size = 8;
2193            let bytes_len = max_ordinal as usize * envelope_size;
2194            #[allow(unused_variables)]
2195            let offset = encoder.out_of_line_offset(bytes_len);
2196            let mut _prev_end_offset: usize = 0;
2197            if 1 > max_ordinal {
2198                return Ok(());
2199            }
2200
2201            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2202            // are envelope_size bytes.
2203            let cur_offset: usize = (1 - 1) * envelope_size;
2204
2205            // Zero reserved fields.
2206            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2207
2208            // Safety:
2209            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2210            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2211            //   envelope_size bytes, there is always sufficient room.
2212            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2213                self.token_server_koid
2214                    .as_ref()
2215                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2216                encoder,
2217                offset + cur_offset,
2218                depth,
2219            )?;
2220
2221            _prev_end_offset = cur_offset + envelope_size;
2222
2223            Ok(())
2224        }
2225    }
2226
2227    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2228        for AllocatorValidateBufferCollectionTokenRequest
2229    {
2230        #[inline(always)]
2231        fn new_empty() -> Self {
2232            Self::default()
2233        }
2234
2235        unsafe fn decode(
2236            &mut self,
2237            decoder: &mut fidl::encoding::Decoder<'_, D>,
2238            offset: usize,
2239            mut depth: fidl::encoding::Depth,
2240        ) -> fidl::Result<()> {
2241            decoder.debug_check_bounds::<Self>(offset);
2242            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2243                None => return Err(fidl::Error::NotNullable),
2244                Some(len) => len,
2245            };
2246            // Calling decoder.out_of_line_offset(0) is not allowed.
2247            if len == 0 {
2248                return Ok(());
2249            };
2250            depth.increment()?;
2251            let envelope_size = 8;
2252            let bytes_len = len * envelope_size;
2253            let offset = decoder.out_of_line_offset(bytes_len)?;
2254            // Decode the envelope for each type.
2255            let mut _next_ordinal_to_read = 0;
2256            let mut next_offset = offset;
2257            let end_offset = offset + bytes_len;
2258            _next_ordinal_to_read += 1;
2259            if next_offset >= end_offset {
2260                return Ok(());
2261            }
2262
2263            // Decode unknown envelopes for gaps in ordinals.
2264            while _next_ordinal_to_read < 1 {
2265                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2266                _next_ordinal_to_read += 1;
2267                next_offset += envelope_size;
2268            }
2269
2270            let next_out_of_line = decoder.next_out_of_line();
2271            let handles_before = decoder.remaining_handles();
2272            if let Some((inlined, num_bytes, num_handles)) =
2273                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2274            {
2275                let member_inline_size =
2276                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2277                if inlined != (member_inline_size <= 4) {
2278                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2279                }
2280                let inner_offset;
2281                let mut inner_depth = depth.clone();
2282                if inlined {
2283                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2284                    inner_offset = next_offset;
2285                } else {
2286                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2287                    inner_depth.increment()?;
2288                }
2289                let val_ref =
2290                    self.token_server_koid.get_or_insert_with(|| fidl::new_empty!(u64, D));
2291                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2292                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2293                {
2294                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2295                }
2296                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2297                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2298                }
2299            }
2300
2301            next_offset += envelope_size;
2302
2303            // Decode the remaining unknown envelopes.
2304            while next_offset < end_offset {
2305                _next_ordinal_to_read += 1;
2306                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2307                next_offset += envelope_size;
2308            }
2309
2310            Ok(())
2311        }
2312    }
2313
2314    impl AllocatorValidateBufferCollectionTokenResponse {
2315        #[inline(always)]
2316        fn max_ordinal_present(&self) -> u64 {
2317            if let Some(_) = self.is_known {
2318                return 1;
2319            }
2320            0
2321        }
2322    }
2323
2324    impl fidl::encoding::ValueTypeMarker for AllocatorValidateBufferCollectionTokenResponse {
2325        type Borrowed<'a> = &'a Self;
2326        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2327            value
2328        }
2329    }
2330
2331    unsafe impl fidl::encoding::TypeMarker for AllocatorValidateBufferCollectionTokenResponse {
2332        type Owned = Self;
2333
2334        #[inline(always)]
2335        fn inline_align(_context: fidl::encoding::Context) -> usize {
2336            8
2337        }
2338
2339        #[inline(always)]
2340        fn inline_size(_context: fidl::encoding::Context) -> usize {
2341            16
2342        }
2343    }
2344
2345    unsafe impl<D: fidl::encoding::ResourceDialect>
2346        fidl::encoding::Encode<AllocatorValidateBufferCollectionTokenResponse, D>
2347        for &AllocatorValidateBufferCollectionTokenResponse
2348    {
2349        unsafe fn encode(
2350            self,
2351            encoder: &mut fidl::encoding::Encoder<'_, D>,
2352            offset: usize,
2353            mut depth: fidl::encoding::Depth,
2354        ) -> fidl::Result<()> {
2355            encoder.debug_check_bounds::<AllocatorValidateBufferCollectionTokenResponse>(offset);
2356            // Vector header
2357            let max_ordinal: u64 = self.max_ordinal_present();
2358            encoder.write_num(max_ordinal, offset);
2359            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2360            // Calling encoder.out_of_line_offset(0) is not allowed.
2361            if max_ordinal == 0 {
2362                return Ok(());
2363            }
2364            depth.increment()?;
2365            let envelope_size = 8;
2366            let bytes_len = max_ordinal as usize * envelope_size;
2367            #[allow(unused_variables)]
2368            let offset = encoder.out_of_line_offset(bytes_len);
2369            let mut _prev_end_offset: usize = 0;
2370            if 1 > max_ordinal {
2371                return Ok(());
2372            }
2373
2374            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2375            // are envelope_size bytes.
2376            let cur_offset: usize = (1 - 1) * envelope_size;
2377
2378            // Zero reserved fields.
2379            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2380
2381            // Safety:
2382            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2383            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2384            //   envelope_size bytes, there is always sufficient room.
2385            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2386                self.is_known.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2387                encoder,
2388                offset + cur_offset,
2389                depth,
2390            )?;
2391
2392            _prev_end_offset = cur_offset + envelope_size;
2393
2394            Ok(())
2395        }
2396    }
2397
2398    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2399        for AllocatorValidateBufferCollectionTokenResponse
2400    {
2401        #[inline(always)]
2402        fn new_empty() -> Self {
2403            Self::default()
2404        }
2405
2406        unsafe fn decode(
2407            &mut self,
2408            decoder: &mut fidl::encoding::Decoder<'_, D>,
2409            offset: usize,
2410            mut depth: fidl::encoding::Depth,
2411        ) -> fidl::Result<()> {
2412            decoder.debug_check_bounds::<Self>(offset);
2413            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2414                None => return Err(fidl::Error::NotNullable),
2415                Some(len) => len,
2416            };
2417            // Calling decoder.out_of_line_offset(0) is not allowed.
2418            if len == 0 {
2419                return Ok(());
2420            };
2421            depth.increment()?;
2422            let envelope_size = 8;
2423            let bytes_len = len * envelope_size;
2424            let offset = decoder.out_of_line_offset(bytes_len)?;
2425            // Decode the envelope for each type.
2426            let mut _next_ordinal_to_read = 0;
2427            let mut next_offset = offset;
2428            let end_offset = offset + bytes_len;
2429            _next_ordinal_to_read += 1;
2430            if next_offset >= end_offset {
2431                return Ok(());
2432            }
2433
2434            // Decode unknown envelopes for gaps in ordinals.
2435            while _next_ordinal_to_read < 1 {
2436                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2437                _next_ordinal_to_read += 1;
2438                next_offset += envelope_size;
2439            }
2440
2441            let next_out_of_line = decoder.next_out_of_line();
2442            let handles_before = decoder.remaining_handles();
2443            if let Some((inlined, num_bytes, num_handles)) =
2444                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2445            {
2446                let member_inline_size =
2447                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2448                if inlined != (member_inline_size <= 4) {
2449                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2450                }
2451                let inner_offset;
2452                let mut inner_depth = depth.clone();
2453                if inlined {
2454                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2455                    inner_offset = next_offset;
2456                } else {
2457                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2458                    inner_depth.increment()?;
2459                }
2460                let val_ref = self.is_known.get_or_insert_with(|| fidl::new_empty!(bool, D));
2461                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2462                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2463                {
2464                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2465                }
2466                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2467                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2468                }
2469            }
2470
2471            next_offset += envelope_size;
2472
2473            // Decode the remaining unknown envelopes.
2474            while next_offset < end_offset {
2475                _next_ordinal_to_read += 1;
2476                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2477                next_offset += envelope_size;
2478            }
2479
2480            Ok(())
2481        }
2482    }
2483
2484    impl BufferCollectionConstraints {
2485        #[inline(always)]
2486        fn max_ordinal_present(&self) -> u64 {
2487            if let Some(_) = self.image_format_constraints {
2488                return 8;
2489            }
2490            if let Some(_) = self.buffer_memory_constraints {
2491                return 7;
2492            }
2493            if let Some(_) = self.max_buffer_count {
2494                return 6;
2495            }
2496            if let Some(_) = self.min_buffer_count {
2497                return 5;
2498            }
2499            if let Some(_) = self.min_buffer_count_for_shared_slack {
2500                return 4;
2501            }
2502            if let Some(_) = self.min_buffer_count_for_dedicated_slack {
2503                return 3;
2504            }
2505            if let Some(_) = self.min_buffer_count_for_camping {
2506                return 2;
2507            }
2508            if let Some(_) = self.usage {
2509                return 1;
2510            }
2511            0
2512        }
2513    }
2514
2515    impl fidl::encoding::ValueTypeMarker for BufferCollectionConstraints {
2516        type Borrowed<'a> = &'a Self;
2517        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2518            value
2519        }
2520    }
2521
2522    unsafe impl fidl::encoding::TypeMarker for BufferCollectionConstraints {
2523        type Owned = Self;
2524
2525        #[inline(always)]
2526        fn inline_align(_context: fidl::encoding::Context) -> usize {
2527            8
2528        }
2529
2530        #[inline(always)]
2531        fn inline_size(_context: fidl::encoding::Context) -> usize {
2532            16
2533        }
2534    }
2535
2536    unsafe impl<D: fidl::encoding::ResourceDialect>
2537        fidl::encoding::Encode<BufferCollectionConstraints, D> for &BufferCollectionConstraints
2538    {
2539        unsafe fn encode(
2540            self,
2541            encoder: &mut fidl::encoding::Encoder<'_, D>,
2542            offset: usize,
2543            mut depth: fidl::encoding::Depth,
2544        ) -> fidl::Result<()> {
2545            encoder.debug_check_bounds::<BufferCollectionConstraints>(offset);
2546            // Vector header
2547            let max_ordinal: u64 = self.max_ordinal_present();
2548            encoder.write_num(max_ordinal, offset);
2549            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2550            // Calling encoder.out_of_line_offset(0) is not allowed.
2551            if max_ordinal == 0 {
2552                return Ok(());
2553            }
2554            depth.increment()?;
2555            let envelope_size = 8;
2556            let bytes_len = max_ordinal as usize * envelope_size;
2557            #[allow(unused_variables)]
2558            let offset = encoder.out_of_line_offset(bytes_len);
2559            let mut _prev_end_offset: usize = 0;
2560            if 1 > max_ordinal {
2561                return Ok(());
2562            }
2563
2564            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2565            // are envelope_size bytes.
2566            let cur_offset: usize = (1 - 1) * envelope_size;
2567
2568            // Zero reserved fields.
2569            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2570
2571            // Safety:
2572            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2573            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2574            //   envelope_size bytes, there is always sufficient room.
2575            fidl::encoding::encode_in_envelope_optional::<BufferUsage, D>(
2576                self.usage.as_ref().map(<BufferUsage as fidl::encoding::ValueTypeMarker>::borrow),
2577                encoder,
2578                offset + cur_offset,
2579                depth,
2580            )?;
2581
2582            _prev_end_offset = cur_offset + envelope_size;
2583            if 2 > max_ordinal {
2584                return Ok(());
2585            }
2586
2587            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2588            // are envelope_size bytes.
2589            let cur_offset: usize = (2 - 1) * envelope_size;
2590
2591            // Zero reserved fields.
2592            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2593
2594            // Safety:
2595            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2596            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2597            //   envelope_size bytes, there is always sufficient room.
2598            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2599                self.min_buffer_count_for_camping
2600                    .as_ref()
2601                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2602                encoder,
2603                offset + cur_offset,
2604                depth,
2605            )?;
2606
2607            _prev_end_offset = cur_offset + envelope_size;
2608            if 3 > max_ordinal {
2609                return Ok(());
2610            }
2611
2612            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2613            // are envelope_size bytes.
2614            let cur_offset: usize = (3 - 1) * envelope_size;
2615
2616            // Zero reserved fields.
2617            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2618
2619            // Safety:
2620            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2621            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2622            //   envelope_size bytes, there is always sufficient room.
2623            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2624                self.min_buffer_count_for_dedicated_slack
2625                    .as_ref()
2626                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2627                encoder,
2628                offset + cur_offset,
2629                depth,
2630            )?;
2631
2632            _prev_end_offset = cur_offset + envelope_size;
2633            if 4 > max_ordinal {
2634                return Ok(());
2635            }
2636
2637            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2638            // are envelope_size bytes.
2639            let cur_offset: usize = (4 - 1) * envelope_size;
2640
2641            // Zero reserved fields.
2642            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2643
2644            // Safety:
2645            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2646            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2647            //   envelope_size bytes, there is always sufficient room.
2648            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2649                self.min_buffer_count_for_shared_slack
2650                    .as_ref()
2651                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2652                encoder,
2653                offset + cur_offset,
2654                depth,
2655            )?;
2656
2657            _prev_end_offset = cur_offset + envelope_size;
2658            if 5 > max_ordinal {
2659                return Ok(());
2660            }
2661
2662            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2663            // are envelope_size bytes.
2664            let cur_offset: usize = (5 - 1) * envelope_size;
2665
2666            // Zero reserved fields.
2667            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2668
2669            // Safety:
2670            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2671            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2672            //   envelope_size bytes, there is always sufficient room.
2673            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2674                self.min_buffer_count
2675                    .as_ref()
2676                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2677                encoder,
2678                offset + cur_offset,
2679                depth,
2680            )?;
2681
2682            _prev_end_offset = cur_offset + envelope_size;
2683            if 6 > max_ordinal {
2684                return Ok(());
2685            }
2686
2687            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2688            // are envelope_size bytes.
2689            let cur_offset: usize = (6 - 1) * envelope_size;
2690
2691            // Zero reserved fields.
2692            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2693
2694            // Safety:
2695            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2696            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2697            //   envelope_size bytes, there is always sufficient room.
2698            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2699                self.max_buffer_count
2700                    .as_ref()
2701                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2702                encoder,
2703                offset + cur_offset,
2704                depth,
2705            )?;
2706
2707            _prev_end_offset = cur_offset + envelope_size;
2708            if 7 > max_ordinal {
2709                return Ok(());
2710            }
2711
2712            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2713            // are envelope_size bytes.
2714            let cur_offset: usize = (7 - 1) * envelope_size;
2715
2716            // Zero reserved fields.
2717            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2718
2719            // Safety:
2720            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2721            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2722            //   envelope_size bytes, there is always sufficient room.
2723            fidl::encoding::encode_in_envelope_optional::<BufferMemoryConstraints, D>(
2724                self.buffer_memory_constraints
2725                    .as_ref()
2726                    .map(<BufferMemoryConstraints as fidl::encoding::ValueTypeMarker>::borrow),
2727                encoder,
2728                offset + cur_offset,
2729                depth,
2730            )?;
2731
2732            _prev_end_offset = cur_offset + envelope_size;
2733            if 8 > max_ordinal {
2734                return Ok(());
2735            }
2736
2737            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2738            // are envelope_size bytes.
2739            let cur_offset: usize = (8 - 1) * envelope_size;
2740
2741            // Zero reserved fields.
2742            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2743
2744            // Safety:
2745            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2746            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2747            //   envelope_size bytes, there is always sufficient room.
2748            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ImageFormatConstraints, 64>, D>(
2749            self.image_format_constraints.as_ref().map(<fidl::encoding::Vector<ImageFormatConstraints, 64> as fidl::encoding::ValueTypeMarker>::borrow),
2750            encoder, offset + cur_offset, depth
2751        )?;
2752
2753            _prev_end_offset = cur_offset + envelope_size;
2754
2755            Ok(())
2756        }
2757    }
2758
2759    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2760        for BufferCollectionConstraints
2761    {
2762        #[inline(always)]
2763        fn new_empty() -> Self {
2764            Self::default()
2765        }
2766
2767        unsafe fn decode(
2768            &mut self,
2769            decoder: &mut fidl::encoding::Decoder<'_, D>,
2770            offset: usize,
2771            mut depth: fidl::encoding::Depth,
2772        ) -> fidl::Result<()> {
2773            decoder.debug_check_bounds::<Self>(offset);
2774            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2775                None => return Err(fidl::Error::NotNullable),
2776                Some(len) => len,
2777            };
2778            // Calling decoder.out_of_line_offset(0) is not allowed.
2779            if len == 0 {
2780                return Ok(());
2781            };
2782            depth.increment()?;
2783            let envelope_size = 8;
2784            let bytes_len = len * envelope_size;
2785            let offset = decoder.out_of_line_offset(bytes_len)?;
2786            // Decode the envelope for each type.
2787            let mut _next_ordinal_to_read = 0;
2788            let mut next_offset = offset;
2789            let end_offset = offset + bytes_len;
2790            _next_ordinal_to_read += 1;
2791            if next_offset >= end_offset {
2792                return Ok(());
2793            }
2794
2795            // Decode unknown envelopes for gaps in ordinals.
2796            while _next_ordinal_to_read < 1 {
2797                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2798                _next_ordinal_to_read += 1;
2799                next_offset += envelope_size;
2800            }
2801
2802            let next_out_of_line = decoder.next_out_of_line();
2803            let handles_before = decoder.remaining_handles();
2804            if let Some((inlined, num_bytes, num_handles)) =
2805                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2806            {
2807                let member_inline_size =
2808                    <BufferUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2809                if inlined != (member_inline_size <= 4) {
2810                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2811                }
2812                let inner_offset;
2813                let mut inner_depth = depth.clone();
2814                if inlined {
2815                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2816                    inner_offset = next_offset;
2817                } else {
2818                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2819                    inner_depth.increment()?;
2820                }
2821                let val_ref = self.usage.get_or_insert_with(|| fidl::new_empty!(BufferUsage, D));
2822                fidl::decode!(BufferUsage, D, val_ref, decoder, inner_offset, inner_depth)?;
2823                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2824                {
2825                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2826                }
2827                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2828                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2829                }
2830            }
2831
2832            next_offset += envelope_size;
2833            _next_ordinal_to_read += 1;
2834            if next_offset >= end_offset {
2835                return Ok(());
2836            }
2837
2838            // Decode unknown envelopes for gaps in ordinals.
2839            while _next_ordinal_to_read < 2 {
2840                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2841                _next_ordinal_to_read += 1;
2842                next_offset += envelope_size;
2843            }
2844
2845            let next_out_of_line = decoder.next_out_of_line();
2846            let handles_before = decoder.remaining_handles();
2847            if let Some((inlined, num_bytes, num_handles)) =
2848                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2849            {
2850                let member_inline_size =
2851                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2852                if inlined != (member_inline_size <= 4) {
2853                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2854                }
2855                let inner_offset;
2856                let mut inner_depth = depth.clone();
2857                if inlined {
2858                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2859                    inner_offset = next_offset;
2860                } else {
2861                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2862                    inner_depth.increment()?;
2863                }
2864                let val_ref = self
2865                    .min_buffer_count_for_camping
2866                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
2867                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2868                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2869                {
2870                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2871                }
2872                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2873                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2874                }
2875            }
2876
2877            next_offset += envelope_size;
2878            _next_ordinal_to_read += 1;
2879            if next_offset >= end_offset {
2880                return Ok(());
2881            }
2882
2883            // Decode unknown envelopes for gaps in ordinals.
2884            while _next_ordinal_to_read < 3 {
2885                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2886                _next_ordinal_to_read += 1;
2887                next_offset += envelope_size;
2888            }
2889
2890            let next_out_of_line = decoder.next_out_of_line();
2891            let handles_before = decoder.remaining_handles();
2892            if let Some((inlined, num_bytes, num_handles)) =
2893                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2894            {
2895                let member_inline_size =
2896                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2897                if inlined != (member_inline_size <= 4) {
2898                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2899                }
2900                let inner_offset;
2901                let mut inner_depth = depth.clone();
2902                if inlined {
2903                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2904                    inner_offset = next_offset;
2905                } else {
2906                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2907                    inner_depth.increment()?;
2908                }
2909                let val_ref = self
2910                    .min_buffer_count_for_dedicated_slack
2911                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
2912                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2913                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2914                {
2915                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2916                }
2917                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2918                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2919                }
2920            }
2921
2922            next_offset += envelope_size;
2923            _next_ordinal_to_read += 1;
2924            if next_offset >= end_offset {
2925                return Ok(());
2926            }
2927
2928            // Decode unknown envelopes for gaps in ordinals.
2929            while _next_ordinal_to_read < 4 {
2930                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2931                _next_ordinal_to_read += 1;
2932                next_offset += envelope_size;
2933            }
2934
2935            let next_out_of_line = decoder.next_out_of_line();
2936            let handles_before = decoder.remaining_handles();
2937            if let Some((inlined, num_bytes, num_handles)) =
2938                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2939            {
2940                let member_inline_size =
2941                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2942                if inlined != (member_inline_size <= 4) {
2943                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2944                }
2945                let inner_offset;
2946                let mut inner_depth = depth.clone();
2947                if inlined {
2948                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2949                    inner_offset = next_offset;
2950                } else {
2951                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2952                    inner_depth.increment()?;
2953                }
2954                let val_ref = self
2955                    .min_buffer_count_for_shared_slack
2956                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
2957                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2958                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2959                {
2960                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2961                }
2962                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2963                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2964                }
2965            }
2966
2967            next_offset += envelope_size;
2968            _next_ordinal_to_read += 1;
2969            if next_offset >= end_offset {
2970                return Ok(());
2971            }
2972
2973            // Decode unknown envelopes for gaps in ordinals.
2974            while _next_ordinal_to_read < 5 {
2975                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2976                _next_ordinal_to_read += 1;
2977                next_offset += envelope_size;
2978            }
2979
2980            let next_out_of_line = decoder.next_out_of_line();
2981            let handles_before = decoder.remaining_handles();
2982            if let Some((inlined, num_bytes, num_handles)) =
2983                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2984            {
2985                let member_inline_size =
2986                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2987                if inlined != (member_inline_size <= 4) {
2988                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2989                }
2990                let inner_offset;
2991                let mut inner_depth = depth.clone();
2992                if inlined {
2993                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2994                    inner_offset = next_offset;
2995                } else {
2996                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2997                    inner_depth.increment()?;
2998                }
2999                let val_ref = self.min_buffer_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
3000                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3001                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3002                {
3003                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3004                }
3005                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3006                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3007                }
3008            }
3009
3010            next_offset += envelope_size;
3011            _next_ordinal_to_read += 1;
3012            if next_offset >= end_offset {
3013                return Ok(());
3014            }
3015
3016            // Decode unknown envelopes for gaps in ordinals.
3017            while _next_ordinal_to_read < 6 {
3018                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3019                _next_ordinal_to_read += 1;
3020                next_offset += envelope_size;
3021            }
3022
3023            let next_out_of_line = decoder.next_out_of_line();
3024            let handles_before = decoder.remaining_handles();
3025            if let Some((inlined, num_bytes, num_handles)) =
3026                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3027            {
3028                let member_inline_size =
3029                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3030                if inlined != (member_inline_size <= 4) {
3031                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3032                }
3033                let inner_offset;
3034                let mut inner_depth = depth.clone();
3035                if inlined {
3036                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3037                    inner_offset = next_offset;
3038                } else {
3039                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3040                    inner_depth.increment()?;
3041                }
3042                let val_ref = self.max_buffer_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
3043                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3044                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3045                {
3046                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3047                }
3048                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3049                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3050                }
3051            }
3052
3053            next_offset += envelope_size;
3054            _next_ordinal_to_read += 1;
3055            if next_offset >= end_offset {
3056                return Ok(());
3057            }
3058
3059            // Decode unknown envelopes for gaps in ordinals.
3060            while _next_ordinal_to_read < 7 {
3061                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3062                _next_ordinal_to_read += 1;
3063                next_offset += envelope_size;
3064            }
3065
3066            let next_out_of_line = decoder.next_out_of_line();
3067            let handles_before = decoder.remaining_handles();
3068            if let Some((inlined, num_bytes, num_handles)) =
3069                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3070            {
3071                let member_inline_size =
3072                    <BufferMemoryConstraints as fidl::encoding::TypeMarker>::inline_size(
3073                        decoder.context,
3074                    );
3075                if inlined != (member_inline_size <= 4) {
3076                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3077                }
3078                let inner_offset;
3079                let mut inner_depth = depth.clone();
3080                if inlined {
3081                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3082                    inner_offset = next_offset;
3083                } else {
3084                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3085                    inner_depth.increment()?;
3086                }
3087                let val_ref = self
3088                    .buffer_memory_constraints
3089                    .get_or_insert_with(|| fidl::new_empty!(BufferMemoryConstraints, D));
3090                fidl::decode!(
3091                    BufferMemoryConstraints,
3092                    D,
3093                    val_ref,
3094                    decoder,
3095                    inner_offset,
3096                    inner_depth
3097                )?;
3098                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3099                {
3100                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3101                }
3102                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3103                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3104                }
3105            }
3106
3107            next_offset += envelope_size;
3108            _next_ordinal_to_read += 1;
3109            if next_offset >= end_offset {
3110                return Ok(());
3111            }
3112
3113            // Decode unknown envelopes for gaps in ordinals.
3114            while _next_ordinal_to_read < 8 {
3115                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3116                _next_ordinal_to_read += 1;
3117                next_offset += envelope_size;
3118            }
3119
3120            let next_out_of_line = decoder.next_out_of_line();
3121            let handles_before = decoder.remaining_handles();
3122            if let Some((inlined, num_bytes, num_handles)) =
3123                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3124            {
3125                let member_inline_size = <fidl::encoding::Vector<ImageFormatConstraints, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3126                if inlined != (member_inline_size <= 4) {
3127                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3128                }
3129                let inner_offset;
3130                let mut inner_depth = depth.clone();
3131                if inlined {
3132                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3133                    inner_offset = next_offset;
3134                } else {
3135                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3136                    inner_depth.increment()?;
3137                }
3138                let val_ref = self.image_format_constraints.get_or_insert_with(
3139                    || fidl::new_empty!(fidl::encoding::Vector<ImageFormatConstraints, 64>, D),
3140                );
3141                fidl::decode!(fidl::encoding::Vector<ImageFormatConstraints, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3142                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3143                {
3144                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3145                }
3146                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3147                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3148                }
3149            }
3150
3151            next_offset += envelope_size;
3152
3153            // Decode the remaining unknown envelopes.
3154            while next_offset < end_offset {
3155                _next_ordinal_to_read += 1;
3156                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3157                next_offset += envelope_size;
3158            }
3159
3160            Ok(())
3161        }
3162    }
3163
3164    impl BufferCollectionTokenDuplicateSyncRequest {
3165        #[inline(always)]
3166        fn max_ordinal_present(&self) -> u64 {
3167            if let Some(_) = self.rights_attenuation_masks {
3168                return 1;
3169            }
3170            0
3171        }
3172    }
3173
3174    impl fidl::encoding::ValueTypeMarker for BufferCollectionTokenDuplicateSyncRequest {
3175        type Borrowed<'a> = &'a Self;
3176        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3177            value
3178        }
3179    }
3180
3181    unsafe impl fidl::encoding::TypeMarker for BufferCollectionTokenDuplicateSyncRequest {
3182        type Owned = Self;
3183
3184        #[inline(always)]
3185        fn inline_align(_context: fidl::encoding::Context) -> usize {
3186            8
3187        }
3188
3189        #[inline(always)]
3190        fn inline_size(_context: fidl::encoding::Context) -> usize {
3191            16
3192        }
3193    }
3194
3195    unsafe impl<D: fidl::encoding::ResourceDialect>
3196        fidl::encoding::Encode<BufferCollectionTokenDuplicateSyncRequest, D>
3197        for &BufferCollectionTokenDuplicateSyncRequest
3198    {
3199        unsafe fn encode(
3200            self,
3201            encoder: &mut fidl::encoding::Encoder<'_, D>,
3202            offset: usize,
3203            mut depth: fidl::encoding::Depth,
3204        ) -> fidl::Result<()> {
3205            encoder.debug_check_bounds::<BufferCollectionTokenDuplicateSyncRequest>(offset);
3206            // Vector header
3207            let max_ordinal: u64 = self.max_ordinal_present();
3208            encoder.write_num(max_ordinal, offset);
3209            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3210            // Calling encoder.out_of_line_offset(0) is not allowed.
3211            if max_ordinal == 0 {
3212                return Ok(());
3213            }
3214            depth.increment()?;
3215            let envelope_size = 8;
3216            let bytes_len = max_ordinal as usize * envelope_size;
3217            #[allow(unused_variables)]
3218            let offset = encoder.out_of_line_offset(bytes_len);
3219            let mut _prev_end_offset: usize = 0;
3220            if 1 > max_ordinal {
3221                return Ok(());
3222            }
3223
3224            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3225            // are envelope_size bytes.
3226            let cur_offset: usize = (1 - 1) * envelope_size;
3227
3228            // Zero reserved fields.
3229            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3230
3231            // Safety:
3232            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3233            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3234            //   envelope_size bytes, there is always sufficient room.
3235            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::Rights, 64>, D>(
3236            self.rights_attenuation_masks.as_ref().map(<fidl::encoding::Vector<fidl::Rights, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3237            encoder, offset + cur_offset, depth
3238        )?;
3239
3240            _prev_end_offset = cur_offset + envelope_size;
3241
3242            Ok(())
3243        }
3244    }
3245
3246    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3247        for BufferCollectionTokenDuplicateSyncRequest
3248    {
3249        #[inline(always)]
3250        fn new_empty() -> Self {
3251            Self::default()
3252        }
3253
3254        unsafe fn decode(
3255            &mut self,
3256            decoder: &mut fidl::encoding::Decoder<'_, D>,
3257            offset: usize,
3258            mut depth: fidl::encoding::Depth,
3259        ) -> fidl::Result<()> {
3260            decoder.debug_check_bounds::<Self>(offset);
3261            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3262                None => return Err(fidl::Error::NotNullable),
3263                Some(len) => len,
3264            };
3265            // Calling decoder.out_of_line_offset(0) is not allowed.
3266            if len == 0 {
3267                return Ok(());
3268            };
3269            depth.increment()?;
3270            let envelope_size = 8;
3271            let bytes_len = len * envelope_size;
3272            let offset = decoder.out_of_line_offset(bytes_len)?;
3273            // Decode the envelope for each type.
3274            let mut _next_ordinal_to_read = 0;
3275            let mut next_offset = offset;
3276            let end_offset = offset + bytes_len;
3277            _next_ordinal_to_read += 1;
3278            if next_offset >= end_offset {
3279                return Ok(());
3280            }
3281
3282            // Decode unknown envelopes for gaps in ordinals.
3283            while _next_ordinal_to_read < 1 {
3284                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3285                _next_ordinal_to_read += 1;
3286                next_offset += envelope_size;
3287            }
3288
3289            let next_out_of_line = decoder.next_out_of_line();
3290            let handles_before = decoder.remaining_handles();
3291            if let Some((inlined, num_bytes, num_handles)) =
3292                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3293            {
3294                let member_inline_size = <fidl::encoding::Vector<fidl::Rights, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3295                if inlined != (member_inline_size <= 4) {
3296                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3297                }
3298                let inner_offset;
3299                let mut inner_depth = depth.clone();
3300                if inlined {
3301                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3302                    inner_offset = next_offset;
3303                } else {
3304                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3305                    inner_depth.increment()?;
3306                }
3307                let val_ref = self.rights_attenuation_masks.get_or_insert_with(
3308                    || fidl::new_empty!(fidl::encoding::Vector<fidl::Rights, 64>, D),
3309                );
3310                fidl::decode!(fidl::encoding::Vector<fidl::Rights, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3311                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3312                {
3313                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3314                }
3315                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3316                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3317                }
3318            }
3319
3320            next_offset += envelope_size;
3321
3322            // Decode the remaining unknown envelopes.
3323            while next_offset < end_offset {
3324                _next_ordinal_to_read += 1;
3325                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3326                next_offset += envelope_size;
3327            }
3328
3329            Ok(())
3330        }
3331    }
3332
3333    impl BufferCollectionTokenGroupCreateChildrenSyncRequest {
3334        #[inline(always)]
3335        fn max_ordinal_present(&self) -> u64 {
3336            if let Some(_) = self.rights_attenuation_masks {
3337                return 1;
3338            }
3339            0
3340        }
3341    }
3342
3343    impl fidl::encoding::ValueTypeMarker for BufferCollectionTokenGroupCreateChildrenSyncRequest {
3344        type Borrowed<'a> = &'a Self;
3345        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3346            value
3347        }
3348    }
3349
3350    unsafe impl fidl::encoding::TypeMarker for BufferCollectionTokenGroupCreateChildrenSyncRequest {
3351        type Owned = Self;
3352
3353        #[inline(always)]
3354        fn inline_align(_context: fidl::encoding::Context) -> usize {
3355            8
3356        }
3357
3358        #[inline(always)]
3359        fn inline_size(_context: fidl::encoding::Context) -> usize {
3360            16
3361        }
3362    }
3363
3364    unsafe impl<D: fidl::encoding::ResourceDialect>
3365        fidl::encoding::Encode<BufferCollectionTokenGroupCreateChildrenSyncRequest, D>
3366        for &BufferCollectionTokenGroupCreateChildrenSyncRequest
3367    {
3368        unsafe fn encode(
3369            self,
3370            encoder: &mut fidl::encoding::Encoder<'_, D>,
3371            offset: usize,
3372            mut depth: fidl::encoding::Depth,
3373        ) -> fidl::Result<()> {
3374            encoder
3375                .debug_check_bounds::<BufferCollectionTokenGroupCreateChildrenSyncRequest>(offset);
3376            // Vector header
3377            let max_ordinal: u64 = self.max_ordinal_present();
3378            encoder.write_num(max_ordinal, offset);
3379            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3380            // Calling encoder.out_of_line_offset(0) is not allowed.
3381            if max_ordinal == 0 {
3382                return Ok(());
3383            }
3384            depth.increment()?;
3385            let envelope_size = 8;
3386            let bytes_len = max_ordinal as usize * envelope_size;
3387            #[allow(unused_variables)]
3388            let offset = encoder.out_of_line_offset(bytes_len);
3389            let mut _prev_end_offset: usize = 0;
3390            if 1 > max_ordinal {
3391                return Ok(());
3392            }
3393
3394            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3395            // are envelope_size bytes.
3396            let cur_offset: usize = (1 - 1) * envelope_size;
3397
3398            // Zero reserved fields.
3399            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3400
3401            // Safety:
3402            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3403            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3404            //   envelope_size bytes, there is always sufficient room.
3405            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::Rights, 64>, D>(
3406            self.rights_attenuation_masks.as_ref().map(<fidl::encoding::Vector<fidl::Rights, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3407            encoder, offset + cur_offset, depth
3408        )?;
3409
3410            _prev_end_offset = cur_offset + envelope_size;
3411
3412            Ok(())
3413        }
3414    }
3415
3416    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3417        for BufferCollectionTokenGroupCreateChildrenSyncRequest
3418    {
3419        #[inline(always)]
3420        fn new_empty() -> Self {
3421            Self::default()
3422        }
3423
3424        unsafe fn decode(
3425            &mut self,
3426            decoder: &mut fidl::encoding::Decoder<'_, D>,
3427            offset: usize,
3428            mut depth: fidl::encoding::Depth,
3429        ) -> fidl::Result<()> {
3430            decoder.debug_check_bounds::<Self>(offset);
3431            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3432                None => return Err(fidl::Error::NotNullable),
3433                Some(len) => len,
3434            };
3435            // Calling decoder.out_of_line_offset(0) is not allowed.
3436            if len == 0 {
3437                return Ok(());
3438            };
3439            depth.increment()?;
3440            let envelope_size = 8;
3441            let bytes_len = len * envelope_size;
3442            let offset = decoder.out_of_line_offset(bytes_len)?;
3443            // Decode the envelope for each type.
3444            let mut _next_ordinal_to_read = 0;
3445            let mut next_offset = offset;
3446            let end_offset = offset + bytes_len;
3447            _next_ordinal_to_read += 1;
3448            if next_offset >= end_offset {
3449                return Ok(());
3450            }
3451
3452            // Decode unknown envelopes for gaps in ordinals.
3453            while _next_ordinal_to_read < 1 {
3454                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3455                _next_ordinal_to_read += 1;
3456                next_offset += envelope_size;
3457            }
3458
3459            let next_out_of_line = decoder.next_out_of_line();
3460            let handles_before = decoder.remaining_handles();
3461            if let Some((inlined, num_bytes, num_handles)) =
3462                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3463            {
3464                let member_inline_size = <fidl::encoding::Vector<fidl::Rights, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3465                if inlined != (member_inline_size <= 4) {
3466                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3467                }
3468                let inner_offset;
3469                let mut inner_depth = depth.clone();
3470                if inlined {
3471                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3472                    inner_offset = next_offset;
3473                } else {
3474                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3475                    inner_depth.increment()?;
3476                }
3477                let val_ref = self.rights_attenuation_masks.get_or_insert_with(
3478                    || fidl::new_empty!(fidl::encoding::Vector<fidl::Rights, 64>, D),
3479                );
3480                fidl::decode!(fidl::encoding::Vector<fidl::Rights, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3481                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3482                {
3483                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3484                }
3485                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3486                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3487                }
3488            }
3489
3490            next_offset += envelope_size;
3491
3492            // Decode the remaining unknown envelopes.
3493            while next_offset < end_offset {
3494                _next_ordinal_to_read += 1;
3495                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3496                next_offset += envelope_size;
3497            }
3498
3499            Ok(())
3500        }
3501    }
3502
3503    impl BufferMemoryConstraints {
3504        #[inline(always)]
3505        fn max_ordinal_present(&self) -> u64 {
3506            if let Some(_) = self.permitted_heaps {
3507                return 8;
3508            }
3509            if let Some(_) = self.inaccessible_domain_supported {
3510                return 7;
3511            }
3512            if let Some(_) = self.ram_domain_supported {
3513                return 6;
3514            }
3515            if let Some(_) = self.cpu_domain_supported {
3516                return 5;
3517            }
3518            if let Some(_) = self.secure_required {
3519                return 4;
3520            }
3521            if let Some(_) = self.physically_contiguous_required {
3522                return 3;
3523            }
3524            if let Some(_) = self.max_size_bytes {
3525                return 2;
3526            }
3527            if let Some(_) = self.min_size_bytes {
3528                return 1;
3529            }
3530            0
3531        }
3532    }
3533
3534    impl fidl::encoding::ValueTypeMarker for BufferMemoryConstraints {
3535        type Borrowed<'a> = &'a Self;
3536        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3537            value
3538        }
3539    }
3540
3541    unsafe impl fidl::encoding::TypeMarker for BufferMemoryConstraints {
3542        type Owned = Self;
3543
3544        #[inline(always)]
3545        fn inline_align(_context: fidl::encoding::Context) -> usize {
3546            8
3547        }
3548
3549        #[inline(always)]
3550        fn inline_size(_context: fidl::encoding::Context) -> usize {
3551            16
3552        }
3553    }
3554
3555    unsafe impl<D: fidl::encoding::ResourceDialect>
3556        fidl::encoding::Encode<BufferMemoryConstraints, D> for &BufferMemoryConstraints
3557    {
3558        unsafe fn encode(
3559            self,
3560            encoder: &mut fidl::encoding::Encoder<'_, D>,
3561            offset: usize,
3562            mut depth: fidl::encoding::Depth,
3563        ) -> fidl::Result<()> {
3564            encoder.debug_check_bounds::<BufferMemoryConstraints>(offset);
3565            // Vector header
3566            let max_ordinal: u64 = self.max_ordinal_present();
3567            encoder.write_num(max_ordinal, offset);
3568            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3569            // Calling encoder.out_of_line_offset(0) is not allowed.
3570            if max_ordinal == 0 {
3571                return Ok(());
3572            }
3573            depth.increment()?;
3574            let envelope_size = 8;
3575            let bytes_len = max_ordinal as usize * envelope_size;
3576            #[allow(unused_variables)]
3577            let offset = encoder.out_of_line_offset(bytes_len);
3578            let mut _prev_end_offset: usize = 0;
3579            if 1 > max_ordinal {
3580                return Ok(());
3581            }
3582
3583            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3584            // are envelope_size bytes.
3585            let cur_offset: usize = (1 - 1) * envelope_size;
3586
3587            // Zero reserved fields.
3588            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3589
3590            // Safety:
3591            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3592            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3593            //   envelope_size bytes, there is always sufficient room.
3594            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3595                self.min_size_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3596                encoder,
3597                offset + cur_offset,
3598                depth,
3599            )?;
3600
3601            _prev_end_offset = cur_offset + envelope_size;
3602            if 2 > max_ordinal {
3603                return Ok(());
3604            }
3605
3606            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3607            // are envelope_size bytes.
3608            let cur_offset: usize = (2 - 1) * envelope_size;
3609
3610            // Zero reserved fields.
3611            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3612
3613            // Safety:
3614            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3615            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3616            //   envelope_size bytes, there is always sufficient room.
3617            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3618                self.max_size_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3619                encoder,
3620                offset + cur_offset,
3621                depth,
3622            )?;
3623
3624            _prev_end_offset = cur_offset + envelope_size;
3625            if 3 > max_ordinal {
3626                return Ok(());
3627            }
3628
3629            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3630            // are envelope_size bytes.
3631            let cur_offset: usize = (3 - 1) * envelope_size;
3632
3633            // Zero reserved fields.
3634            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3635
3636            // Safety:
3637            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3638            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3639            //   envelope_size bytes, there is always sufficient room.
3640            fidl::encoding::encode_in_envelope_optional::<bool, D>(
3641                self.physically_contiguous_required
3642                    .as_ref()
3643                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3644                encoder,
3645                offset + cur_offset,
3646                depth,
3647            )?;
3648
3649            _prev_end_offset = cur_offset + envelope_size;
3650            if 4 > max_ordinal {
3651                return Ok(());
3652            }
3653
3654            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3655            // are envelope_size bytes.
3656            let cur_offset: usize = (4 - 1) * envelope_size;
3657
3658            // Zero reserved fields.
3659            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3660
3661            // Safety:
3662            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3663            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3664            //   envelope_size bytes, there is always sufficient room.
3665            fidl::encoding::encode_in_envelope_optional::<bool, D>(
3666                self.secure_required
3667                    .as_ref()
3668                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3669                encoder,
3670                offset + cur_offset,
3671                depth,
3672            )?;
3673
3674            _prev_end_offset = cur_offset + envelope_size;
3675            if 5 > max_ordinal {
3676                return Ok(());
3677            }
3678
3679            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3680            // are envelope_size bytes.
3681            let cur_offset: usize = (5 - 1) * envelope_size;
3682
3683            // Zero reserved fields.
3684            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3685
3686            // Safety:
3687            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3688            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3689            //   envelope_size bytes, there is always sufficient room.
3690            fidl::encoding::encode_in_envelope_optional::<bool, D>(
3691                self.cpu_domain_supported
3692                    .as_ref()
3693                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3694                encoder,
3695                offset + cur_offset,
3696                depth,
3697            )?;
3698
3699            _prev_end_offset = cur_offset + envelope_size;
3700            if 6 > max_ordinal {
3701                return Ok(());
3702            }
3703
3704            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3705            // are envelope_size bytes.
3706            let cur_offset: usize = (6 - 1) * envelope_size;
3707
3708            // Zero reserved fields.
3709            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3710
3711            // Safety:
3712            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3713            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3714            //   envelope_size bytes, there is always sufficient room.
3715            fidl::encoding::encode_in_envelope_optional::<bool, D>(
3716                self.ram_domain_supported
3717                    .as_ref()
3718                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3719                encoder,
3720                offset + cur_offset,
3721                depth,
3722            )?;
3723
3724            _prev_end_offset = cur_offset + envelope_size;
3725            if 7 > max_ordinal {
3726                return Ok(());
3727            }
3728
3729            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3730            // are envelope_size bytes.
3731            let cur_offset: usize = (7 - 1) * envelope_size;
3732
3733            // Zero reserved fields.
3734            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3735
3736            // Safety:
3737            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3738            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3739            //   envelope_size bytes, there is always sufficient room.
3740            fidl::encoding::encode_in_envelope_optional::<bool, D>(
3741                self.inaccessible_domain_supported
3742                    .as_ref()
3743                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3744                encoder,
3745                offset + cur_offset,
3746                depth,
3747            )?;
3748
3749            _prev_end_offset = cur_offset + envelope_size;
3750            if 8 > max_ordinal {
3751                return Ok(());
3752            }
3753
3754            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3755            // are envelope_size bytes.
3756            let cur_offset: usize = (8 - 1) * envelope_size;
3757
3758            // Zero reserved fields.
3759            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3760
3761            // Safety:
3762            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3763            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3764            //   envelope_size bytes, there is always sufficient room.
3765            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<Heap, 64>, D>(
3766                self.permitted_heaps.as_ref().map(
3767                    <fidl::encoding::Vector<Heap, 64> as fidl::encoding::ValueTypeMarker>::borrow,
3768                ),
3769                encoder,
3770                offset + cur_offset,
3771                depth,
3772            )?;
3773
3774            _prev_end_offset = cur_offset + envelope_size;
3775
3776            Ok(())
3777        }
3778    }
3779
3780    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3781        for BufferMemoryConstraints
3782    {
3783        #[inline(always)]
3784        fn new_empty() -> Self {
3785            Self::default()
3786        }
3787
3788        unsafe fn decode(
3789            &mut self,
3790            decoder: &mut fidl::encoding::Decoder<'_, D>,
3791            offset: usize,
3792            mut depth: fidl::encoding::Depth,
3793        ) -> fidl::Result<()> {
3794            decoder.debug_check_bounds::<Self>(offset);
3795            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3796                None => return Err(fidl::Error::NotNullable),
3797                Some(len) => len,
3798            };
3799            // Calling decoder.out_of_line_offset(0) is not allowed.
3800            if len == 0 {
3801                return Ok(());
3802            };
3803            depth.increment()?;
3804            let envelope_size = 8;
3805            let bytes_len = len * envelope_size;
3806            let offset = decoder.out_of_line_offset(bytes_len)?;
3807            // Decode the envelope for each type.
3808            let mut _next_ordinal_to_read = 0;
3809            let mut next_offset = offset;
3810            let end_offset = offset + bytes_len;
3811            _next_ordinal_to_read += 1;
3812            if next_offset >= end_offset {
3813                return Ok(());
3814            }
3815
3816            // Decode unknown envelopes for gaps in ordinals.
3817            while _next_ordinal_to_read < 1 {
3818                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3819                _next_ordinal_to_read += 1;
3820                next_offset += envelope_size;
3821            }
3822
3823            let next_out_of_line = decoder.next_out_of_line();
3824            let handles_before = decoder.remaining_handles();
3825            if let Some((inlined, num_bytes, num_handles)) =
3826                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3827            {
3828                let member_inline_size =
3829                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3830                if inlined != (member_inline_size <= 4) {
3831                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3832                }
3833                let inner_offset;
3834                let mut inner_depth = depth.clone();
3835                if inlined {
3836                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3837                    inner_offset = next_offset;
3838                } else {
3839                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3840                    inner_depth.increment()?;
3841                }
3842                let val_ref = self.min_size_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
3843                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3844                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3845                {
3846                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3847                }
3848                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3849                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3850                }
3851            }
3852
3853            next_offset += envelope_size;
3854            _next_ordinal_to_read += 1;
3855            if next_offset >= end_offset {
3856                return Ok(());
3857            }
3858
3859            // Decode unknown envelopes for gaps in ordinals.
3860            while _next_ordinal_to_read < 2 {
3861                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3862                _next_ordinal_to_read += 1;
3863                next_offset += envelope_size;
3864            }
3865
3866            let next_out_of_line = decoder.next_out_of_line();
3867            let handles_before = decoder.remaining_handles();
3868            if let Some((inlined, num_bytes, num_handles)) =
3869                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3870            {
3871                let member_inline_size =
3872                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3873                if inlined != (member_inline_size <= 4) {
3874                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3875                }
3876                let inner_offset;
3877                let mut inner_depth = depth.clone();
3878                if inlined {
3879                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3880                    inner_offset = next_offset;
3881                } else {
3882                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3883                    inner_depth.increment()?;
3884                }
3885                let val_ref = self.max_size_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
3886                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3887                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3888                {
3889                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3890                }
3891                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3892                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3893                }
3894            }
3895
3896            next_offset += envelope_size;
3897            _next_ordinal_to_read += 1;
3898            if next_offset >= end_offset {
3899                return Ok(());
3900            }
3901
3902            // Decode unknown envelopes for gaps in ordinals.
3903            while _next_ordinal_to_read < 3 {
3904                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3905                _next_ordinal_to_read += 1;
3906                next_offset += envelope_size;
3907            }
3908
3909            let next_out_of_line = decoder.next_out_of_line();
3910            let handles_before = decoder.remaining_handles();
3911            if let Some((inlined, num_bytes, num_handles)) =
3912                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3913            {
3914                let member_inline_size =
3915                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3916                if inlined != (member_inline_size <= 4) {
3917                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3918                }
3919                let inner_offset;
3920                let mut inner_depth = depth.clone();
3921                if inlined {
3922                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3923                    inner_offset = next_offset;
3924                } else {
3925                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3926                    inner_depth.increment()?;
3927                }
3928                let val_ref = self
3929                    .physically_contiguous_required
3930                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
3931                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3932                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3933                {
3934                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3935                }
3936                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3937                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3938                }
3939            }
3940
3941            next_offset += envelope_size;
3942            _next_ordinal_to_read += 1;
3943            if next_offset >= end_offset {
3944                return Ok(());
3945            }
3946
3947            // Decode unknown envelopes for gaps in ordinals.
3948            while _next_ordinal_to_read < 4 {
3949                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3950                _next_ordinal_to_read += 1;
3951                next_offset += envelope_size;
3952            }
3953
3954            let next_out_of_line = decoder.next_out_of_line();
3955            let handles_before = decoder.remaining_handles();
3956            if let Some((inlined, num_bytes, num_handles)) =
3957                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3958            {
3959                let member_inline_size =
3960                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3961                if inlined != (member_inline_size <= 4) {
3962                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3963                }
3964                let inner_offset;
3965                let mut inner_depth = depth.clone();
3966                if inlined {
3967                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3968                    inner_offset = next_offset;
3969                } else {
3970                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3971                    inner_depth.increment()?;
3972                }
3973                let val_ref = self.secure_required.get_or_insert_with(|| fidl::new_empty!(bool, D));
3974                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3975                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3976                {
3977                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3978                }
3979                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3980                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3981                }
3982            }
3983
3984            next_offset += envelope_size;
3985            _next_ordinal_to_read += 1;
3986            if next_offset >= end_offset {
3987                return Ok(());
3988            }
3989
3990            // Decode unknown envelopes for gaps in ordinals.
3991            while _next_ordinal_to_read < 5 {
3992                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3993                _next_ordinal_to_read += 1;
3994                next_offset += envelope_size;
3995            }
3996
3997            let next_out_of_line = decoder.next_out_of_line();
3998            let handles_before = decoder.remaining_handles();
3999            if let Some((inlined, num_bytes, num_handles)) =
4000                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4001            {
4002                let member_inline_size =
4003                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4004                if inlined != (member_inline_size <= 4) {
4005                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4006                }
4007                let inner_offset;
4008                let mut inner_depth = depth.clone();
4009                if inlined {
4010                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4011                    inner_offset = next_offset;
4012                } else {
4013                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4014                    inner_depth.increment()?;
4015                }
4016                let val_ref =
4017                    self.cpu_domain_supported.get_or_insert_with(|| fidl::new_empty!(bool, D));
4018                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4019                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4020                {
4021                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4022                }
4023                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4024                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4025                }
4026            }
4027
4028            next_offset += envelope_size;
4029            _next_ordinal_to_read += 1;
4030            if next_offset >= end_offset {
4031                return Ok(());
4032            }
4033
4034            // Decode unknown envelopes for gaps in ordinals.
4035            while _next_ordinal_to_read < 6 {
4036                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4037                _next_ordinal_to_read += 1;
4038                next_offset += envelope_size;
4039            }
4040
4041            let next_out_of_line = decoder.next_out_of_line();
4042            let handles_before = decoder.remaining_handles();
4043            if let Some((inlined, num_bytes, num_handles)) =
4044                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4045            {
4046                let member_inline_size =
4047                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4048                if inlined != (member_inline_size <= 4) {
4049                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4050                }
4051                let inner_offset;
4052                let mut inner_depth = depth.clone();
4053                if inlined {
4054                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4055                    inner_offset = next_offset;
4056                } else {
4057                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4058                    inner_depth.increment()?;
4059                }
4060                let val_ref =
4061                    self.ram_domain_supported.get_or_insert_with(|| fidl::new_empty!(bool, D));
4062                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4063                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4064                {
4065                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4066                }
4067                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4068                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4069                }
4070            }
4071
4072            next_offset += envelope_size;
4073            _next_ordinal_to_read += 1;
4074            if next_offset >= end_offset {
4075                return Ok(());
4076            }
4077
4078            // Decode unknown envelopes for gaps in ordinals.
4079            while _next_ordinal_to_read < 7 {
4080                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4081                _next_ordinal_to_read += 1;
4082                next_offset += envelope_size;
4083            }
4084
4085            let next_out_of_line = decoder.next_out_of_line();
4086            let handles_before = decoder.remaining_handles();
4087            if let Some((inlined, num_bytes, num_handles)) =
4088                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4089            {
4090                let member_inline_size =
4091                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4092                if inlined != (member_inline_size <= 4) {
4093                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4094                }
4095                let inner_offset;
4096                let mut inner_depth = depth.clone();
4097                if inlined {
4098                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4099                    inner_offset = next_offset;
4100                } else {
4101                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4102                    inner_depth.increment()?;
4103                }
4104                let val_ref = self
4105                    .inaccessible_domain_supported
4106                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
4107                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4108                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4109                {
4110                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4111                }
4112                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4113                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4114                }
4115            }
4116
4117            next_offset += envelope_size;
4118            _next_ordinal_to_read += 1;
4119            if next_offset >= end_offset {
4120                return Ok(());
4121            }
4122
4123            // Decode unknown envelopes for gaps in ordinals.
4124            while _next_ordinal_to_read < 8 {
4125                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4126                _next_ordinal_to_read += 1;
4127                next_offset += envelope_size;
4128            }
4129
4130            let next_out_of_line = decoder.next_out_of_line();
4131            let handles_before = decoder.remaining_handles();
4132            if let Some((inlined, num_bytes, num_handles)) =
4133                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4134            {
4135                let member_inline_size =
4136                    <fidl::encoding::Vector<Heap, 64> as fidl::encoding::TypeMarker>::inline_size(
4137                        decoder.context,
4138                    );
4139                if inlined != (member_inline_size <= 4) {
4140                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4141                }
4142                let inner_offset;
4143                let mut inner_depth = depth.clone();
4144                if inlined {
4145                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4146                    inner_offset = next_offset;
4147                } else {
4148                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4149                    inner_depth.increment()?;
4150                }
4151                let val_ref = self
4152                    .permitted_heaps
4153                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<Heap, 64>, D));
4154                fidl::decode!(fidl::encoding::Vector<Heap, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
4155                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4156                {
4157                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4158                }
4159                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4160                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4161                }
4162            }
4163
4164            next_offset += envelope_size;
4165
4166            // Decode the remaining unknown envelopes.
4167            while next_offset < end_offset {
4168                _next_ordinal_to_read += 1;
4169                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4170                next_offset += envelope_size;
4171            }
4172
4173            Ok(())
4174        }
4175    }
4176
4177    impl BufferMemorySettings {
4178        #[inline(always)]
4179        fn max_ordinal_present(&self) -> u64 {
4180            if let Some(_) = self.heap {
4181                return 5;
4182            }
4183            if let Some(_) = self.coherency_domain {
4184                return 4;
4185            }
4186            if let Some(_) = self.is_secure {
4187                return 3;
4188            }
4189            if let Some(_) = self.is_physically_contiguous {
4190                return 2;
4191            }
4192            if let Some(_) = self.size_bytes {
4193                return 1;
4194            }
4195            0
4196        }
4197    }
4198
4199    impl fidl::encoding::ValueTypeMarker for BufferMemorySettings {
4200        type Borrowed<'a> = &'a Self;
4201        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4202            value
4203        }
4204    }
4205
4206    unsafe impl fidl::encoding::TypeMarker for BufferMemorySettings {
4207        type Owned = Self;
4208
4209        #[inline(always)]
4210        fn inline_align(_context: fidl::encoding::Context) -> usize {
4211            8
4212        }
4213
4214        #[inline(always)]
4215        fn inline_size(_context: fidl::encoding::Context) -> usize {
4216            16
4217        }
4218    }
4219
4220    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BufferMemorySettings, D>
4221        for &BufferMemorySettings
4222    {
4223        unsafe fn encode(
4224            self,
4225            encoder: &mut fidl::encoding::Encoder<'_, D>,
4226            offset: usize,
4227            mut depth: fidl::encoding::Depth,
4228        ) -> fidl::Result<()> {
4229            encoder.debug_check_bounds::<BufferMemorySettings>(offset);
4230            // Vector header
4231            let max_ordinal: u64 = self.max_ordinal_present();
4232            encoder.write_num(max_ordinal, offset);
4233            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4234            // Calling encoder.out_of_line_offset(0) is not allowed.
4235            if max_ordinal == 0 {
4236                return Ok(());
4237            }
4238            depth.increment()?;
4239            let envelope_size = 8;
4240            let bytes_len = max_ordinal as usize * envelope_size;
4241            #[allow(unused_variables)]
4242            let offset = encoder.out_of_line_offset(bytes_len);
4243            let mut _prev_end_offset: usize = 0;
4244            if 1 > max_ordinal {
4245                return Ok(());
4246            }
4247
4248            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4249            // are envelope_size bytes.
4250            let cur_offset: usize = (1 - 1) * envelope_size;
4251
4252            // Zero reserved fields.
4253            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4254
4255            // Safety:
4256            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4257            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4258            //   envelope_size bytes, there is always sufficient room.
4259            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4260                self.size_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4261                encoder,
4262                offset + cur_offset,
4263                depth,
4264            )?;
4265
4266            _prev_end_offset = cur_offset + envelope_size;
4267            if 2 > max_ordinal {
4268                return Ok(());
4269            }
4270
4271            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4272            // are envelope_size bytes.
4273            let cur_offset: usize = (2 - 1) * envelope_size;
4274
4275            // Zero reserved fields.
4276            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4277
4278            // Safety:
4279            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4280            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4281            //   envelope_size bytes, there is always sufficient room.
4282            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4283                self.is_physically_contiguous
4284                    .as_ref()
4285                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4286                encoder,
4287                offset + cur_offset,
4288                depth,
4289            )?;
4290
4291            _prev_end_offset = cur_offset + envelope_size;
4292            if 3 > max_ordinal {
4293                return Ok(());
4294            }
4295
4296            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4297            // are envelope_size bytes.
4298            let cur_offset: usize = (3 - 1) * envelope_size;
4299
4300            // Zero reserved fields.
4301            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4302
4303            // Safety:
4304            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4305            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4306            //   envelope_size bytes, there is always sufficient room.
4307            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4308                self.is_secure.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4309                encoder,
4310                offset + cur_offset,
4311                depth,
4312            )?;
4313
4314            _prev_end_offset = cur_offset + envelope_size;
4315            if 4 > max_ordinal {
4316                return Ok(());
4317            }
4318
4319            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4320            // are envelope_size bytes.
4321            let cur_offset: usize = (4 - 1) * envelope_size;
4322
4323            // Zero reserved fields.
4324            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4325
4326            // Safety:
4327            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4328            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4329            //   envelope_size bytes, there is always sufficient room.
4330            fidl::encoding::encode_in_envelope_optional::<CoherencyDomain, D>(
4331                self.coherency_domain
4332                    .as_ref()
4333                    .map(<CoherencyDomain as fidl::encoding::ValueTypeMarker>::borrow),
4334                encoder,
4335                offset + cur_offset,
4336                depth,
4337            )?;
4338
4339            _prev_end_offset = cur_offset + envelope_size;
4340            if 5 > max_ordinal {
4341                return Ok(());
4342            }
4343
4344            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4345            // are envelope_size bytes.
4346            let cur_offset: usize = (5 - 1) * envelope_size;
4347
4348            // Zero reserved fields.
4349            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4350
4351            // Safety:
4352            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4353            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4354            //   envelope_size bytes, there is always sufficient room.
4355            fidl::encoding::encode_in_envelope_optional::<Heap, D>(
4356                self.heap.as_ref().map(<Heap as fidl::encoding::ValueTypeMarker>::borrow),
4357                encoder,
4358                offset + cur_offset,
4359                depth,
4360            )?;
4361
4362            _prev_end_offset = cur_offset + envelope_size;
4363
4364            Ok(())
4365        }
4366    }
4367
4368    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BufferMemorySettings {
4369        #[inline(always)]
4370        fn new_empty() -> Self {
4371            Self::default()
4372        }
4373
4374        unsafe fn decode(
4375            &mut self,
4376            decoder: &mut fidl::encoding::Decoder<'_, D>,
4377            offset: usize,
4378            mut depth: fidl::encoding::Depth,
4379        ) -> fidl::Result<()> {
4380            decoder.debug_check_bounds::<Self>(offset);
4381            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4382                None => return Err(fidl::Error::NotNullable),
4383                Some(len) => len,
4384            };
4385            // Calling decoder.out_of_line_offset(0) is not allowed.
4386            if len == 0 {
4387                return Ok(());
4388            };
4389            depth.increment()?;
4390            let envelope_size = 8;
4391            let bytes_len = len * envelope_size;
4392            let offset = decoder.out_of_line_offset(bytes_len)?;
4393            // Decode the envelope for each type.
4394            let mut _next_ordinal_to_read = 0;
4395            let mut next_offset = offset;
4396            let end_offset = offset + bytes_len;
4397            _next_ordinal_to_read += 1;
4398            if next_offset >= end_offset {
4399                return Ok(());
4400            }
4401
4402            // Decode unknown envelopes for gaps in ordinals.
4403            while _next_ordinal_to_read < 1 {
4404                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4405                _next_ordinal_to_read += 1;
4406                next_offset += envelope_size;
4407            }
4408
4409            let next_out_of_line = decoder.next_out_of_line();
4410            let handles_before = decoder.remaining_handles();
4411            if let Some((inlined, num_bytes, num_handles)) =
4412                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4413            {
4414                let member_inline_size =
4415                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4416                if inlined != (member_inline_size <= 4) {
4417                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4418                }
4419                let inner_offset;
4420                let mut inner_depth = depth.clone();
4421                if inlined {
4422                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4423                    inner_offset = next_offset;
4424                } else {
4425                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4426                    inner_depth.increment()?;
4427                }
4428                let val_ref = self.size_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4429                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4430                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4431                {
4432                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4433                }
4434                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4435                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4436                }
4437            }
4438
4439            next_offset += envelope_size;
4440            _next_ordinal_to_read += 1;
4441            if next_offset >= end_offset {
4442                return Ok(());
4443            }
4444
4445            // Decode unknown envelopes for gaps in ordinals.
4446            while _next_ordinal_to_read < 2 {
4447                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4448                _next_ordinal_to_read += 1;
4449                next_offset += envelope_size;
4450            }
4451
4452            let next_out_of_line = decoder.next_out_of_line();
4453            let handles_before = decoder.remaining_handles();
4454            if let Some((inlined, num_bytes, num_handles)) =
4455                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4456            {
4457                let member_inline_size =
4458                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4459                if inlined != (member_inline_size <= 4) {
4460                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4461                }
4462                let inner_offset;
4463                let mut inner_depth = depth.clone();
4464                if inlined {
4465                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4466                    inner_offset = next_offset;
4467                } else {
4468                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4469                    inner_depth.increment()?;
4470                }
4471                let val_ref =
4472                    self.is_physically_contiguous.get_or_insert_with(|| fidl::new_empty!(bool, D));
4473                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4474                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4475                {
4476                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4477                }
4478                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4479                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4480                }
4481            }
4482
4483            next_offset += envelope_size;
4484            _next_ordinal_to_read += 1;
4485            if next_offset >= end_offset {
4486                return Ok(());
4487            }
4488
4489            // Decode unknown envelopes for gaps in ordinals.
4490            while _next_ordinal_to_read < 3 {
4491                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4492                _next_ordinal_to_read += 1;
4493                next_offset += envelope_size;
4494            }
4495
4496            let next_out_of_line = decoder.next_out_of_line();
4497            let handles_before = decoder.remaining_handles();
4498            if let Some((inlined, num_bytes, num_handles)) =
4499                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4500            {
4501                let member_inline_size =
4502                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4503                if inlined != (member_inline_size <= 4) {
4504                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4505                }
4506                let inner_offset;
4507                let mut inner_depth = depth.clone();
4508                if inlined {
4509                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4510                    inner_offset = next_offset;
4511                } else {
4512                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4513                    inner_depth.increment()?;
4514                }
4515                let val_ref = self.is_secure.get_or_insert_with(|| fidl::new_empty!(bool, D));
4516                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4517                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4518                {
4519                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4520                }
4521                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4522                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4523                }
4524            }
4525
4526            next_offset += envelope_size;
4527            _next_ordinal_to_read += 1;
4528            if next_offset >= end_offset {
4529                return Ok(());
4530            }
4531
4532            // Decode unknown envelopes for gaps in ordinals.
4533            while _next_ordinal_to_read < 4 {
4534                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4535                _next_ordinal_to_read += 1;
4536                next_offset += envelope_size;
4537            }
4538
4539            let next_out_of_line = decoder.next_out_of_line();
4540            let handles_before = decoder.remaining_handles();
4541            if let Some((inlined, num_bytes, num_handles)) =
4542                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4543            {
4544                let member_inline_size =
4545                    <CoherencyDomain as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4546                if inlined != (member_inline_size <= 4) {
4547                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4548                }
4549                let inner_offset;
4550                let mut inner_depth = depth.clone();
4551                if inlined {
4552                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4553                    inner_offset = next_offset;
4554                } else {
4555                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4556                    inner_depth.increment()?;
4557                }
4558                let val_ref = self
4559                    .coherency_domain
4560                    .get_or_insert_with(|| fidl::new_empty!(CoherencyDomain, D));
4561                fidl::decode!(CoherencyDomain, D, val_ref, decoder, inner_offset, inner_depth)?;
4562                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4563                {
4564                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4565                }
4566                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4567                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4568                }
4569            }
4570
4571            next_offset += envelope_size;
4572            _next_ordinal_to_read += 1;
4573            if next_offset >= end_offset {
4574                return Ok(());
4575            }
4576
4577            // Decode unknown envelopes for gaps in ordinals.
4578            while _next_ordinal_to_read < 5 {
4579                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4580                _next_ordinal_to_read += 1;
4581                next_offset += envelope_size;
4582            }
4583
4584            let next_out_of_line = decoder.next_out_of_line();
4585            let handles_before = decoder.remaining_handles();
4586            if let Some((inlined, num_bytes, num_handles)) =
4587                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4588            {
4589                let member_inline_size =
4590                    <Heap as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4591                if inlined != (member_inline_size <= 4) {
4592                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4593                }
4594                let inner_offset;
4595                let mut inner_depth = depth.clone();
4596                if inlined {
4597                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4598                    inner_offset = next_offset;
4599                } else {
4600                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4601                    inner_depth.increment()?;
4602                }
4603                let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(Heap, D));
4604                fidl::decode!(Heap, D, val_ref, decoder, inner_offset, inner_depth)?;
4605                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4606                {
4607                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4608                }
4609                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4610                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4611                }
4612            }
4613
4614            next_offset += envelope_size;
4615
4616            // Decode the remaining unknown envelopes.
4617            while next_offset < end_offset {
4618                _next_ordinal_to_read += 1;
4619                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4620                next_offset += envelope_size;
4621            }
4622
4623            Ok(())
4624        }
4625    }
4626
4627    impl BufferUsage {
4628        #[inline(always)]
4629        fn max_ordinal_present(&self) -> u64 {
4630            if let Some(_) = self.video {
4631                return 5;
4632            }
4633            if let Some(_) = self.display {
4634                return 4;
4635            }
4636            if let Some(_) = self.vulkan {
4637                return 3;
4638            }
4639            if let Some(_) = self.cpu {
4640                return 2;
4641            }
4642            if let Some(_) = self.none {
4643                return 1;
4644            }
4645            0
4646        }
4647    }
4648
4649    impl fidl::encoding::ValueTypeMarker for BufferUsage {
4650        type Borrowed<'a> = &'a Self;
4651        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4652            value
4653        }
4654    }
4655
4656    unsafe impl fidl::encoding::TypeMarker for BufferUsage {
4657        type Owned = Self;
4658
4659        #[inline(always)]
4660        fn inline_align(_context: fidl::encoding::Context) -> usize {
4661            8
4662        }
4663
4664        #[inline(always)]
4665        fn inline_size(_context: fidl::encoding::Context) -> usize {
4666            16
4667        }
4668    }
4669
4670    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BufferUsage, D>
4671        for &BufferUsage
4672    {
4673        unsafe fn encode(
4674            self,
4675            encoder: &mut fidl::encoding::Encoder<'_, D>,
4676            offset: usize,
4677            mut depth: fidl::encoding::Depth,
4678        ) -> fidl::Result<()> {
4679            encoder.debug_check_bounds::<BufferUsage>(offset);
4680            // Vector header
4681            let max_ordinal: u64 = self.max_ordinal_present();
4682            encoder.write_num(max_ordinal, offset);
4683            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4684            // Calling encoder.out_of_line_offset(0) is not allowed.
4685            if max_ordinal == 0 {
4686                return Ok(());
4687            }
4688            depth.increment()?;
4689            let envelope_size = 8;
4690            let bytes_len = max_ordinal as usize * envelope_size;
4691            #[allow(unused_variables)]
4692            let offset = encoder.out_of_line_offset(bytes_len);
4693            let mut _prev_end_offset: usize = 0;
4694            if 1 > max_ordinal {
4695                return Ok(());
4696            }
4697
4698            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4699            // are envelope_size bytes.
4700            let cur_offset: usize = (1 - 1) * envelope_size;
4701
4702            // Zero reserved fields.
4703            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4704
4705            // Safety:
4706            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4707            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4708            //   envelope_size bytes, there is always sufficient room.
4709            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4710                self.none.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4711                encoder,
4712                offset + cur_offset,
4713                depth,
4714            )?;
4715
4716            _prev_end_offset = cur_offset + envelope_size;
4717            if 2 > max_ordinal {
4718                return Ok(());
4719            }
4720
4721            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4722            // are envelope_size bytes.
4723            let cur_offset: usize = (2 - 1) * envelope_size;
4724
4725            // Zero reserved fields.
4726            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4727
4728            // Safety:
4729            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4730            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4731            //   envelope_size bytes, there is always sufficient room.
4732            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4733                self.cpu.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4734                encoder,
4735                offset + cur_offset,
4736                depth,
4737            )?;
4738
4739            _prev_end_offset = cur_offset + envelope_size;
4740            if 3 > max_ordinal {
4741                return Ok(());
4742            }
4743
4744            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4745            // are envelope_size bytes.
4746            let cur_offset: usize = (3 - 1) * envelope_size;
4747
4748            // Zero reserved fields.
4749            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4750
4751            // Safety:
4752            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4753            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4754            //   envelope_size bytes, there is always sufficient room.
4755            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4756                self.vulkan.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4757                encoder,
4758                offset + cur_offset,
4759                depth,
4760            )?;
4761
4762            _prev_end_offset = cur_offset + envelope_size;
4763            if 4 > max_ordinal {
4764                return Ok(());
4765            }
4766
4767            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4768            // are envelope_size bytes.
4769            let cur_offset: usize = (4 - 1) * envelope_size;
4770
4771            // Zero reserved fields.
4772            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4773
4774            // Safety:
4775            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4776            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4777            //   envelope_size bytes, there is always sufficient room.
4778            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4779                self.display.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4780                encoder,
4781                offset + cur_offset,
4782                depth,
4783            )?;
4784
4785            _prev_end_offset = cur_offset + envelope_size;
4786            if 5 > max_ordinal {
4787                return Ok(());
4788            }
4789
4790            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4791            // are envelope_size bytes.
4792            let cur_offset: usize = (5 - 1) * envelope_size;
4793
4794            // Zero reserved fields.
4795            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4796
4797            // Safety:
4798            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4799            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4800            //   envelope_size bytes, there is always sufficient room.
4801            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4802                self.video.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4803                encoder,
4804                offset + cur_offset,
4805                depth,
4806            )?;
4807
4808            _prev_end_offset = cur_offset + envelope_size;
4809
4810            Ok(())
4811        }
4812    }
4813
4814    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BufferUsage {
4815        #[inline(always)]
4816        fn new_empty() -> Self {
4817            Self::default()
4818        }
4819
4820        unsafe fn decode(
4821            &mut self,
4822            decoder: &mut fidl::encoding::Decoder<'_, D>,
4823            offset: usize,
4824            mut depth: fidl::encoding::Depth,
4825        ) -> fidl::Result<()> {
4826            decoder.debug_check_bounds::<Self>(offset);
4827            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4828                None => return Err(fidl::Error::NotNullable),
4829                Some(len) => len,
4830            };
4831            // Calling decoder.out_of_line_offset(0) is not allowed.
4832            if len == 0 {
4833                return Ok(());
4834            };
4835            depth.increment()?;
4836            let envelope_size = 8;
4837            let bytes_len = len * envelope_size;
4838            let offset = decoder.out_of_line_offset(bytes_len)?;
4839            // Decode the envelope for each type.
4840            let mut _next_ordinal_to_read = 0;
4841            let mut next_offset = offset;
4842            let end_offset = offset + bytes_len;
4843            _next_ordinal_to_read += 1;
4844            if next_offset >= end_offset {
4845                return Ok(());
4846            }
4847
4848            // Decode unknown envelopes for gaps in ordinals.
4849            while _next_ordinal_to_read < 1 {
4850                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4851                _next_ordinal_to_read += 1;
4852                next_offset += envelope_size;
4853            }
4854
4855            let next_out_of_line = decoder.next_out_of_line();
4856            let handles_before = decoder.remaining_handles();
4857            if let Some((inlined, num_bytes, num_handles)) =
4858                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4859            {
4860                let member_inline_size =
4861                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4862                if inlined != (member_inline_size <= 4) {
4863                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4864                }
4865                let inner_offset;
4866                let mut inner_depth = depth.clone();
4867                if inlined {
4868                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4869                    inner_offset = next_offset;
4870                } else {
4871                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4872                    inner_depth.increment()?;
4873                }
4874                let val_ref = self.none.get_or_insert_with(|| fidl::new_empty!(u32, D));
4875                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4876                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4877                {
4878                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4879                }
4880                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4881                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4882                }
4883            }
4884
4885            next_offset += envelope_size;
4886            _next_ordinal_to_read += 1;
4887            if next_offset >= end_offset {
4888                return Ok(());
4889            }
4890
4891            // Decode unknown envelopes for gaps in ordinals.
4892            while _next_ordinal_to_read < 2 {
4893                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4894                _next_ordinal_to_read += 1;
4895                next_offset += envelope_size;
4896            }
4897
4898            let next_out_of_line = decoder.next_out_of_line();
4899            let handles_before = decoder.remaining_handles();
4900            if let Some((inlined, num_bytes, num_handles)) =
4901                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4902            {
4903                let member_inline_size =
4904                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4905                if inlined != (member_inline_size <= 4) {
4906                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4907                }
4908                let inner_offset;
4909                let mut inner_depth = depth.clone();
4910                if inlined {
4911                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4912                    inner_offset = next_offset;
4913                } else {
4914                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4915                    inner_depth.increment()?;
4916                }
4917                let val_ref = self.cpu.get_or_insert_with(|| fidl::new_empty!(u32, D));
4918                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4919                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4920                {
4921                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4922                }
4923                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4924                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4925                }
4926            }
4927
4928            next_offset += envelope_size;
4929            _next_ordinal_to_read += 1;
4930            if next_offset >= end_offset {
4931                return Ok(());
4932            }
4933
4934            // Decode unknown envelopes for gaps in ordinals.
4935            while _next_ordinal_to_read < 3 {
4936                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4937                _next_ordinal_to_read += 1;
4938                next_offset += envelope_size;
4939            }
4940
4941            let next_out_of_line = decoder.next_out_of_line();
4942            let handles_before = decoder.remaining_handles();
4943            if let Some((inlined, num_bytes, num_handles)) =
4944                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4945            {
4946                let member_inline_size =
4947                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4948                if inlined != (member_inline_size <= 4) {
4949                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4950                }
4951                let inner_offset;
4952                let mut inner_depth = depth.clone();
4953                if inlined {
4954                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4955                    inner_offset = next_offset;
4956                } else {
4957                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4958                    inner_depth.increment()?;
4959                }
4960                let val_ref = self.vulkan.get_or_insert_with(|| fidl::new_empty!(u32, D));
4961                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4962                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4963                {
4964                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4965                }
4966                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4967                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4968                }
4969            }
4970
4971            next_offset += envelope_size;
4972            _next_ordinal_to_read += 1;
4973            if next_offset >= end_offset {
4974                return Ok(());
4975            }
4976
4977            // Decode unknown envelopes for gaps in ordinals.
4978            while _next_ordinal_to_read < 4 {
4979                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4980                _next_ordinal_to_read += 1;
4981                next_offset += envelope_size;
4982            }
4983
4984            let next_out_of_line = decoder.next_out_of_line();
4985            let handles_before = decoder.remaining_handles();
4986            if let Some((inlined, num_bytes, num_handles)) =
4987                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4988            {
4989                let member_inline_size =
4990                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4991                if inlined != (member_inline_size <= 4) {
4992                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4993                }
4994                let inner_offset;
4995                let mut inner_depth = depth.clone();
4996                if inlined {
4997                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4998                    inner_offset = next_offset;
4999                } else {
5000                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5001                    inner_depth.increment()?;
5002                }
5003                let val_ref = self.display.get_or_insert_with(|| fidl::new_empty!(u32, D));
5004                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5005                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5006                {
5007                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5008                }
5009                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5010                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5011                }
5012            }
5013
5014            next_offset += envelope_size;
5015            _next_ordinal_to_read += 1;
5016            if next_offset >= end_offset {
5017                return Ok(());
5018            }
5019
5020            // Decode unknown envelopes for gaps in ordinals.
5021            while _next_ordinal_to_read < 5 {
5022                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5023                _next_ordinal_to_read += 1;
5024                next_offset += envelope_size;
5025            }
5026
5027            let next_out_of_line = decoder.next_out_of_line();
5028            let handles_before = decoder.remaining_handles();
5029            if let Some((inlined, num_bytes, num_handles)) =
5030                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5031            {
5032                let member_inline_size =
5033                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5034                if inlined != (member_inline_size <= 4) {
5035                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5036                }
5037                let inner_offset;
5038                let mut inner_depth = depth.clone();
5039                if inlined {
5040                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5041                    inner_offset = next_offset;
5042                } else {
5043                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5044                    inner_depth.increment()?;
5045                }
5046                let val_ref = self.video.get_or_insert_with(|| fidl::new_empty!(u32, D));
5047                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5048                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5049                {
5050                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5051                }
5052                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5053                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5054                }
5055            }
5056
5057            next_offset += envelope_size;
5058
5059            // Decode the remaining unknown envelopes.
5060            while next_offset < end_offset {
5061                _next_ordinal_to_read += 1;
5062                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5063                next_offset += envelope_size;
5064            }
5065
5066            Ok(())
5067        }
5068    }
5069
5070    impl Config {
5071        #[inline(always)]
5072        fn max_ordinal_present(&self) -> u64 {
5073            if let Some(_) = self.format_costs {
5074                return 1;
5075            }
5076            0
5077        }
5078    }
5079
5080    impl fidl::encoding::ValueTypeMarker for Config {
5081        type Borrowed<'a> = &'a Self;
5082        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5083            value
5084        }
5085    }
5086
5087    unsafe impl fidl::encoding::TypeMarker for Config {
5088        type Owned = Self;
5089
5090        #[inline(always)]
5091        fn inline_align(_context: fidl::encoding::Context) -> usize {
5092            8
5093        }
5094
5095        #[inline(always)]
5096        fn inline_size(_context: fidl::encoding::Context) -> usize {
5097            16
5098        }
5099    }
5100
5101    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Config, D> for &Config {
5102        unsafe fn encode(
5103            self,
5104            encoder: &mut fidl::encoding::Encoder<'_, D>,
5105            offset: usize,
5106            mut depth: fidl::encoding::Depth,
5107        ) -> fidl::Result<()> {
5108            encoder.debug_check_bounds::<Config>(offset);
5109            // Vector header
5110            let max_ordinal: u64 = self.max_ordinal_present();
5111            encoder.write_num(max_ordinal, offset);
5112            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5113            // Calling encoder.out_of_line_offset(0) is not allowed.
5114            if max_ordinal == 0 {
5115                return Ok(());
5116            }
5117            depth.increment()?;
5118            let envelope_size = 8;
5119            let bytes_len = max_ordinal as usize * envelope_size;
5120            #[allow(unused_variables)]
5121            let offset = encoder.out_of_line_offset(bytes_len);
5122            let mut _prev_end_offset: usize = 0;
5123            if 1 > max_ordinal {
5124                return Ok(());
5125            }
5126
5127            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5128            // are envelope_size bytes.
5129            let cur_offset: usize = (1 - 1) * envelope_size;
5130
5131            // Zero reserved fields.
5132            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5133
5134            // Safety:
5135            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5136            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5137            //   envelope_size bytes, there is always sufficient room.
5138            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<FormatCostEntry>, D>(
5139            self.format_costs.as_ref().map(<fidl::encoding::UnboundedVector<FormatCostEntry> as fidl::encoding::ValueTypeMarker>::borrow),
5140            encoder, offset + cur_offset, depth
5141        )?;
5142
5143            _prev_end_offset = cur_offset + envelope_size;
5144
5145            Ok(())
5146        }
5147    }
5148
5149    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Config {
5150        #[inline(always)]
5151        fn new_empty() -> Self {
5152            Self::default()
5153        }
5154
5155        unsafe fn decode(
5156            &mut self,
5157            decoder: &mut fidl::encoding::Decoder<'_, D>,
5158            offset: usize,
5159            mut depth: fidl::encoding::Depth,
5160        ) -> fidl::Result<()> {
5161            decoder.debug_check_bounds::<Self>(offset);
5162            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5163                None => return Err(fidl::Error::NotNullable),
5164                Some(len) => len,
5165            };
5166            // Calling decoder.out_of_line_offset(0) is not allowed.
5167            if len == 0 {
5168                return Ok(());
5169            };
5170            depth.increment()?;
5171            let envelope_size = 8;
5172            let bytes_len = len * envelope_size;
5173            let offset = decoder.out_of_line_offset(bytes_len)?;
5174            // Decode the envelope for each type.
5175            let mut _next_ordinal_to_read = 0;
5176            let mut next_offset = offset;
5177            let end_offset = offset + bytes_len;
5178            _next_ordinal_to_read += 1;
5179            if next_offset >= end_offset {
5180                return Ok(());
5181            }
5182
5183            // Decode unknown envelopes for gaps in ordinals.
5184            while _next_ordinal_to_read < 1 {
5185                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5186                _next_ordinal_to_read += 1;
5187                next_offset += envelope_size;
5188            }
5189
5190            let next_out_of_line = decoder.next_out_of_line();
5191            let handles_before = decoder.remaining_handles();
5192            if let Some((inlined, num_bytes, num_handles)) =
5193                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5194            {
5195                let member_inline_size = <fidl::encoding::UnboundedVector<FormatCostEntry> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5196                if inlined != (member_inline_size <= 4) {
5197                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5198                }
5199                let inner_offset;
5200                let mut inner_depth = depth.clone();
5201                if inlined {
5202                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5203                    inner_offset = next_offset;
5204                } else {
5205                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5206                    inner_depth.increment()?;
5207                }
5208                let val_ref = self.format_costs.get_or_insert_with(|| {
5209                    fidl::new_empty!(fidl::encoding::UnboundedVector<FormatCostEntry>, D)
5210                });
5211                fidl::decode!(
5212                    fidl::encoding::UnboundedVector<FormatCostEntry>,
5213                    D,
5214                    val_ref,
5215                    decoder,
5216                    inner_offset,
5217                    inner_depth
5218                )?;
5219                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5220                {
5221                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5222                }
5223                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5224                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5225                }
5226            }
5227
5228            next_offset += envelope_size;
5229
5230            // Decode the remaining unknown envelopes.
5231            while next_offset < end_offset {
5232                _next_ordinal_to_read += 1;
5233                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5234                next_offset += envelope_size;
5235            }
5236
5237            Ok(())
5238        }
5239    }
5240
5241    impl DynamicSecureHeap {
5242        #[inline(always)]
5243        fn max_ordinal_present(&self) -> u64 {
5244            if let Some(_) = self.heap {
5245                return 1;
5246            }
5247            0
5248        }
5249    }
5250
5251    impl fidl::encoding::ValueTypeMarker for DynamicSecureHeap {
5252        type Borrowed<'a> = &'a Self;
5253        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5254            value
5255        }
5256    }
5257
5258    unsafe impl fidl::encoding::TypeMarker for DynamicSecureHeap {
5259        type Owned = Self;
5260
5261        #[inline(always)]
5262        fn inline_align(_context: fidl::encoding::Context) -> usize {
5263            8
5264        }
5265
5266        #[inline(always)]
5267        fn inline_size(_context: fidl::encoding::Context) -> usize {
5268            16
5269        }
5270    }
5271
5272    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DynamicSecureHeap, D>
5273        for &DynamicSecureHeap
5274    {
5275        unsafe fn encode(
5276            self,
5277            encoder: &mut fidl::encoding::Encoder<'_, D>,
5278            offset: usize,
5279            mut depth: fidl::encoding::Depth,
5280        ) -> fidl::Result<()> {
5281            encoder.debug_check_bounds::<DynamicSecureHeap>(offset);
5282            // Vector header
5283            let max_ordinal: u64 = self.max_ordinal_present();
5284            encoder.write_num(max_ordinal, offset);
5285            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5286            // Calling encoder.out_of_line_offset(0) is not allowed.
5287            if max_ordinal == 0 {
5288                return Ok(());
5289            }
5290            depth.increment()?;
5291            let envelope_size = 8;
5292            let bytes_len = max_ordinal as usize * envelope_size;
5293            #[allow(unused_variables)]
5294            let offset = encoder.out_of_line_offset(bytes_len);
5295            let mut _prev_end_offset: usize = 0;
5296            if 1 > max_ordinal {
5297                return Ok(());
5298            }
5299
5300            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5301            // are envelope_size bytes.
5302            let cur_offset: usize = (1 - 1) * envelope_size;
5303
5304            // Zero reserved fields.
5305            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5306
5307            // Safety:
5308            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5309            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5310            //   envelope_size bytes, there is always sufficient room.
5311            fidl::encoding::encode_in_envelope_optional::<Heap, D>(
5312                self.heap.as_ref().map(<Heap as fidl::encoding::ValueTypeMarker>::borrow),
5313                encoder,
5314                offset + cur_offset,
5315                depth,
5316            )?;
5317
5318            _prev_end_offset = cur_offset + envelope_size;
5319
5320            Ok(())
5321        }
5322    }
5323
5324    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DynamicSecureHeap {
5325        #[inline(always)]
5326        fn new_empty() -> Self {
5327            Self::default()
5328        }
5329
5330        unsafe fn decode(
5331            &mut self,
5332            decoder: &mut fidl::encoding::Decoder<'_, D>,
5333            offset: usize,
5334            mut depth: fidl::encoding::Depth,
5335        ) -> fidl::Result<()> {
5336            decoder.debug_check_bounds::<Self>(offset);
5337            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5338                None => return Err(fidl::Error::NotNullable),
5339                Some(len) => len,
5340            };
5341            // Calling decoder.out_of_line_offset(0) is not allowed.
5342            if len == 0 {
5343                return Ok(());
5344            };
5345            depth.increment()?;
5346            let envelope_size = 8;
5347            let bytes_len = len * envelope_size;
5348            let offset = decoder.out_of_line_offset(bytes_len)?;
5349            // Decode the envelope for each type.
5350            let mut _next_ordinal_to_read = 0;
5351            let mut next_offset = offset;
5352            let end_offset = offset + bytes_len;
5353            _next_ordinal_to_read += 1;
5354            if next_offset >= end_offset {
5355                return Ok(());
5356            }
5357
5358            // Decode unknown envelopes for gaps in ordinals.
5359            while _next_ordinal_to_read < 1 {
5360                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5361                _next_ordinal_to_read += 1;
5362                next_offset += envelope_size;
5363            }
5364
5365            let next_out_of_line = decoder.next_out_of_line();
5366            let handles_before = decoder.remaining_handles();
5367            if let Some((inlined, num_bytes, num_handles)) =
5368                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5369            {
5370                let member_inline_size =
5371                    <Heap as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5372                if inlined != (member_inline_size <= 4) {
5373                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5374                }
5375                let inner_offset;
5376                let mut inner_depth = depth.clone();
5377                if inlined {
5378                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5379                    inner_offset = next_offset;
5380                } else {
5381                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5382                    inner_depth.increment()?;
5383                }
5384                let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(Heap, D));
5385                fidl::decode!(Heap, D, val_ref, decoder, inner_offset, inner_depth)?;
5386                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5387                {
5388                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5389                }
5390                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5391                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5392                }
5393            }
5394
5395            next_offset += envelope_size;
5396
5397            // Decode the remaining unknown envelopes.
5398            while next_offset < end_offset {
5399                _next_ordinal_to_read += 1;
5400                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5401                next_offset += envelope_size;
5402            }
5403
5404            Ok(())
5405        }
5406    }
5407
5408    impl FormatCostEntry {
5409        #[inline(always)]
5410        fn max_ordinal_present(&self) -> u64 {
5411            if let Some(_) = self.cost {
5412                return 2;
5413            }
5414            if let Some(_) = self.key {
5415                return 1;
5416            }
5417            0
5418        }
5419    }
5420
5421    impl fidl::encoding::ValueTypeMarker for FormatCostEntry {
5422        type Borrowed<'a> = &'a Self;
5423        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5424            value
5425        }
5426    }
5427
5428    unsafe impl fidl::encoding::TypeMarker for FormatCostEntry {
5429        type Owned = Self;
5430
5431        #[inline(always)]
5432        fn inline_align(_context: fidl::encoding::Context) -> usize {
5433            8
5434        }
5435
5436        #[inline(always)]
5437        fn inline_size(_context: fidl::encoding::Context) -> usize {
5438            16
5439        }
5440    }
5441
5442    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FormatCostEntry, D>
5443        for &FormatCostEntry
5444    {
5445        unsafe fn encode(
5446            self,
5447            encoder: &mut fidl::encoding::Encoder<'_, D>,
5448            offset: usize,
5449            mut depth: fidl::encoding::Depth,
5450        ) -> fidl::Result<()> {
5451            encoder.debug_check_bounds::<FormatCostEntry>(offset);
5452            // Vector header
5453            let max_ordinal: u64 = self.max_ordinal_present();
5454            encoder.write_num(max_ordinal, offset);
5455            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5456            // Calling encoder.out_of_line_offset(0) is not allowed.
5457            if max_ordinal == 0 {
5458                return Ok(());
5459            }
5460            depth.increment()?;
5461            let envelope_size = 8;
5462            let bytes_len = max_ordinal as usize * envelope_size;
5463            #[allow(unused_variables)]
5464            let offset = encoder.out_of_line_offset(bytes_len);
5465            let mut _prev_end_offset: usize = 0;
5466            if 1 > max_ordinal {
5467                return Ok(());
5468            }
5469
5470            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5471            // are envelope_size bytes.
5472            let cur_offset: usize = (1 - 1) * envelope_size;
5473
5474            // Zero reserved fields.
5475            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5476
5477            // Safety:
5478            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5479            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5480            //   envelope_size bytes, there is always sufficient room.
5481            fidl::encoding::encode_in_envelope_optional::<FormatCostKey, D>(
5482                self.key.as_ref().map(<FormatCostKey as fidl::encoding::ValueTypeMarker>::borrow),
5483                encoder,
5484                offset + cur_offset,
5485                depth,
5486            )?;
5487
5488            _prev_end_offset = cur_offset + envelope_size;
5489            if 2 > max_ordinal {
5490                return Ok(());
5491            }
5492
5493            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5494            // are envelope_size bytes.
5495            let cur_offset: usize = (2 - 1) * envelope_size;
5496
5497            // Zero reserved fields.
5498            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5499
5500            // Safety:
5501            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5502            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5503            //   envelope_size bytes, there is always sufficient room.
5504            fidl::encoding::encode_in_envelope_optional::<f32, D>(
5505                self.cost.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
5506                encoder,
5507                offset + cur_offset,
5508                depth,
5509            )?;
5510
5511            _prev_end_offset = cur_offset + envelope_size;
5512
5513            Ok(())
5514        }
5515    }
5516
5517    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FormatCostEntry {
5518        #[inline(always)]
5519        fn new_empty() -> Self {
5520            Self::default()
5521        }
5522
5523        unsafe fn decode(
5524            &mut self,
5525            decoder: &mut fidl::encoding::Decoder<'_, D>,
5526            offset: usize,
5527            mut depth: fidl::encoding::Depth,
5528        ) -> fidl::Result<()> {
5529            decoder.debug_check_bounds::<Self>(offset);
5530            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5531                None => return Err(fidl::Error::NotNullable),
5532                Some(len) => len,
5533            };
5534            // Calling decoder.out_of_line_offset(0) is not allowed.
5535            if len == 0 {
5536                return Ok(());
5537            };
5538            depth.increment()?;
5539            let envelope_size = 8;
5540            let bytes_len = len * envelope_size;
5541            let offset = decoder.out_of_line_offset(bytes_len)?;
5542            // Decode the envelope for each type.
5543            let mut _next_ordinal_to_read = 0;
5544            let mut next_offset = offset;
5545            let end_offset = offset + bytes_len;
5546            _next_ordinal_to_read += 1;
5547            if next_offset >= end_offset {
5548                return Ok(());
5549            }
5550
5551            // Decode unknown envelopes for gaps in ordinals.
5552            while _next_ordinal_to_read < 1 {
5553                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5554                _next_ordinal_to_read += 1;
5555                next_offset += envelope_size;
5556            }
5557
5558            let next_out_of_line = decoder.next_out_of_line();
5559            let handles_before = decoder.remaining_handles();
5560            if let Some((inlined, num_bytes, num_handles)) =
5561                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5562            {
5563                let member_inline_size =
5564                    <FormatCostKey as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5565                if inlined != (member_inline_size <= 4) {
5566                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5567                }
5568                let inner_offset;
5569                let mut inner_depth = depth.clone();
5570                if inlined {
5571                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5572                    inner_offset = next_offset;
5573                } else {
5574                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5575                    inner_depth.increment()?;
5576                }
5577                let val_ref = self.key.get_or_insert_with(|| fidl::new_empty!(FormatCostKey, D));
5578                fidl::decode!(FormatCostKey, D, val_ref, decoder, inner_offset, inner_depth)?;
5579                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5580                {
5581                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5582                }
5583                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5584                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5585                }
5586            }
5587
5588            next_offset += envelope_size;
5589            _next_ordinal_to_read += 1;
5590            if next_offset >= end_offset {
5591                return Ok(());
5592            }
5593
5594            // Decode unknown envelopes for gaps in ordinals.
5595            while _next_ordinal_to_read < 2 {
5596                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5597                _next_ordinal_to_read += 1;
5598                next_offset += envelope_size;
5599            }
5600
5601            let next_out_of_line = decoder.next_out_of_line();
5602            let handles_before = decoder.remaining_handles();
5603            if let Some((inlined, num_bytes, num_handles)) =
5604                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5605            {
5606                let member_inline_size =
5607                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5608                if inlined != (member_inline_size <= 4) {
5609                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5610                }
5611                let inner_offset;
5612                let mut inner_depth = depth.clone();
5613                if inlined {
5614                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5615                    inner_offset = next_offset;
5616                } else {
5617                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5618                    inner_depth.increment()?;
5619                }
5620                let val_ref = self.cost.get_or_insert_with(|| fidl::new_empty!(f32, D));
5621                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
5622                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5623                {
5624                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5625                }
5626                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5627                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5628                }
5629            }
5630
5631            next_offset += envelope_size;
5632
5633            // Decode the remaining unknown envelopes.
5634            while next_offset < end_offset {
5635                _next_ordinal_to_read += 1;
5636                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5637                next_offset += envelope_size;
5638            }
5639
5640            Ok(())
5641        }
5642    }
5643
5644    impl FormatCostKey {
5645        #[inline(always)]
5646        fn max_ordinal_present(&self) -> u64 {
5647            if let Some(_) = self.buffer_usage_bits {
5648                return 3;
5649            }
5650            if let Some(_) = self.pixel_format_modifier {
5651                return 2;
5652            }
5653            if let Some(_) = self.pixel_format {
5654                return 1;
5655            }
5656            0
5657        }
5658    }
5659
5660    impl fidl::encoding::ValueTypeMarker for FormatCostKey {
5661        type Borrowed<'a> = &'a Self;
5662        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5663            value
5664        }
5665    }
5666
5667    unsafe impl fidl::encoding::TypeMarker for FormatCostKey {
5668        type Owned = Self;
5669
5670        #[inline(always)]
5671        fn inline_align(_context: fidl::encoding::Context) -> usize {
5672            8
5673        }
5674
5675        #[inline(always)]
5676        fn inline_size(_context: fidl::encoding::Context) -> usize {
5677            16
5678        }
5679    }
5680
5681    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FormatCostKey, D>
5682        for &FormatCostKey
5683    {
5684        unsafe fn encode(
5685            self,
5686            encoder: &mut fidl::encoding::Encoder<'_, D>,
5687            offset: usize,
5688            mut depth: fidl::encoding::Depth,
5689        ) -> fidl::Result<()> {
5690            encoder.debug_check_bounds::<FormatCostKey>(offset);
5691            // Vector header
5692            let max_ordinal: u64 = self.max_ordinal_present();
5693            encoder.write_num(max_ordinal, offset);
5694            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5695            // Calling encoder.out_of_line_offset(0) is not allowed.
5696            if max_ordinal == 0 {
5697                return Ok(());
5698            }
5699            depth.increment()?;
5700            let envelope_size = 8;
5701            let bytes_len = max_ordinal as usize * envelope_size;
5702            #[allow(unused_variables)]
5703            let offset = encoder.out_of_line_offset(bytes_len);
5704            let mut _prev_end_offset: usize = 0;
5705            if 1 > max_ordinal {
5706                return Ok(());
5707            }
5708
5709            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5710            // are envelope_size bytes.
5711            let cur_offset: usize = (1 - 1) * envelope_size;
5712
5713            // Zero reserved fields.
5714            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5715
5716            // Safety:
5717            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5718            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5719            //   envelope_size bytes, there is always sufficient room.
5720            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_images2__common::PixelFormat, D>(
5721            self.pixel_format.as_ref().map(<fidl_fuchsia_images2__common::PixelFormat as fidl::encoding::ValueTypeMarker>::borrow),
5722            encoder, offset + cur_offset, depth
5723        )?;
5724
5725            _prev_end_offset = cur_offset + envelope_size;
5726            if 2 > max_ordinal {
5727                return Ok(());
5728            }
5729
5730            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5731            // are envelope_size bytes.
5732            let cur_offset: usize = (2 - 1) * envelope_size;
5733
5734            // Zero reserved fields.
5735            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5736
5737            // Safety:
5738            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5739            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5740            //   envelope_size bytes, there is always sufficient room.
5741            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_images2__common::PixelFormatModifier, D>(
5742            self.pixel_format_modifier.as_ref().map(<fidl_fuchsia_images2__common::PixelFormatModifier as fidl::encoding::ValueTypeMarker>::borrow),
5743            encoder, offset + cur_offset, depth
5744        )?;
5745
5746            _prev_end_offset = cur_offset + envelope_size;
5747            if 3 > max_ordinal {
5748                return Ok(());
5749            }
5750
5751            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5752            // are envelope_size bytes.
5753            let cur_offset: usize = (3 - 1) * envelope_size;
5754
5755            // Zero reserved fields.
5756            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5757
5758            // Safety:
5759            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5760            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5761            //   envelope_size bytes, there is always sufficient room.
5762            fidl::encoding::encode_in_envelope_optional::<BufferUsage, D>(
5763                self.buffer_usage_bits
5764                    .as_ref()
5765                    .map(<BufferUsage as fidl::encoding::ValueTypeMarker>::borrow),
5766                encoder,
5767                offset + cur_offset,
5768                depth,
5769            )?;
5770
5771            _prev_end_offset = cur_offset + envelope_size;
5772
5773            Ok(())
5774        }
5775    }
5776
5777    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FormatCostKey {
5778        #[inline(always)]
5779        fn new_empty() -> Self {
5780            Self::default()
5781        }
5782
5783        unsafe fn decode(
5784            &mut self,
5785            decoder: &mut fidl::encoding::Decoder<'_, D>,
5786            offset: usize,
5787            mut depth: fidl::encoding::Depth,
5788        ) -> fidl::Result<()> {
5789            decoder.debug_check_bounds::<Self>(offset);
5790            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5791                None => return Err(fidl::Error::NotNullable),
5792                Some(len) => len,
5793            };
5794            // Calling decoder.out_of_line_offset(0) is not allowed.
5795            if len == 0 {
5796                return Ok(());
5797            };
5798            depth.increment()?;
5799            let envelope_size = 8;
5800            let bytes_len = len * envelope_size;
5801            let offset = decoder.out_of_line_offset(bytes_len)?;
5802            // Decode the envelope for each type.
5803            let mut _next_ordinal_to_read = 0;
5804            let mut next_offset = offset;
5805            let end_offset = offset + bytes_len;
5806            _next_ordinal_to_read += 1;
5807            if next_offset >= end_offset {
5808                return Ok(());
5809            }
5810
5811            // Decode unknown envelopes for gaps in ordinals.
5812            while _next_ordinal_to_read < 1 {
5813                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5814                _next_ordinal_to_read += 1;
5815                next_offset += envelope_size;
5816            }
5817
5818            let next_out_of_line = decoder.next_out_of_line();
5819            let handles_before = decoder.remaining_handles();
5820            if let Some((inlined, num_bytes, num_handles)) =
5821                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5822            {
5823                let member_inline_size = <fidl_fuchsia_images2__common::PixelFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5824                if inlined != (member_inline_size <= 4) {
5825                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5826                }
5827                let inner_offset;
5828                let mut inner_depth = depth.clone();
5829                if inlined {
5830                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5831                    inner_offset = next_offset;
5832                } else {
5833                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5834                    inner_depth.increment()?;
5835                }
5836                let val_ref = self.pixel_format.get_or_insert_with(|| {
5837                    fidl::new_empty!(fidl_fuchsia_images2__common::PixelFormat, D)
5838                });
5839                fidl::decode!(
5840                    fidl_fuchsia_images2__common::PixelFormat,
5841                    D,
5842                    val_ref,
5843                    decoder,
5844                    inner_offset,
5845                    inner_depth
5846                )?;
5847                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5848                {
5849                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5850                }
5851                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5852                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5853                }
5854            }
5855
5856            next_offset += envelope_size;
5857            _next_ordinal_to_read += 1;
5858            if next_offset >= end_offset {
5859                return Ok(());
5860            }
5861
5862            // Decode unknown envelopes for gaps in ordinals.
5863            while _next_ordinal_to_read < 2 {
5864                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5865                _next_ordinal_to_read += 1;
5866                next_offset += envelope_size;
5867            }
5868
5869            let next_out_of_line = decoder.next_out_of_line();
5870            let handles_before = decoder.remaining_handles();
5871            if let Some((inlined, num_bytes, num_handles)) =
5872                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5873            {
5874                let member_inline_size = <fidl_fuchsia_images2__common::PixelFormatModifier as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5875                if inlined != (member_inline_size <= 4) {
5876                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5877                }
5878                let inner_offset;
5879                let mut inner_depth = depth.clone();
5880                if inlined {
5881                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5882                    inner_offset = next_offset;
5883                } else {
5884                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5885                    inner_depth.increment()?;
5886                }
5887                let val_ref = self.pixel_format_modifier.get_or_insert_with(|| {
5888                    fidl::new_empty!(fidl_fuchsia_images2__common::PixelFormatModifier, D)
5889                });
5890                fidl::decode!(
5891                    fidl_fuchsia_images2__common::PixelFormatModifier,
5892                    D,
5893                    val_ref,
5894                    decoder,
5895                    inner_offset,
5896                    inner_depth
5897                )?;
5898                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5899                {
5900                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5901                }
5902                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5903                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5904                }
5905            }
5906
5907            next_offset += envelope_size;
5908            _next_ordinal_to_read += 1;
5909            if next_offset >= end_offset {
5910                return Ok(());
5911            }
5912
5913            // Decode unknown envelopes for gaps in ordinals.
5914            while _next_ordinal_to_read < 3 {
5915                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5916                _next_ordinal_to_read += 1;
5917                next_offset += envelope_size;
5918            }
5919
5920            let next_out_of_line = decoder.next_out_of_line();
5921            let handles_before = decoder.remaining_handles();
5922            if let Some((inlined, num_bytes, num_handles)) =
5923                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5924            {
5925                let member_inline_size =
5926                    <BufferUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5927                if inlined != (member_inline_size <= 4) {
5928                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5929                }
5930                let inner_offset;
5931                let mut inner_depth = depth.clone();
5932                if inlined {
5933                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5934                    inner_offset = next_offset;
5935                } else {
5936                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5937                    inner_depth.increment()?;
5938                }
5939                let val_ref =
5940                    self.buffer_usage_bits.get_or_insert_with(|| fidl::new_empty!(BufferUsage, D));
5941                fidl::decode!(BufferUsage, D, val_ref, decoder, inner_offset, inner_depth)?;
5942                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5943                {
5944                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5945                }
5946                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5947                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5948                }
5949            }
5950
5951            next_offset += envelope_size;
5952
5953            // Decode the remaining unknown envelopes.
5954            while next_offset < end_offset {
5955                _next_ordinal_to_read += 1;
5956                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5957                next_offset += envelope_size;
5958            }
5959
5960            Ok(())
5961        }
5962    }
5963
5964    impl FormatCosts {
5965        #[inline(always)]
5966        fn max_ordinal_present(&self) -> u64 {
5967            if let Some(_) = self.format_costs {
5968                return 1;
5969            }
5970            0
5971        }
5972    }
5973
5974    impl fidl::encoding::ValueTypeMarker for FormatCosts {
5975        type Borrowed<'a> = &'a Self;
5976        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5977            value
5978        }
5979    }
5980
5981    unsafe impl fidl::encoding::TypeMarker for FormatCosts {
5982        type Owned = Self;
5983
5984        #[inline(always)]
5985        fn inline_align(_context: fidl::encoding::Context) -> usize {
5986            8
5987        }
5988
5989        #[inline(always)]
5990        fn inline_size(_context: fidl::encoding::Context) -> usize {
5991            16
5992        }
5993    }
5994
5995    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FormatCosts, D>
5996        for &FormatCosts
5997    {
5998        unsafe fn encode(
5999            self,
6000            encoder: &mut fidl::encoding::Encoder<'_, D>,
6001            offset: usize,
6002            mut depth: fidl::encoding::Depth,
6003        ) -> fidl::Result<()> {
6004            encoder.debug_check_bounds::<FormatCosts>(offset);
6005            // Vector header
6006            let max_ordinal: u64 = self.max_ordinal_present();
6007            encoder.write_num(max_ordinal, offset);
6008            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6009            // Calling encoder.out_of_line_offset(0) is not allowed.
6010            if max_ordinal == 0 {
6011                return Ok(());
6012            }
6013            depth.increment()?;
6014            let envelope_size = 8;
6015            let bytes_len = max_ordinal as usize * envelope_size;
6016            #[allow(unused_variables)]
6017            let offset = encoder.out_of_line_offset(bytes_len);
6018            let mut _prev_end_offset: usize = 0;
6019            if 1 > max_ordinal {
6020                return Ok(());
6021            }
6022
6023            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6024            // are envelope_size bytes.
6025            let cur_offset: usize = (1 - 1) * envelope_size;
6026
6027            // Zero reserved fields.
6028            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6029
6030            // Safety:
6031            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6032            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6033            //   envelope_size bytes, there is always sufficient room.
6034            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<FormatCostEntry>, D>(
6035            self.format_costs.as_ref().map(<fidl::encoding::UnboundedVector<FormatCostEntry> as fidl::encoding::ValueTypeMarker>::borrow),
6036            encoder, offset + cur_offset, depth
6037        )?;
6038
6039            _prev_end_offset = cur_offset + envelope_size;
6040
6041            Ok(())
6042        }
6043    }
6044
6045    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FormatCosts {
6046        #[inline(always)]
6047        fn new_empty() -> Self {
6048            Self::default()
6049        }
6050
6051        unsafe fn decode(
6052            &mut self,
6053            decoder: &mut fidl::encoding::Decoder<'_, D>,
6054            offset: usize,
6055            mut depth: fidl::encoding::Depth,
6056        ) -> fidl::Result<()> {
6057            decoder.debug_check_bounds::<Self>(offset);
6058            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6059                None => return Err(fidl::Error::NotNullable),
6060                Some(len) => len,
6061            };
6062            // Calling decoder.out_of_line_offset(0) is not allowed.
6063            if len == 0 {
6064                return Ok(());
6065            };
6066            depth.increment()?;
6067            let envelope_size = 8;
6068            let bytes_len = len * envelope_size;
6069            let offset = decoder.out_of_line_offset(bytes_len)?;
6070            // Decode the envelope for each type.
6071            let mut _next_ordinal_to_read = 0;
6072            let mut next_offset = offset;
6073            let end_offset = offset + bytes_len;
6074            _next_ordinal_to_read += 1;
6075            if next_offset >= end_offset {
6076                return Ok(());
6077            }
6078
6079            // Decode unknown envelopes for gaps in ordinals.
6080            while _next_ordinal_to_read < 1 {
6081                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6082                _next_ordinal_to_read += 1;
6083                next_offset += envelope_size;
6084            }
6085
6086            let next_out_of_line = decoder.next_out_of_line();
6087            let handles_before = decoder.remaining_handles();
6088            if let Some((inlined, num_bytes, num_handles)) =
6089                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6090            {
6091                let member_inline_size = <fidl::encoding::UnboundedVector<FormatCostEntry> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6092                if inlined != (member_inline_size <= 4) {
6093                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6094                }
6095                let inner_offset;
6096                let mut inner_depth = depth.clone();
6097                if inlined {
6098                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6099                    inner_offset = next_offset;
6100                } else {
6101                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6102                    inner_depth.increment()?;
6103                }
6104                let val_ref = self.format_costs.get_or_insert_with(|| {
6105                    fidl::new_empty!(fidl::encoding::UnboundedVector<FormatCostEntry>, D)
6106                });
6107                fidl::decode!(
6108                    fidl::encoding::UnboundedVector<FormatCostEntry>,
6109                    D,
6110                    val_ref,
6111                    decoder,
6112                    inner_offset,
6113                    inner_depth
6114                )?;
6115                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6116                {
6117                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6118                }
6119                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6120                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6121                }
6122            }
6123
6124            next_offset += envelope_size;
6125
6126            // Decode the remaining unknown envelopes.
6127            while next_offset < end_offset {
6128                _next_ordinal_to_read += 1;
6129                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6130                next_offset += envelope_size;
6131            }
6132
6133            Ok(())
6134        }
6135    }
6136
6137    impl Heap {
6138        #[inline(always)]
6139        fn max_ordinal_present(&self) -> u64 {
6140            if let Some(_) = self.id {
6141                return 2;
6142            }
6143            if let Some(_) = self.heap_type {
6144                return 1;
6145            }
6146            0
6147        }
6148    }
6149
6150    impl fidl::encoding::ValueTypeMarker for Heap {
6151        type Borrowed<'a> = &'a Self;
6152        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6153            value
6154        }
6155    }
6156
6157    unsafe impl fidl::encoding::TypeMarker for Heap {
6158        type Owned = Self;
6159
6160        #[inline(always)]
6161        fn inline_align(_context: fidl::encoding::Context) -> usize {
6162            8
6163        }
6164
6165        #[inline(always)]
6166        fn inline_size(_context: fidl::encoding::Context) -> usize {
6167            16
6168        }
6169    }
6170
6171    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Heap, D> for &Heap {
6172        unsafe fn encode(
6173            self,
6174            encoder: &mut fidl::encoding::Encoder<'_, D>,
6175            offset: usize,
6176            mut depth: fidl::encoding::Depth,
6177        ) -> fidl::Result<()> {
6178            encoder.debug_check_bounds::<Heap>(offset);
6179            // Vector header
6180            let max_ordinal: u64 = self.max_ordinal_present();
6181            encoder.write_num(max_ordinal, offset);
6182            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6183            // Calling encoder.out_of_line_offset(0) is not allowed.
6184            if max_ordinal == 0 {
6185                return Ok(());
6186            }
6187            depth.increment()?;
6188            let envelope_size = 8;
6189            let bytes_len = max_ordinal as usize * envelope_size;
6190            #[allow(unused_variables)]
6191            let offset = encoder.out_of_line_offset(bytes_len);
6192            let mut _prev_end_offset: usize = 0;
6193            if 1 > max_ordinal {
6194                return Ok(());
6195            }
6196
6197            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6198            // are envelope_size bytes.
6199            let cur_offset: usize = (1 - 1) * envelope_size;
6200
6201            // Zero reserved fields.
6202            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6203
6204            // Safety:
6205            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6206            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6207            //   envelope_size bytes, there is always sufficient room.
6208            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<128>, D>(
6209                self.heap_type.as_ref().map(
6210                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
6211                ),
6212                encoder,
6213                offset + cur_offset,
6214                depth,
6215            )?;
6216
6217            _prev_end_offset = cur_offset + envelope_size;
6218            if 2 > max_ordinal {
6219                return Ok(());
6220            }
6221
6222            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6223            // are envelope_size bytes.
6224            let cur_offset: usize = (2 - 1) * envelope_size;
6225
6226            // Zero reserved fields.
6227            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6228
6229            // Safety:
6230            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6231            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6232            //   envelope_size bytes, there is always sufficient room.
6233            fidl::encoding::encode_in_envelope_optional::<u64, D>(
6234                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
6235                encoder,
6236                offset + cur_offset,
6237                depth,
6238            )?;
6239
6240            _prev_end_offset = cur_offset + envelope_size;
6241
6242            Ok(())
6243        }
6244    }
6245
6246    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Heap {
6247        #[inline(always)]
6248        fn new_empty() -> Self {
6249            Self::default()
6250        }
6251
6252        unsafe fn decode(
6253            &mut self,
6254            decoder: &mut fidl::encoding::Decoder<'_, D>,
6255            offset: usize,
6256            mut depth: fidl::encoding::Depth,
6257        ) -> fidl::Result<()> {
6258            decoder.debug_check_bounds::<Self>(offset);
6259            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6260                None => return Err(fidl::Error::NotNullable),
6261                Some(len) => len,
6262            };
6263            // Calling decoder.out_of_line_offset(0) is not allowed.
6264            if len == 0 {
6265                return Ok(());
6266            };
6267            depth.increment()?;
6268            let envelope_size = 8;
6269            let bytes_len = len * envelope_size;
6270            let offset = decoder.out_of_line_offset(bytes_len)?;
6271            // Decode the envelope for each type.
6272            let mut _next_ordinal_to_read = 0;
6273            let mut next_offset = offset;
6274            let end_offset = offset + bytes_len;
6275            _next_ordinal_to_read += 1;
6276            if next_offset >= end_offset {
6277                return Ok(());
6278            }
6279
6280            // Decode unknown envelopes for gaps in ordinals.
6281            while _next_ordinal_to_read < 1 {
6282                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6283                _next_ordinal_to_read += 1;
6284                next_offset += envelope_size;
6285            }
6286
6287            let next_out_of_line = decoder.next_out_of_line();
6288            let handles_before = decoder.remaining_handles();
6289            if let Some((inlined, num_bytes, num_handles)) =
6290                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6291            {
6292                let member_inline_size =
6293                    <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
6294                        decoder.context,
6295                    );
6296                if inlined != (member_inline_size <= 4) {
6297                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6298                }
6299                let inner_offset;
6300                let mut inner_depth = depth.clone();
6301                if inlined {
6302                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6303                    inner_offset = next_offset;
6304                } else {
6305                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6306                    inner_depth.increment()?;
6307                }
6308                let val_ref = self
6309                    .heap_type
6310                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
6311                fidl::decode!(
6312                    fidl::encoding::BoundedString<128>,
6313                    D,
6314                    val_ref,
6315                    decoder,
6316                    inner_offset,
6317                    inner_depth
6318                )?;
6319                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6320                {
6321                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6322                }
6323                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6324                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6325                }
6326            }
6327
6328            next_offset += envelope_size;
6329            _next_ordinal_to_read += 1;
6330            if next_offset >= end_offset {
6331                return Ok(());
6332            }
6333
6334            // Decode unknown envelopes for gaps in ordinals.
6335            while _next_ordinal_to_read < 2 {
6336                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6337                _next_ordinal_to_read += 1;
6338                next_offset += envelope_size;
6339            }
6340
6341            let next_out_of_line = decoder.next_out_of_line();
6342            let handles_before = decoder.remaining_handles();
6343            if let Some((inlined, num_bytes, num_handles)) =
6344                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6345            {
6346                let member_inline_size =
6347                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6348                if inlined != (member_inline_size <= 4) {
6349                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6350                }
6351                let inner_offset;
6352                let mut inner_depth = depth.clone();
6353                if inlined {
6354                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6355                    inner_offset = next_offset;
6356                } else {
6357                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6358                    inner_depth.increment()?;
6359                }
6360                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
6361                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
6362                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6363                {
6364                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6365                }
6366                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6367                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6368                }
6369            }
6370
6371            next_offset += envelope_size;
6372
6373            // Decode the remaining unknown envelopes.
6374            while next_offset < end_offset {
6375                _next_ordinal_to_read += 1;
6376                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6377                next_offset += envelope_size;
6378            }
6379
6380            Ok(())
6381        }
6382    }
6383
6384    impl ImageFormatConstraints {
6385        #[inline(always)]
6386        fn max_ordinal_present(&self) -> u64 {
6387            if let Some(_) = self.is_alpha_present {
6388                return 17;
6389            }
6390            if let Some(_) = self.require_bytes_per_row_at_pixel_boundary {
6391                return 16;
6392            }
6393            if let Some(_) = self.pixel_format_and_modifiers {
6394                return 15;
6395            }
6396            if let Some(_) = self.start_offset_divisor {
6397                return 14;
6398            }
6399            if let Some(_) = self.bytes_per_row_divisor {
6400                return 13;
6401            }
6402            if let Some(_) = self.required_max_size {
6403                return 12;
6404            }
6405            if let Some(_) = self.required_min_size {
6406                return 11;
6407            }
6408            if let Some(_) = self.display_rect_alignment {
6409                return 10;
6410            }
6411            if let Some(_) = self.size_alignment {
6412                return 9;
6413            }
6414            if let Some(_) = self.max_width_times_height {
6415                return 8;
6416            }
6417            if let Some(_) = self.max_bytes_per_row {
6418                return 7;
6419            }
6420            if let Some(_) = self.min_bytes_per_row {
6421                return 6;
6422            }
6423            if let Some(_) = self.max_size {
6424                return 5;
6425            }
6426            if let Some(_) = self.min_size {
6427                return 4;
6428            }
6429            if let Some(_) = self.color_spaces {
6430                return 3;
6431            }
6432            if let Some(_) = self.pixel_format_modifier {
6433                return 2;
6434            }
6435            if let Some(_) = self.pixel_format {
6436                return 1;
6437            }
6438            0
6439        }
6440    }
6441
6442    impl fidl::encoding::ValueTypeMarker for ImageFormatConstraints {
6443        type Borrowed<'a> = &'a Self;
6444        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6445            value
6446        }
6447    }
6448
6449    unsafe impl fidl::encoding::TypeMarker for ImageFormatConstraints {
6450        type Owned = Self;
6451
6452        #[inline(always)]
6453        fn inline_align(_context: fidl::encoding::Context) -> usize {
6454            8
6455        }
6456
6457        #[inline(always)]
6458        fn inline_size(_context: fidl::encoding::Context) -> usize {
6459            16
6460        }
6461    }
6462
6463    unsafe impl<D: fidl::encoding::ResourceDialect>
6464        fidl::encoding::Encode<ImageFormatConstraints, D> for &ImageFormatConstraints
6465    {
6466        unsafe fn encode(
6467            self,
6468            encoder: &mut fidl::encoding::Encoder<'_, D>,
6469            offset: usize,
6470            mut depth: fidl::encoding::Depth,
6471        ) -> fidl::Result<()> {
6472            encoder.debug_check_bounds::<ImageFormatConstraints>(offset);
6473            // Vector header
6474            let max_ordinal: u64 = self.max_ordinal_present();
6475            encoder.write_num(max_ordinal, offset);
6476            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6477            // Calling encoder.out_of_line_offset(0) is not allowed.
6478            if max_ordinal == 0 {
6479                return Ok(());
6480            }
6481            depth.increment()?;
6482            let envelope_size = 8;
6483            let bytes_len = max_ordinal as usize * envelope_size;
6484            #[allow(unused_variables)]
6485            let offset = encoder.out_of_line_offset(bytes_len);
6486            let mut _prev_end_offset: usize = 0;
6487            if 1 > max_ordinal {
6488                return Ok(());
6489            }
6490
6491            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6492            // are envelope_size bytes.
6493            let cur_offset: usize = (1 - 1) * envelope_size;
6494
6495            // Zero reserved fields.
6496            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6497
6498            // Safety:
6499            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6500            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6501            //   envelope_size bytes, there is always sufficient room.
6502            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_images2__common::PixelFormat, D>(
6503            self.pixel_format.as_ref().map(<fidl_fuchsia_images2__common::PixelFormat as fidl::encoding::ValueTypeMarker>::borrow),
6504            encoder, offset + cur_offset, depth
6505        )?;
6506
6507            _prev_end_offset = cur_offset + envelope_size;
6508            if 2 > max_ordinal {
6509                return Ok(());
6510            }
6511
6512            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6513            // are envelope_size bytes.
6514            let cur_offset: usize = (2 - 1) * envelope_size;
6515
6516            // Zero reserved fields.
6517            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6518
6519            // Safety:
6520            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6521            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6522            //   envelope_size bytes, there is always sufficient room.
6523            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_images2__common::PixelFormatModifier, D>(
6524            self.pixel_format_modifier.as_ref().map(<fidl_fuchsia_images2__common::PixelFormatModifier as fidl::encoding::ValueTypeMarker>::borrow),
6525            encoder, offset + cur_offset, depth
6526        )?;
6527
6528            _prev_end_offset = cur_offset + envelope_size;
6529            if 3 > max_ordinal {
6530                return Ok(());
6531            }
6532
6533            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6534            // are envelope_size bytes.
6535            let cur_offset: usize = (3 - 1) * envelope_size;
6536
6537            // Zero reserved fields.
6538            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6539
6540            // Safety:
6541            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6542            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6543            //   envelope_size bytes, there is always sufficient room.
6544            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_images2__common::ColorSpace, 32>, D>(
6545            self.color_spaces.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_images2__common::ColorSpace, 32> as fidl::encoding::ValueTypeMarker>::borrow),
6546            encoder, offset + cur_offset, depth
6547        )?;
6548
6549            _prev_end_offset = cur_offset + envelope_size;
6550            if 4 > max_ordinal {
6551                return Ok(());
6552            }
6553
6554            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6555            // are envelope_size bytes.
6556            let cur_offset: usize = (4 - 1) * envelope_size;
6557
6558            // Zero reserved fields.
6559            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6560
6561            // Safety:
6562            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6563            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6564            //   envelope_size bytes, there is always sufficient room.
6565            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
6566                self.min_size.as_ref().map(
6567                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
6568                ),
6569                encoder,
6570                offset + cur_offset,
6571                depth,
6572            )?;
6573
6574            _prev_end_offset = cur_offset + envelope_size;
6575            if 5 > max_ordinal {
6576                return Ok(());
6577            }
6578
6579            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6580            // are envelope_size bytes.
6581            let cur_offset: usize = (5 - 1) * envelope_size;
6582
6583            // Zero reserved fields.
6584            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6585
6586            // Safety:
6587            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6588            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6589            //   envelope_size bytes, there is always sufficient room.
6590            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
6591                self.max_size.as_ref().map(
6592                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
6593                ),
6594                encoder,
6595                offset + cur_offset,
6596                depth,
6597            )?;
6598
6599            _prev_end_offset = cur_offset + envelope_size;
6600            if 6 > max_ordinal {
6601                return Ok(());
6602            }
6603
6604            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6605            // are envelope_size bytes.
6606            let cur_offset: usize = (6 - 1) * envelope_size;
6607
6608            // Zero reserved fields.
6609            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6610
6611            // Safety:
6612            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6613            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6614            //   envelope_size bytes, there is always sufficient room.
6615            fidl::encoding::encode_in_envelope_optional::<u32, D>(
6616                self.min_bytes_per_row
6617                    .as_ref()
6618                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6619                encoder,
6620                offset + cur_offset,
6621                depth,
6622            )?;
6623
6624            _prev_end_offset = cur_offset + envelope_size;
6625            if 7 > max_ordinal {
6626                return Ok(());
6627            }
6628
6629            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6630            // are envelope_size bytes.
6631            let cur_offset: usize = (7 - 1) * envelope_size;
6632
6633            // Zero reserved fields.
6634            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6635
6636            // Safety:
6637            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6638            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6639            //   envelope_size bytes, there is always sufficient room.
6640            fidl::encoding::encode_in_envelope_optional::<u32, D>(
6641                self.max_bytes_per_row
6642                    .as_ref()
6643                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6644                encoder,
6645                offset + cur_offset,
6646                depth,
6647            )?;
6648
6649            _prev_end_offset = cur_offset + envelope_size;
6650            if 8 > max_ordinal {
6651                return Ok(());
6652            }
6653
6654            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6655            // are envelope_size bytes.
6656            let cur_offset: usize = (8 - 1) * envelope_size;
6657
6658            // Zero reserved fields.
6659            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6660
6661            // Safety:
6662            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6663            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6664            //   envelope_size bytes, there is always sufficient room.
6665            fidl::encoding::encode_in_envelope_optional::<u64, D>(
6666                self.max_width_times_height
6667                    .as_ref()
6668                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
6669                encoder,
6670                offset + cur_offset,
6671                depth,
6672            )?;
6673
6674            _prev_end_offset = cur_offset + envelope_size;
6675            if 9 > max_ordinal {
6676                return Ok(());
6677            }
6678
6679            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6680            // are envelope_size bytes.
6681            let cur_offset: usize = (9 - 1) * envelope_size;
6682
6683            // Zero reserved fields.
6684            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6685
6686            // Safety:
6687            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6688            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6689            //   envelope_size bytes, there is always sufficient room.
6690            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
6691                self.size_alignment.as_ref().map(
6692                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
6693                ),
6694                encoder,
6695                offset + cur_offset,
6696                depth,
6697            )?;
6698
6699            _prev_end_offset = cur_offset + envelope_size;
6700            if 10 > max_ordinal {
6701                return Ok(());
6702            }
6703
6704            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6705            // are envelope_size bytes.
6706            let cur_offset: usize = (10 - 1) * envelope_size;
6707
6708            // Zero reserved fields.
6709            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6710
6711            // Safety:
6712            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6713            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6714            //   envelope_size bytes, there is always sufficient room.
6715            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
6716                self.display_rect_alignment.as_ref().map(
6717                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
6718                ),
6719                encoder,
6720                offset + cur_offset,
6721                depth,
6722            )?;
6723
6724            _prev_end_offset = cur_offset + envelope_size;
6725            if 11 > max_ordinal {
6726                return Ok(());
6727            }
6728
6729            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6730            // are envelope_size bytes.
6731            let cur_offset: usize = (11 - 1) * envelope_size;
6732
6733            // Zero reserved fields.
6734            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6735
6736            // Safety:
6737            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6738            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6739            //   envelope_size bytes, there is always sufficient room.
6740            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
6741                self.required_min_size.as_ref().map(
6742                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
6743                ),
6744                encoder,
6745                offset + cur_offset,
6746                depth,
6747            )?;
6748
6749            _prev_end_offset = cur_offset + envelope_size;
6750            if 12 > max_ordinal {
6751                return Ok(());
6752            }
6753
6754            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6755            // are envelope_size bytes.
6756            let cur_offset: usize = (12 - 1) * envelope_size;
6757
6758            // Zero reserved fields.
6759            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6760
6761            // Safety:
6762            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6763            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6764            //   envelope_size bytes, there is always sufficient room.
6765            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math__common::SizeU, D>(
6766                self.required_max_size.as_ref().map(
6767                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::ValueTypeMarker>::borrow,
6768                ),
6769                encoder,
6770                offset + cur_offset,
6771                depth,
6772            )?;
6773
6774            _prev_end_offset = cur_offset + envelope_size;
6775            if 13 > max_ordinal {
6776                return Ok(());
6777            }
6778
6779            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6780            // are envelope_size bytes.
6781            let cur_offset: usize = (13 - 1) * envelope_size;
6782
6783            // Zero reserved fields.
6784            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6785
6786            // Safety:
6787            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6788            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6789            //   envelope_size bytes, there is always sufficient room.
6790            fidl::encoding::encode_in_envelope_optional::<u32, D>(
6791                self.bytes_per_row_divisor
6792                    .as_ref()
6793                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6794                encoder,
6795                offset + cur_offset,
6796                depth,
6797            )?;
6798
6799            _prev_end_offset = cur_offset + envelope_size;
6800            if 14 > max_ordinal {
6801                return Ok(());
6802            }
6803
6804            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6805            // are envelope_size bytes.
6806            let cur_offset: usize = (14 - 1) * envelope_size;
6807
6808            // Zero reserved fields.
6809            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6810
6811            // Safety:
6812            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6813            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6814            //   envelope_size bytes, there is always sufficient room.
6815            fidl::encoding::encode_in_envelope_optional::<u32, D>(
6816                self.start_offset_divisor
6817                    .as_ref()
6818                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6819                encoder,
6820                offset + cur_offset,
6821                depth,
6822            )?;
6823
6824            _prev_end_offset = cur_offset + envelope_size;
6825            if 15 > max_ordinal {
6826                return Ok(());
6827            }
6828
6829            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6830            // are envelope_size bytes.
6831            let cur_offset: usize = (15 - 1) * envelope_size;
6832
6833            // Zero reserved fields.
6834            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6835
6836            // Safety:
6837            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6838            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6839            //   envelope_size bytes, there is always sufficient room.
6840            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<PixelFormatAndModifier, 64>, D>(
6841            self.pixel_format_and_modifiers.as_ref().map(<fidl::encoding::Vector<PixelFormatAndModifier, 64> as fidl::encoding::ValueTypeMarker>::borrow),
6842            encoder, offset + cur_offset, depth
6843        )?;
6844
6845            _prev_end_offset = cur_offset + envelope_size;
6846            if 16 > max_ordinal {
6847                return Ok(());
6848            }
6849
6850            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6851            // are envelope_size bytes.
6852            let cur_offset: usize = (16 - 1) * envelope_size;
6853
6854            // Zero reserved fields.
6855            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6856
6857            // Safety:
6858            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6859            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6860            //   envelope_size bytes, there is always sufficient room.
6861            fidl::encoding::encode_in_envelope_optional::<bool, D>(
6862                self.require_bytes_per_row_at_pixel_boundary
6863                    .as_ref()
6864                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6865                encoder,
6866                offset + cur_offset,
6867                depth,
6868            )?;
6869
6870            _prev_end_offset = cur_offset + envelope_size;
6871            if 17 > max_ordinal {
6872                return Ok(());
6873            }
6874
6875            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6876            // are envelope_size bytes.
6877            let cur_offset: usize = (17 - 1) * envelope_size;
6878
6879            // Zero reserved fields.
6880            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6881
6882            // Safety:
6883            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6884            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6885            //   envelope_size bytes, there is always sufficient room.
6886            fidl::encoding::encode_in_envelope_optional::<bool, D>(
6887                self.is_alpha_present
6888                    .as_ref()
6889                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6890                encoder,
6891                offset + cur_offset,
6892                depth,
6893            )?;
6894
6895            _prev_end_offset = cur_offset + envelope_size;
6896
6897            Ok(())
6898        }
6899    }
6900
6901    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6902        for ImageFormatConstraints
6903    {
6904        #[inline(always)]
6905        fn new_empty() -> Self {
6906            Self::default()
6907        }
6908
6909        unsafe fn decode(
6910            &mut self,
6911            decoder: &mut fidl::encoding::Decoder<'_, D>,
6912            offset: usize,
6913            mut depth: fidl::encoding::Depth,
6914        ) -> fidl::Result<()> {
6915            decoder.debug_check_bounds::<Self>(offset);
6916            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6917                None => return Err(fidl::Error::NotNullable),
6918                Some(len) => len,
6919            };
6920            // Calling decoder.out_of_line_offset(0) is not allowed.
6921            if len == 0 {
6922                return Ok(());
6923            };
6924            depth.increment()?;
6925            let envelope_size = 8;
6926            let bytes_len = len * envelope_size;
6927            let offset = decoder.out_of_line_offset(bytes_len)?;
6928            // Decode the envelope for each type.
6929            let mut _next_ordinal_to_read = 0;
6930            let mut next_offset = offset;
6931            let end_offset = offset + bytes_len;
6932            _next_ordinal_to_read += 1;
6933            if next_offset >= end_offset {
6934                return Ok(());
6935            }
6936
6937            // Decode unknown envelopes for gaps in ordinals.
6938            while _next_ordinal_to_read < 1 {
6939                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6940                _next_ordinal_to_read += 1;
6941                next_offset += envelope_size;
6942            }
6943
6944            let next_out_of_line = decoder.next_out_of_line();
6945            let handles_before = decoder.remaining_handles();
6946            if let Some((inlined, num_bytes, num_handles)) =
6947                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6948            {
6949                let member_inline_size = <fidl_fuchsia_images2__common::PixelFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6950                if inlined != (member_inline_size <= 4) {
6951                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6952                }
6953                let inner_offset;
6954                let mut inner_depth = depth.clone();
6955                if inlined {
6956                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6957                    inner_offset = next_offset;
6958                } else {
6959                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6960                    inner_depth.increment()?;
6961                }
6962                let val_ref = self.pixel_format.get_or_insert_with(|| {
6963                    fidl::new_empty!(fidl_fuchsia_images2__common::PixelFormat, D)
6964                });
6965                fidl::decode!(
6966                    fidl_fuchsia_images2__common::PixelFormat,
6967                    D,
6968                    val_ref,
6969                    decoder,
6970                    inner_offset,
6971                    inner_depth
6972                )?;
6973                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6974                {
6975                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6976                }
6977                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6978                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6979                }
6980            }
6981
6982            next_offset += envelope_size;
6983            _next_ordinal_to_read += 1;
6984            if next_offset >= end_offset {
6985                return Ok(());
6986            }
6987
6988            // Decode unknown envelopes for gaps in ordinals.
6989            while _next_ordinal_to_read < 2 {
6990                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6991                _next_ordinal_to_read += 1;
6992                next_offset += envelope_size;
6993            }
6994
6995            let next_out_of_line = decoder.next_out_of_line();
6996            let handles_before = decoder.remaining_handles();
6997            if let Some((inlined, num_bytes, num_handles)) =
6998                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6999            {
7000                let member_inline_size = <fidl_fuchsia_images2__common::PixelFormatModifier as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7001                if inlined != (member_inline_size <= 4) {
7002                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7003                }
7004                let inner_offset;
7005                let mut inner_depth = depth.clone();
7006                if inlined {
7007                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7008                    inner_offset = next_offset;
7009                } else {
7010                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7011                    inner_depth.increment()?;
7012                }
7013                let val_ref = self.pixel_format_modifier.get_or_insert_with(|| {
7014                    fidl::new_empty!(fidl_fuchsia_images2__common::PixelFormatModifier, D)
7015                });
7016                fidl::decode!(
7017                    fidl_fuchsia_images2__common::PixelFormatModifier,
7018                    D,
7019                    val_ref,
7020                    decoder,
7021                    inner_offset,
7022                    inner_depth
7023                )?;
7024                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7025                {
7026                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7027                }
7028                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7029                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7030                }
7031            }
7032
7033            next_offset += envelope_size;
7034            _next_ordinal_to_read += 1;
7035            if next_offset >= end_offset {
7036                return Ok(());
7037            }
7038
7039            // Decode unknown envelopes for gaps in ordinals.
7040            while _next_ordinal_to_read < 3 {
7041                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7042                _next_ordinal_to_read += 1;
7043                next_offset += envelope_size;
7044            }
7045
7046            let next_out_of_line = decoder.next_out_of_line();
7047            let handles_before = decoder.remaining_handles();
7048            if let Some((inlined, num_bytes, num_handles)) =
7049                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7050            {
7051                let member_inline_size = <fidl::encoding::Vector<
7052                    fidl_fuchsia_images2__common::ColorSpace,
7053                    32,
7054                > as fidl::encoding::TypeMarker>::inline_size(
7055                    decoder.context
7056                );
7057                if inlined != (member_inline_size <= 4) {
7058                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7059                }
7060                let inner_offset;
7061                let mut inner_depth = depth.clone();
7062                if inlined {
7063                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7064                    inner_offset = next_offset;
7065                } else {
7066                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7067                    inner_depth.increment()?;
7068                }
7069                let val_ref =
7070                self.color_spaces.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_images2__common::ColorSpace, 32>, D));
7071                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_images2__common::ColorSpace, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
7072                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7073                {
7074                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7075                }
7076                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7077                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7078                }
7079            }
7080
7081            next_offset += envelope_size;
7082            _next_ordinal_to_read += 1;
7083            if next_offset >= end_offset {
7084                return Ok(());
7085            }
7086
7087            // Decode unknown envelopes for gaps in ordinals.
7088            while _next_ordinal_to_read < 4 {
7089                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7090                _next_ordinal_to_read += 1;
7091                next_offset += envelope_size;
7092            }
7093
7094            let next_out_of_line = decoder.next_out_of_line();
7095            let handles_before = decoder.remaining_handles();
7096            if let Some((inlined, num_bytes, num_handles)) =
7097                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7098            {
7099                let member_inline_size =
7100                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
7101                        decoder.context,
7102                    );
7103                if inlined != (member_inline_size <= 4) {
7104                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7105                }
7106                let inner_offset;
7107                let mut inner_depth = depth.clone();
7108                if inlined {
7109                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7110                    inner_offset = next_offset;
7111                } else {
7112                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7113                    inner_depth.increment()?;
7114                }
7115                let val_ref = self
7116                    .min_size
7117                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
7118                fidl::decode!(
7119                    fidl_fuchsia_math__common::SizeU,
7120                    D,
7121                    val_ref,
7122                    decoder,
7123                    inner_offset,
7124                    inner_depth
7125                )?;
7126                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7127                {
7128                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7129                }
7130                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7131                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7132                }
7133            }
7134
7135            next_offset += envelope_size;
7136            _next_ordinal_to_read += 1;
7137            if next_offset >= end_offset {
7138                return Ok(());
7139            }
7140
7141            // Decode unknown envelopes for gaps in ordinals.
7142            while _next_ordinal_to_read < 5 {
7143                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7144                _next_ordinal_to_read += 1;
7145                next_offset += envelope_size;
7146            }
7147
7148            let next_out_of_line = decoder.next_out_of_line();
7149            let handles_before = decoder.remaining_handles();
7150            if let Some((inlined, num_bytes, num_handles)) =
7151                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7152            {
7153                let member_inline_size =
7154                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
7155                        decoder.context,
7156                    );
7157                if inlined != (member_inline_size <= 4) {
7158                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7159                }
7160                let inner_offset;
7161                let mut inner_depth = depth.clone();
7162                if inlined {
7163                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7164                    inner_offset = next_offset;
7165                } else {
7166                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7167                    inner_depth.increment()?;
7168                }
7169                let val_ref = self
7170                    .max_size
7171                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
7172                fidl::decode!(
7173                    fidl_fuchsia_math__common::SizeU,
7174                    D,
7175                    val_ref,
7176                    decoder,
7177                    inner_offset,
7178                    inner_depth
7179                )?;
7180                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7181                {
7182                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7183                }
7184                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7185                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7186                }
7187            }
7188
7189            next_offset += envelope_size;
7190            _next_ordinal_to_read += 1;
7191            if next_offset >= end_offset {
7192                return Ok(());
7193            }
7194
7195            // Decode unknown envelopes for gaps in ordinals.
7196            while _next_ordinal_to_read < 6 {
7197                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7198                _next_ordinal_to_read += 1;
7199                next_offset += envelope_size;
7200            }
7201
7202            let next_out_of_line = decoder.next_out_of_line();
7203            let handles_before = decoder.remaining_handles();
7204            if let Some((inlined, num_bytes, num_handles)) =
7205                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7206            {
7207                let member_inline_size =
7208                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7209                if inlined != (member_inline_size <= 4) {
7210                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7211                }
7212                let inner_offset;
7213                let mut inner_depth = depth.clone();
7214                if inlined {
7215                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7216                    inner_offset = next_offset;
7217                } else {
7218                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7219                    inner_depth.increment()?;
7220                }
7221                let val_ref =
7222                    self.min_bytes_per_row.get_or_insert_with(|| fidl::new_empty!(u32, D));
7223                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7224                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7225                {
7226                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7227                }
7228                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7229                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7230                }
7231            }
7232
7233            next_offset += envelope_size;
7234            _next_ordinal_to_read += 1;
7235            if next_offset >= end_offset {
7236                return Ok(());
7237            }
7238
7239            // Decode unknown envelopes for gaps in ordinals.
7240            while _next_ordinal_to_read < 7 {
7241                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7242                _next_ordinal_to_read += 1;
7243                next_offset += envelope_size;
7244            }
7245
7246            let next_out_of_line = decoder.next_out_of_line();
7247            let handles_before = decoder.remaining_handles();
7248            if let Some((inlined, num_bytes, num_handles)) =
7249                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7250            {
7251                let member_inline_size =
7252                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7253                if inlined != (member_inline_size <= 4) {
7254                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7255                }
7256                let inner_offset;
7257                let mut inner_depth = depth.clone();
7258                if inlined {
7259                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7260                    inner_offset = next_offset;
7261                } else {
7262                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7263                    inner_depth.increment()?;
7264                }
7265                let val_ref =
7266                    self.max_bytes_per_row.get_or_insert_with(|| fidl::new_empty!(u32, D));
7267                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7268                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7269                {
7270                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7271                }
7272                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7273                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7274                }
7275            }
7276
7277            next_offset += envelope_size;
7278            _next_ordinal_to_read += 1;
7279            if next_offset >= end_offset {
7280                return Ok(());
7281            }
7282
7283            // Decode unknown envelopes for gaps in ordinals.
7284            while _next_ordinal_to_read < 8 {
7285                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7286                _next_ordinal_to_read += 1;
7287                next_offset += envelope_size;
7288            }
7289
7290            let next_out_of_line = decoder.next_out_of_line();
7291            let handles_before = decoder.remaining_handles();
7292            if let Some((inlined, num_bytes, num_handles)) =
7293                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7294            {
7295                let member_inline_size =
7296                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7297                if inlined != (member_inline_size <= 4) {
7298                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7299                }
7300                let inner_offset;
7301                let mut inner_depth = depth.clone();
7302                if inlined {
7303                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7304                    inner_offset = next_offset;
7305                } else {
7306                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7307                    inner_depth.increment()?;
7308                }
7309                let val_ref =
7310                    self.max_width_times_height.get_or_insert_with(|| fidl::new_empty!(u64, D));
7311                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
7312                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7313                {
7314                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7315                }
7316                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7317                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7318                }
7319            }
7320
7321            next_offset += envelope_size;
7322            _next_ordinal_to_read += 1;
7323            if next_offset >= end_offset {
7324                return Ok(());
7325            }
7326
7327            // Decode unknown envelopes for gaps in ordinals.
7328            while _next_ordinal_to_read < 9 {
7329                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7330                _next_ordinal_to_read += 1;
7331                next_offset += envelope_size;
7332            }
7333
7334            let next_out_of_line = decoder.next_out_of_line();
7335            let handles_before = decoder.remaining_handles();
7336            if let Some((inlined, num_bytes, num_handles)) =
7337                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7338            {
7339                let member_inline_size =
7340                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
7341                        decoder.context,
7342                    );
7343                if inlined != (member_inline_size <= 4) {
7344                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7345                }
7346                let inner_offset;
7347                let mut inner_depth = depth.clone();
7348                if inlined {
7349                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7350                    inner_offset = next_offset;
7351                } else {
7352                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7353                    inner_depth.increment()?;
7354                }
7355                let val_ref = self
7356                    .size_alignment
7357                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
7358                fidl::decode!(
7359                    fidl_fuchsia_math__common::SizeU,
7360                    D,
7361                    val_ref,
7362                    decoder,
7363                    inner_offset,
7364                    inner_depth
7365                )?;
7366                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7367                {
7368                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7369                }
7370                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7371                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7372                }
7373            }
7374
7375            next_offset += envelope_size;
7376            _next_ordinal_to_read += 1;
7377            if next_offset >= end_offset {
7378                return Ok(());
7379            }
7380
7381            // Decode unknown envelopes for gaps in ordinals.
7382            while _next_ordinal_to_read < 10 {
7383                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7384                _next_ordinal_to_read += 1;
7385                next_offset += envelope_size;
7386            }
7387
7388            let next_out_of_line = decoder.next_out_of_line();
7389            let handles_before = decoder.remaining_handles();
7390            if let Some((inlined, num_bytes, num_handles)) =
7391                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7392            {
7393                let member_inline_size =
7394                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
7395                        decoder.context,
7396                    );
7397                if inlined != (member_inline_size <= 4) {
7398                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7399                }
7400                let inner_offset;
7401                let mut inner_depth = depth.clone();
7402                if inlined {
7403                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7404                    inner_offset = next_offset;
7405                } else {
7406                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7407                    inner_depth.increment()?;
7408                }
7409                let val_ref = self
7410                    .display_rect_alignment
7411                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
7412                fidl::decode!(
7413                    fidl_fuchsia_math__common::SizeU,
7414                    D,
7415                    val_ref,
7416                    decoder,
7417                    inner_offset,
7418                    inner_depth
7419                )?;
7420                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7421                {
7422                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7423                }
7424                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7425                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7426                }
7427            }
7428
7429            next_offset += envelope_size;
7430            _next_ordinal_to_read += 1;
7431            if next_offset >= end_offset {
7432                return Ok(());
7433            }
7434
7435            // Decode unknown envelopes for gaps in ordinals.
7436            while _next_ordinal_to_read < 11 {
7437                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7438                _next_ordinal_to_read += 1;
7439                next_offset += envelope_size;
7440            }
7441
7442            let next_out_of_line = decoder.next_out_of_line();
7443            let handles_before = decoder.remaining_handles();
7444            if let Some((inlined, num_bytes, num_handles)) =
7445                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7446            {
7447                let member_inline_size =
7448                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
7449                        decoder.context,
7450                    );
7451                if inlined != (member_inline_size <= 4) {
7452                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7453                }
7454                let inner_offset;
7455                let mut inner_depth = depth.clone();
7456                if inlined {
7457                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7458                    inner_offset = next_offset;
7459                } else {
7460                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7461                    inner_depth.increment()?;
7462                }
7463                let val_ref = self
7464                    .required_min_size
7465                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
7466                fidl::decode!(
7467                    fidl_fuchsia_math__common::SizeU,
7468                    D,
7469                    val_ref,
7470                    decoder,
7471                    inner_offset,
7472                    inner_depth
7473                )?;
7474                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7475                {
7476                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7477                }
7478                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7479                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7480                }
7481            }
7482
7483            next_offset += envelope_size;
7484            _next_ordinal_to_read += 1;
7485            if next_offset >= end_offset {
7486                return Ok(());
7487            }
7488
7489            // Decode unknown envelopes for gaps in ordinals.
7490            while _next_ordinal_to_read < 12 {
7491                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7492                _next_ordinal_to_read += 1;
7493                next_offset += envelope_size;
7494            }
7495
7496            let next_out_of_line = decoder.next_out_of_line();
7497            let handles_before = decoder.remaining_handles();
7498            if let Some((inlined, num_bytes, num_handles)) =
7499                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7500            {
7501                let member_inline_size =
7502                    <fidl_fuchsia_math__common::SizeU as fidl::encoding::TypeMarker>::inline_size(
7503                        decoder.context,
7504                    );
7505                if inlined != (member_inline_size <= 4) {
7506                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7507                }
7508                let inner_offset;
7509                let mut inner_depth = depth.clone();
7510                if inlined {
7511                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7512                    inner_offset = next_offset;
7513                } else {
7514                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7515                    inner_depth.increment()?;
7516                }
7517                let val_ref = self
7518                    .required_max_size
7519                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math__common::SizeU, D));
7520                fidl::decode!(
7521                    fidl_fuchsia_math__common::SizeU,
7522                    D,
7523                    val_ref,
7524                    decoder,
7525                    inner_offset,
7526                    inner_depth
7527                )?;
7528                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7529                {
7530                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7531                }
7532                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7533                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7534                }
7535            }
7536
7537            next_offset += envelope_size;
7538            _next_ordinal_to_read += 1;
7539            if next_offset >= end_offset {
7540                return Ok(());
7541            }
7542
7543            // Decode unknown envelopes for gaps in ordinals.
7544            while _next_ordinal_to_read < 13 {
7545                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7546                _next_ordinal_to_read += 1;
7547                next_offset += envelope_size;
7548            }
7549
7550            let next_out_of_line = decoder.next_out_of_line();
7551            let handles_before = decoder.remaining_handles();
7552            if let Some((inlined, num_bytes, num_handles)) =
7553                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7554            {
7555                let member_inline_size =
7556                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7557                if inlined != (member_inline_size <= 4) {
7558                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7559                }
7560                let inner_offset;
7561                let mut inner_depth = depth.clone();
7562                if inlined {
7563                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7564                    inner_offset = next_offset;
7565                } else {
7566                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7567                    inner_depth.increment()?;
7568                }
7569                let val_ref =
7570                    self.bytes_per_row_divisor.get_or_insert_with(|| fidl::new_empty!(u32, D));
7571                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7572                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7573                {
7574                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7575                }
7576                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7577                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7578                }
7579            }
7580
7581            next_offset += envelope_size;
7582            _next_ordinal_to_read += 1;
7583            if next_offset >= end_offset {
7584                return Ok(());
7585            }
7586
7587            // Decode unknown envelopes for gaps in ordinals.
7588            while _next_ordinal_to_read < 14 {
7589                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7590                _next_ordinal_to_read += 1;
7591                next_offset += envelope_size;
7592            }
7593
7594            let next_out_of_line = decoder.next_out_of_line();
7595            let handles_before = decoder.remaining_handles();
7596            if let Some((inlined, num_bytes, num_handles)) =
7597                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7598            {
7599                let member_inline_size =
7600                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7601                if inlined != (member_inline_size <= 4) {
7602                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7603                }
7604                let inner_offset;
7605                let mut inner_depth = depth.clone();
7606                if inlined {
7607                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7608                    inner_offset = next_offset;
7609                } else {
7610                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7611                    inner_depth.increment()?;
7612                }
7613                let val_ref =
7614                    self.start_offset_divisor.get_or_insert_with(|| fidl::new_empty!(u32, D));
7615                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7616                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7617                {
7618                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7619                }
7620                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7621                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7622                }
7623            }
7624
7625            next_offset += envelope_size;
7626            _next_ordinal_to_read += 1;
7627            if next_offset >= end_offset {
7628                return Ok(());
7629            }
7630
7631            // Decode unknown envelopes for gaps in ordinals.
7632            while _next_ordinal_to_read < 15 {
7633                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7634                _next_ordinal_to_read += 1;
7635                next_offset += envelope_size;
7636            }
7637
7638            let next_out_of_line = decoder.next_out_of_line();
7639            let handles_before = decoder.remaining_handles();
7640            if let Some((inlined, num_bytes, num_handles)) =
7641                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7642            {
7643                let member_inline_size = <fidl::encoding::Vector<PixelFormatAndModifier, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7644                if inlined != (member_inline_size <= 4) {
7645                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7646                }
7647                let inner_offset;
7648                let mut inner_depth = depth.clone();
7649                if inlined {
7650                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7651                    inner_offset = next_offset;
7652                } else {
7653                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7654                    inner_depth.increment()?;
7655                }
7656                let val_ref = self.pixel_format_and_modifiers.get_or_insert_with(
7657                    || fidl::new_empty!(fidl::encoding::Vector<PixelFormatAndModifier, 64>, D),
7658                );
7659                fidl::decode!(fidl::encoding::Vector<PixelFormatAndModifier, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
7660                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7661                {
7662                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7663                }
7664                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7665                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7666                }
7667            }
7668
7669            next_offset += envelope_size;
7670            _next_ordinal_to_read += 1;
7671            if next_offset >= end_offset {
7672                return Ok(());
7673            }
7674
7675            // Decode unknown envelopes for gaps in ordinals.
7676            while _next_ordinal_to_read < 16 {
7677                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7678                _next_ordinal_to_read += 1;
7679                next_offset += envelope_size;
7680            }
7681
7682            let next_out_of_line = decoder.next_out_of_line();
7683            let handles_before = decoder.remaining_handles();
7684            if let Some((inlined, num_bytes, num_handles)) =
7685                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7686            {
7687                let member_inline_size =
7688                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7689                if inlined != (member_inline_size <= 4) {
7690                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7691                }
7692                let inner_offset;
7693                let mut inner_depth = depth.clone();
7694                if inlined {
7695                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7696                    inner_offset = next_offset;
7697                } else {
7698                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7699                    inner_depth.increment()?;
7700                }
7701                let val_ref = self
7702                    .require_bytes_per_row_at_pixel_boundary
7703                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
7704                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7705                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7706                {
7707                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7708                }
7709                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7710                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7711                }
7712            }
7713
7714            next_offset += envelope_size;
7715            _next_ordinal_to_read += 1;
7716            if next_offset >= end_offset {
7717                return Ok(());
7718            }
7719
7720            // Decode unknown envelopes for gaps in ordinals.
7721            while _next_ordinal_to_read < 17 {
7722                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7723                _next_ordinal_to_read += 1;
7724                next_offset += envelope_size;
7725            }
7726
7727            let next_out_of_line = decoder.next_out_of_line();
7728            let handles_before = decoder.remaining_handles();
7729            if let Some((inlined, num_bytes, num_handles)) =
7730                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7731            {
7732                let member_inline_size =
7733                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7734                if inlined != (member_inline_size <= 4) {
7735                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7736                }
7737                let inner_offset;
7738                let mut inner_depth = depth.clone();
7739                if inlined {
7740                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7741                    inner_offset = next_offset;
7742                } else {
7743                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7744                    inner_depth.increment()?;
7745                }
7746                let val_ref =
7747                    self.is_alpha_present.get_or_insert_with(|| fidl::new_empty!(bool, D));
7748                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7749                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7750                {
7751                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7752                }
7753                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7754                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7755                }
7756            }
7757
7758            next_offset += envelope_size;
7759
7760            // Decode the remaining unknown envelopes.
7761            while next_offset < end_offset {
7762                _next_ordinal_to_read += 1;
7763                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7764                next_offset += envelope_size;
7765            }
7766
7767            Ok(())
7768        }
7769    }
7770
7771    impl NodeSetDebugClientInfoRequest {
7772        #[inline(always)]
7773        fn max_ordinal_present(&self) -> u64 {
7774            if let Some(_) = self.id {
7775                return 2;
7776            }
7777            if let Some(_) = self.name {
7778                return 1;
7779            }
7780            0
7781        }
7782    }
7783
7784    impl fidl::encoding::ValueTypeMarker for NodeSetDebugClientInfoRequest {
7785        type Borrowed<'a> = &'a Self;
7786        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7787            value
7788        }
7789    }
7790
7791    unsafe impl fidl::encoding::TypeMarker for NodeSetDebugClientInfoRequest {
7792        type Owned = Self;
7793
7794        #[inline(always)]
7795        fn inline_align(_context: fidl::encoding::Context) -> usize {
7796            8
7797        }
7798
7799        #[inline(always)]
7800        fn inline_size(_context: fidl::encoding::Context) -> usize {
7801            16
7802        }
7803    }
7804
7805    unsafe impl<D: fidl::encoding::ResourceDialect>
7806        fidl::encoding::Encode<NodeSetDebugClientInfoRequest, D>
7807        for &NodeSetDebugClientInfoRequest
7808    {
7809        unsafe fn encode(
7810            self,
7811            encoder: &mut fidl::encoding::Encoder<'_, D>,
7812            offset: usize,
7813            mut depth: fidl::encoding::Depth,
7814        ) -> fidl::Result<()> {
7815            encoder.debug_check_bounds::<NodeSetDebugClientInfoRequest>(offset);
7816            // Vector header
7817            let max_ordinal: u64 = self.max_ordinal_present();
7818            encoder.write_num(max_ordinal, offset);
7819            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7820            // Calling encoder.out_of_line_offset(0) is not allowed.
7821            if max_ordinal == 0 {
7822                return Ok(());
7823            }
7824            depth.increment()?;
7825            let envelope_size = 8;
7826            let bytes_len = max_ordinal as usize * envelope_size;
7827            #[allow(unused_variables)]
7828            let offset = encoder.out_of_line_offset(bytes_len);
7829            let mut _prev_end_offset: usize = 0;
7830            if 1 > max_ordinal {
7831                return Ok(());
7832            }
7833
7834            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7835            // are envelope_size bytes.
7836            let cur_offset: usize = (1 - 1) * envelope_size;
7837
7838            // Zero reserved fields.
7839            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7840
7841            // Safety:
7842            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7843            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7844            //   envelope_size bytes, there is always sufficient room.
7845            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
7846                self.name.as_ref().map(
7847                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
7848                ),
7849                encoder,
7850                offset + cur_offset,
7851                depth,
7852            )?;
7853
7854            _prev_end_offset = cur_offset + envelope_size;
7855            if 2 > max_ordinal {
7856                return Ok(());
7857            }
7858
7859            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7860            // are envelope_size bytes.
7861            let cur_offset: usize = (2 - 1) * envelope_size;
7862
7863            // Zero reserved fields.
7864            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7865
7866            // Safety:
7867            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7868            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7869            //   envelope_size bytes, there is always sufficient room.
7870            fidl::encoding::encode_in_envelope_optional::<u64, D>(
7871                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7872                encoder,
7873                offset + cur_offset,
7874                depth,
7875            )?;
7876
7877            _prev_end_offset = cur_offset + envelope_size;
7878
7879            Ok(())
7880        }
7881    }
7882
7883    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7884        for NodeSetDebugClientInfoRequest
7885    {
7886        #[inline(always)]
7887        fn new_empty() -> Self {
7888            Self::default()
7889        }
7890
7891        unsafe fn decode(
7892            &mut self,
7893            decoder: &mut fidl::encoding::Decoder<'_, D>,
7894            offset: usize,
7895            mut depth: fidl::encoding::Depth,
7896        ) -> fidl::Result<()> {
7897            decoder.debug_check_bounds::<Self>(offset);
7898            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7899                None => return Err(fidl::Error::NotNullable),
7900                Some(len) => len,
7901            };
7902            // Calling decoder.out_of_line_offset(0) is not allowed.
7903            if len == 0 {
7904                return Ok(());
7905            };
7906            depth.increment()?;
7907            let envelope_size = 8;
7908            let bytes_len = len * envelope_size;
7909            let offset = decoder.out_of_line_offset(bytes_len)?;
7910            // Decode the envelope for each type.
7911            let mut _next_ordinal_to_read = 0;
7912            let mut next_offset = offset;
7913            let end_offset = offset + bytes_len;
7914            _next_ordinal_to_read += 1;
7915            if next_offset >= end_offset {
7916                return Ok(());
7917            }
7918
7919            // Decode unknown envelopes for gaps in ordinals.
7920            while _next_ordinal_to_read < 1 {
7921                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7922                _next_ordinal_to_read += 1;
7923                next_offset += envelope_size;
7924            }
7925
7926            let next_out_of_line = decoder.next_out_of_line();
7927            let handles_before = decoder.remaining_handles();
7928            if let Some((inlined, num_bytes, num_handles)) =
7929                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7930            {
7931                let member_inline_size =
7932                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
7933                        decoder.context,
7934                    );
7935                if inlined != (member_inline_size <= 4) {
7936                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7937                }
7938                let inner_offset;
7939                let mut inner_depth = depth.clone();
7940                if inlined {
7941                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7942                    inner_offset = next_offset;
7943                } else {
7944                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7945                    inner_depth.increment()?;
7946                }
7947                let val_ref = self
7948                    .name
7949                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
7950                fidl::decode!(
7951                    fidl::encoding::BoundedString<256>,
7952                    D,
7953                    val_ref,
7954                    decoder,
7955                    inner_offset,
7956                    inner_depth
7957                )?;
7958                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7959                {
7960                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7961                }
7962                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7963                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7964                }
7965            }
7966
7967            next_offset += envelope_size;
7968            _next_ordinal_to_read += 1;
7969            if next_offset >= end_offset {
7970                return Ok(());
7971            }
7972
7973            // Decode unknown envelopes for gaps in ordinals.
7974            while _next_ordinal_to_read < 2 {
7975                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7976                _next_ordinal_to_read += 1;
7977                next_offset += envelope_size;
7978            }
7979
7980            let next_out_of_line = decoder.next_out_of_line();
7981            let handles_before = decoder.remaining_handles();
7982            if let Some((inlined, num_bytes, num_handles)) =
7983                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7984            {
7985                let member_inline_size =
7986                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7987                if inlined != (member_inline_size <= 4) {
7988                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7989                }
7990                let inner_offset;
7991                let mut inner_depth = depth.clone();
7992                if inlined {
7993                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7994                    inner_offset = next_offset;
7995                } else {
7996                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7997                    inner_depth.increment()?;
7998                }
7999                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
8000                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
8001                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8002                {
8003                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8004                }
8005                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8006                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8007                }
8008            }
8009
8010            next_offset += envelope_size;
8011
8012            // Decode the remaining unknown envelopes.
8013            while next_offset < end_offset {
8014                _next_ordinal_to_read += 1;
8015                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8016                next_offset += envelope_size;
8017            }
8018
8019            Ok(())
8020        }
8021    }
8022
8023    impl NodeSetDebugTimeoutLogDeadlineRequest {
8024        #[inline(always)]
8025        fn max_ordinal_present(&self) -> u64 {
8026            if let Some(_) = self.deadline {
8027                return 1;
8028            }
8029            0
8030        }
8031    }
8032
8033    impl fidl::encoding::ValueTypeMarker for NodeSetDebugTimeoutLogDeadlineRequest {
8034        type Borrowed<'a> = &'a Self;
8035        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8036            value
8037        }
8038    }
8039
8040    unsafe impl fidl::encoding::TypeMarker for NodeSetDebugTimeoutLogDeadlineRequest {
8041        type Owned = Self;
8042
8043        #[inline(always)]
8044        fn inline_align(_context: fidl::encoding::Context) -> usize {
8045            8
8046        }
8047
8048        #[inline(always)]
8049        fn inline_size(_context: fidl::encoding::Context) -> usize {
8050            16
8051        }
8052    }
8053
8054    unsafe impl<D: fidl::encoding::ResourceDialect>
8055        fidl::encoding::Encode<NodeSetDebugTimeoutLogDeadlineRequest, D>
8056        for &NodeSetDebugTimeoutLogDeadlineRequest
8057    {
8058        unsafe fn encode(
8059            self,
8060            encoder: &mut fidl::encoding::Encoder<'_, D>,
8061            offset: usize,
8062            mut depth: fidl::encoding::Depth,
8063        ) -> fidl::Result<()> {
8064            encoder.debug_check_bounds::<NodeSetDebugTimeoutLogDeadlineRequest>(offset);
8065            // Vector header
8066            let max_ordinal: u64 = self.max_ordinal_present();
8067            encoder.write_num(max_ordinal, offset);
8068            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8069            // Calling encoder.out_of_line_offset(0) is not allowed.
8070            if max_ordinal == 0 {
8071                return Ok(());
8072            }
8073            depth.increment()?;
8074            let envelope_size = 8;
8075            let bytes_len = max_ordinal as usize * envelope_size;
8076            #[allow(unused_variables)]
8077            let offset = encoder.out_of_line_offset(bytes_len);
8078            let mut _prev_end_offset: usize = 0;
8079            if 1 > max_ordinal {
8080                return Ok(());
8081            }
8082
8083            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8084            // are envelope_size bytes.
8085            let cur_offset: usize = (1 - 1) * envelope_size;
8086
8087            // Zero reserved fields.
8088            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8089
8090            // Safety:
8091            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8092            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8093            //   envelope_size bytes, there is always sufficient room.
8094            fidl::encoding::encode_in_envelope_optional::<i64, D>(
8095                self.deadline.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8096                encoder,
8097                offset + cur_offset,
8098                depth,
8099            )?;
8100
8101            _prev_end_offset = cur_offset + envelope_size;
8102
8103            Ok(())
8104        }
8105    }
8106
8107    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8108        for NodeSetDebugTimeoutLogDeadlineRequest
8109    {
8110        #[inline(always)]
8111        fn new_empty() -> Self {
8112            Self::default()
8113        }
8114
8115        unsafe fn decode(
8116            &mut self,
8117            decoder: &mut fidl::encoding::Decoder<'_, D>,
8118            offset: usize,
8119            mut depth: fidl::encoding::Depth,
8120        ) -> fidl::Result<()> {
8121            decoder.debug_check_bounds::<Self>(offset);
8122            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8123                None => return Err(fidl::Error::NotNullable),
8124                Some(len) => len,
8125            };
8126            // Calling decoder.out_of_line_offset(0) is not allowed.
8127            if len == 0 {
8128                return Ok(());
8129            };
8130            depth.increment()?;
8131            let envelope_size = 8;
8132            let bytes_len = len * envelope_size;
8133            let offset = decoder.out_of_line_offset(bytes_len)?;
8134            // Decode the envelope for each type.
8135            let mut _next_ordinal_to_read = 0;
8136            let mut next_offset = offset;
8137            let end_offset = offset + bytes_len;
8138            _next_ordinal_to_read += 1;
8139            if next_offset >= end_offset {
8140                return Ok(());
8141            }
8142
8143            // Decode unknown envelopes for gaps in ordinals.
8144            while _next_ordinal_to_read < 1 {
8145                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8146                _next_ordinal_to_read += 1;
8147                next_offset += envelope_size;
8148            }
8149
8150            let next_out_of_line = decoder.next_out_of_line();
8151            let handles_before = decoder.remaining_handles();
8152            if let Some((inlined, num_bytes, num_handles)) =
8153                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8154            {
8155                let member_inline_size =
8156                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8157                if inlined != (member_inline_size <= 4) {
8158                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8159                }
8160                let inner_offset;
8161                let mut inner_depth = depth.clone();
8162                if inlined {
8163                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8164                    inner_offset = next_offset;
8165                } else {
8166                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8167                    inner_depth.increment()?;
8168                }
8169                let val_ref = self.deadline.get_or_insert_with(|| fidl::new_empty!(i64, D));
8170                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8171                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8172                {
8173                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8174                }
8175                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8176                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8177                }
8178            }
8179
8180            next_offset += envelope_size;
8181
8182            // Decode the remaining unknown envelopes.
8183            while next_offset < end_offset {
8184                _next_ordinal_to_read += 1;
8185                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8186                next_offset += envelope_size;
8187            }
8188
8189            Ok(())
8190        }
8191    }
8192
8193    impl NodeSetNameRequest {
8194        #[inline(always)]
8195        fn max_ordinal_present(&self) -> u64 {
8196            if let Some(_) = self.name {
8197                return 2;
8198            }
8199            if let Some(_) = self.priority {
8200                return 1;
8201            }
8202            0
8203        }
8204    }
8205
8206    impl fidl::encoding::ValueTypeMarker for NodeSetNameRequest {
8207        type Borrowed<'a> = &'a Self;
8208        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8209            value
8210        }
8211    }
8212
8213    unsafe impl fidl::encoding::TypeMarker for NodeSetNameRequest {
8214        type Owned = Self;
8215
8216        #[inline(always)]
8217        fn inline_align(_context: fidl::encoding::Context) -> usize {
8218            8
8219        }
8220
8221        #[inline(always)]
8222        fn inline_size(_context: fidl::encoding::Context) -> usize {
8223            16
8224        }
8225    }
8226
8227    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeSetNameRequest, D>
8228        for &NodeSetNameRequest
8229    {
8230        unsafe fn encode(
8231            self,
8232            encoder: &mut fidl::encoding::Encoder<'_, D>,
8233            offset: usize,
8234            mut depth: fidl::encoding::Depth,
8235        ) -> fidl::Result<()> {
8236            encoder.debug_check_bounds::<NodeSetNameRequest>(offset);
8237            // Vector header
8238            let max_ordinal: u64 = self.max_ordinal_present();
8239            encoder.write_num(max_ordinal, offset);
8240            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8241            // Calling encoder.out_of_line_offset(0) is not allowed.
8242            if max_ordinal == 0 {
8243                return Ok(());
8244            }
8245            depth.increment()?;
8246            let envelope_size = 8;
8247            let bytes_len = max_ordinal as usize * envelope_size;
8248            #[allow(unused_variables)]
8249            let offset = encoder.out_of_line_offset(bytes_len);
8250            let mut _prev_end_offset: usize = 0;
8251            if 1 > max_ordinal {
8252                return Ok(());
8253            }
8254
8255            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8256            // are envelope_size bytes.
8257            let cur_offset: usize = (1 - 1) * envelope_size;
8258
8259            // Zero reserved fields.
8260            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8261
8262            // Safety:
8263            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8264            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8265            //   envelope_size bytes, there is always sufficient room.
8266            fidl::encoding::encode_in_envelope_optional::<u32, D>(
8267                self.priority.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
8268                encoder,
8269                offset + cur_offset,
8270                depth,
8271            )?;
8272
8273            _prev_end_offset = cur_offset + envelope_size;
8274            if 2 > max_ordinal {
8275                return Ok(());
8276            }
8277
8278            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8279            // are envelope_size bytes.
8280            let cur_offset: usize = (2 - 1) * envelope_size;
8281
8282            // Zero reserved fields.
8283            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8284
8285            // Safety:
8286            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8287            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8288            //   envelope_size bytes, there is always sufficient room.
8289            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
8290                self.name.as_ref().map(
8291                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
8292                ),
8293                encoder,
8294                offset + cur_offset,
8295                depth,
8296            )?;
8297
8298            _prev_end_offset = cur_offset + envelope_size;
8299
8300            Ok(())
8301        }
8302    }
8303
8304    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeSetNameRequest {
8305        #[inline(always)]
8306        fn new_empty() -> Self {
8307            Self::default()
8308        }
8309
8310        unsafe fn decode(
8311            &mut self,
8312            decoder: &mut fidl::encoding::Decoder<'_, D>,
8313            offset: usize,
8314            mut depth: fidl::encoding::Depth,
8315        ) -> fidl::Result<()> {
8316            decoder.debug_check_bounds::<Self>(offset);
8317            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8318                None => return Err(fidl::Error::NotNullable),
8319                Some(len) => len,
8320            };
8321            // Calling decoder.out_of_line_offset(0) is not allowed.
8322            if len == 0 {
8323                return Ok(());
8324            };
8325            depth.increment()?;
8326            let envelope_size = 8;
8327            let bytes_len = len * envelope_size;
8328            let offset = decoder.out_of_line_offset(bytes_len)?;
8329            // Decode the envelope for each type.
8330            let mut _next_ordinal_to_read = 0;
8331            let mut next_offset = offset;
8332            let end_offset = offset + bytes_len;
8333            _next_ordinal_to_read += 1;
8334            if next_offset >= end_offset {
8335                return Ok(());
8336            }
8337
8338            // Decode unknown envelopes for gaps in ordinals.
8339            while _next_ordinal_to_read < 1 {
8340                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8341                _next_ordinal_to_read += 1;
8342                next_offset += envelope_size;
8343            }
8344
8345            let next_out_of_line = decoder.next_out_of_line();
8346            let handles_before = decoder.remaining_handles();
8347            if let Some((inlined, num_bytes, num_handles)) =
8348                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8349            {
8350                let member_inline_size =
8351                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8352                if inlined != (member_inline_size <= 4) {
8353                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8354                }
8355                let inner_offset;
8356                let mut inner_depth = depth.clone();
8357                if inlined {
8358                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8359                    inner_offset = next_offset;
8360                } else {
8361                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8362                    inner_depth.increment()?;
8363                }
8364                let val_ref = self.priority.get_or_insert_with(|| fidl::new_empty!(u32, D));
8365                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
8366                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8367                {
8368                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8369                }
8370                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8371                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8372                }
8373            }
8374
8375            next_offset += envelope_size;
8376            _next_ordinal_to_read += 1;
8377            if next_offset >= end_offset {
8378                return Ok(());
8379            }
8380
8381            // Decode unknown envelopes for gaps in ordinals.
8382            while _next_ordinal_to_read < 2 {
8383                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8384                _next_ordinal_to_read += 1;
8385                next_offset += envelope_size;
8386            }
8387
8388            let next_out_of_line = decoder.next_out_of_line();
8389            let handles_before = decoder.remaining_handles();
8390            if let Some((inlined, num_bytes, num_handles)) =
8391                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8392            {
8393                let member_inline_size =
8394                    <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
8395                        decoder.context,
8396                    );
8397                if inlined != (member_inline_size <= 4) {
8398                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8399                }
8400                let inner_offset;
8401                let mut inner_depth = depth.clone();
8402                if inlined {
8403                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8404                    inner_offset = next_offset;
8405                } else {
8406                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8407                    inner_depth.increment()?;
8408                }
8409                let val_ref = self
8410                    .name
8411                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
8412                fidl::decode!(
8413                    fidl::encoding::BoundedString<64>,
8414                    D,
8415                    val_ref,
8416                    decoder,
8417                    inner_offset,
8418                    inner_depth
8419                )?;
8420                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8421                {
8422                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8423                }
8424                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8425                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8426                }
8427            }
8428
8429            next_offset += envelope_size;
8430
8431            // Decode the remaining unknown envelopes.
8432            while next_offset < end_offset {
8433                _next_ordinal_to_read += 1;
8434                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8435                next_offset += envelope_size;
8436            }
8437
8438            Ok(())
8439        }
8440    }
8441
8442    impl NodeGetBufferCollectionIdResponse {
8443        #[inline(always)]
8444        fn max_ordinal_present(&self) -> u64 {
8445            if let Some(_) = self.buffer_collection_id {
8446                return 1;
8447            }
8448            0
8449        }
8450    }
8451
8452    impl fidl::encoding::ValueTypeMarker for NodeGetBufferCollectionIdResponse {
8453        type Borrowed<'a> = &'a Self;
8454        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8455            value
8456        }
8457    }
8458
8459    unsafe impl fidl::encoding::TypeMarker for NodeGetBufferCollectionIdResponse {
8460        type Owned = Self;
8461
8462        #[inline(always)]
8463        fn inline_align(_context: fidl::encoding::Context) -> usize {
8464            8
8465        }
8466
8467        #[inline(always)]
8468        fn inline_size(_context: fidl::encoding::Context) -> usize {
8469            16
8470        }
8471    }
8472
8473    unsafe impl<D: fidl::encoding::ResourceDialect>
8474        fidl::encoding::Encode<NodeGetBufferCollectionIdResponse, D>
8475        for &NodeGetBufferCollectionIdResponse
8476    {
8477        unsafe fn encode(
8478            self,
8479            encoder: &mut fidl::encoding::Encoder<'_, D>,
8480            offset: usize,
8481            mut depth: fidl::encoding::Depth,
8482        ) -> fidl::Result<()> {
8483            encoder.debug_check_bounds::<NodeGetBufferCollectionIdResponse>(offset);
8484            // Vector header
8485            let max_ordinal: u64 = self.max_ordinal_present();
8486            encoder.write_num(max_ordinal, offset);
8487            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8488            // Calling encoder.out_of_line_offset(0) is not allowed.
8489            if max_ordinal == 0 {
8490                return Ok(());
8491            }
8492            depth.increment()?;
8493            let envelope_size = 8;
8494            let bytes_len = max_ordinal as usize * envelope_size;
8495            #[allow(unused_variables)]
8496            let offset = encoder.out_of_line_offset(bytes_len);
8497            let mut _prev_end_offset: usize = 0;
8498            if 1 > max_ordinal {
8499                return Ok(());
8500            }
8501
8502            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8503            // are envelope_size bytes.
8504            let cur_offset: usize = (1 - 1) * envelope_size;
8505
8506            // Zero reserved fields.
8507            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8508
8509            // Safety:
8510            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8511            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8512            //   envelope_size bytes, there is always sufficient room.
8513            fidl::encoding::encode_in_envelope_optional::<u64, D>(
8514                self.buffer_collection_id
8515                    .as_ref()
8516                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
8517                encoder,
8518                offset + cur_offset,
8519                depth,
8520            )?;
8521
8522            _prev_end_offset = cur_offset + envelope_size;
8523
8524            Ok(())
8525        }
8526    }
8527
8528    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8529        for NodeGetBufferCollectionIdResponse
8530    {
8531        #[inline(always)]
8532        fn new_empty() -> Self {
8533            Self::default()
8534        }
8535
8536        unsafe fn decode(
8537            &mut self,
8538            decoder: &mut fidl::encoding::Decoder<'_, D>,
8539            offset: usize,
8540            mut depth: fidl::encoding::Depth,
8541        ) -> fidl::Result<()> {
8542            decoder.debug_check_bounds::<Self>(offset);
8543            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8544                None => return Err(fidl::Error::NotNullable),
8545                Some(len) => len,
8546            };
8547            // Calling decoder.out_of_line_offset(0) is not allowed.
8548            if len == 0 {
8549                return Ok(());
8550            };
8551            depth.increment()?;
8552            let envelope_size = 8;
8553            let bytes_len = len * envelope_size;
8554            let offset = decoder.out_of_line_offset(bytes_len)?;
8555            // Decode the envelope for each type.
8556            let mut _next_ordinal_to_read = 0;
8557            let mut next_offset = offset;
8558            let end_offset = offset + bytes_len;
8559            _next_ordinal_to_read += 1;
8560            if next_offset >= end_offset {
8561                return Ok(());
8562            }
8563
8564            // Decode unknown envelopes for gaps in ordinals.
8565            while _next_ordinal_to_read < 1 {
8566                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8567                _next_ordinal_to_read += 1;
8568                next_offset += envelope_size;
8569            }
8570
8571            let next_out_of_line = decoder.next_out_of_line();
8572            let handles_before = decoder.remaining_handles();
8573            if let Some((inlined, num_bytes, num_handles)) =
8574                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8575            {
8576                let member_inline_size =
8577                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8578                if inlined != (member_inline_size <= 4) {
8579                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8580                }
8581                let inner_offset;
8582                let mut inner_depth = depth.clone();
8583                if inlined {
8584                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8585                    inner_offset = next_offset;
8586                } else {
8587                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8588                    inner_depth.increment()?;
8589                }
8590                let val_ref =
8591                    self.buffer_collection_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
8592                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
8593                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8594                {
8595                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8596                }
8597                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8598                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8599                }
8600            }
8601
8602            next_offset += envelope_size;
8603
8604            // Decode the remaining unknown envelopes.
8605            while next_offset < end_offset {
8606                _next_ordinal_to_read += 1;
8607                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8608                next_offset += envelope_size;
8609            }
8610
8611            Ok(())
8612        }
8613    }
8614
8615    impl NodeIsAlternateForResponse {
8616        #[inline(always)]
8617        fn max_ordinal_present(&self) -> u64 {
8618            if let Some(_) = self.is_alternate {
8619                return 1;
8620            }
8621            0
8622        }
8623    }
8624
8625    impl fidl::encoding::ValueTypeMarker for NodeIsAlternateForResponse {
8626        type Borrowed<'a> = &'a Self;
8627        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8628            value
8629        }
8630    }
8631
8632    unsafe impl fidl::encoding::TypeMarker for NodeIsAlternateForResponse {
8633        type Owned = Self;
8634
8635        #[inline(always)]
8636        fn inline_align(_context: fidl::encoding::Context) -> usize {
8637            8
8638        }
8639
8640        #[inline(always)]
8641        fn inline_size(_context: fidl::encoding::Context) -> usize {
8642            16
8643        }
8644    }
8645
8646    unsafe impl<D: fidl::encoding::ResourceDialect>
8647        fidl::encoding::Encode<NodeIsAlternateForResponse, D> for &NodeIsAlternateForResponse
8648    {
8649        unsafe fn encode(
8650            self,
8651            encoder: &mut fidl::encoding::Encoder<'_, D>,
8652            offset: usize,
8653            mut depth: fidl::encoding::Depth,
8654        ) -> fidl::Result<()> {
8655            encoder.debug_check_bounds::<NodeIsAlternateForResponse>(offset);
8656            // Vector header
8657            let max_ordinal: u64 = self.max_ordinal_present();
8658            encoder.write_num(max_ordinal, offset);
8659            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8660            // Calling encoder.out_of_line_offset(0) is not allowed.
8661            if max_ordinal == 0 {
8662                return Ok(());
8663            }
8664            depth.increment()?;
8665            let envelope_size = 8;
8666            let bytes_len = max_ordinal as usize * envelope_size;
8667            #[allow(unused_variables)]
8668            let offset = encoder.out_of_line_offset(bytes_len);
8669            let mut _prev_end_offset: usize = 0;
8670            if 1 > max_ordinal {
8671                return Ok(());
8672            }
8673
8674            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8675            // are envelope_size bytes.
8676            let cur_offset: usize = (1 - 1) * envelope_size;
8677
8678            // Zero reserved fields.
8679            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8680
8681            // Safety:
8682            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8683            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8684            //   envelope_size bytes, there is always sufficient room.
8685            fidl::encoding::encode_in_envelope_optional::<bool, D>(
8686                self.is_alternate.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
8687                encoder,
8688                offset + cur_offset,
8689                depth,
8690            )?;
8691
8692            _prev_end_offset = cur_offset + envelope_size;
8693
8694            Ok(())
8695        }
8696    }
8697
8698    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8699        for NodeIsAlternateForResponse
8700    {
8701        #[inline(always)]
8702        fn new_empty() -> Self {
8703            Self::default()
8704        }
8705
8706        unsafe fn decode(
8707            &mut self,
8708            decoder: &mut fidl::encoding::Decoder<'_, D>,
8709            offset: usize,
8710            mut depth: fidl::encoding::Depth,
8711        ) -> fidl::Result<()> {
8712            decoder.debug_check_bounds::<Self>(offset);
8713            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8714                None => return Err(fidl::Error::NotNullable),
8715                Some(len) => len,
8716            };
8717            // Calling decoder.out_of_line_offset(0) is not allowed.
8718            if len == 0 {
8719                return Ok(());
8720            };
8721            depth.increment()?;
8722            let envelope_size = 8;
8723            let bytes_len = len * envelope_size;
8724            let offset = decoder.out_of_line_offset(bytes_len)?;
8725            // Decode the envelope for each type.
8726            let mut _next_ordinal_to_read = 0;
8727            let mut next_offset = offset;
8728            let end_offset = offset + bytes_len;
8729            _next_ordinal_to_read += 1;
8730            if next_offset >= end_offset {
8731                return Ok(());
8732            }
8733
8734            // Decode unknown envelopes for gaps in ordinals.
8735            while _next_ordinal_to_read < 1 {
8736                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8737                _next_ordinal_to_read += 1;
8738                next_offset += envelope_size;
8739            }
8740
8741            let next_out_of_line = decoder.next_out_of_line();
8742            let handles_before = decoder.remaining_handles();
8743            if let Some((inlined, num_bytes, num_handles)) =
8744                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8745            {
8746                let member_inline_size =
8747                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8748                if inlined != (member_inline_size <= 4) {
8749                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8750                }
8751                let inner_offset;
8752                let mut inner_depth = depth.clone();
8753                if inlined {
8754                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8755                    inner_offset = next_offset;
8756                } else {
8757                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8758                    inner_depth.increment()?;
8759                }
8760                let val_ref = self.is_alternate.get_or_insert_with(|| fidl::new_empty!(bool, D));
8761                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8762                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8763                {
8764                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8765                }
8766                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8767                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8768                }
8769            }
8770
8771            next_offset += envelope_size;
8772
8773            // Decode the remaining unknown envelopes.
8774            while next_offset < end_offset {
8775                _next_ordinal_to_read += 1;
8776                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8777                next_offset += envelope_size;
8778            }
8779
8780            Ok(())
8781        }
8782    }
8783
8784    impl SecureHeapAndRange {
8785        #[inline(always)]
8786        fn max_ordinal_present(&self) -> u64 {
8787            if let Some(_) = self.range {
8788                return 2;
8789            }
8790            if let Some(_) = self.heap {
8791                return 1;
8792            }
8793            0
8794        }
8795    }
8796
8797    impl fidl::encoding::ValueTypeMarker for SecureHeapAndRange {
8798        type Borrowed<'a> = &'a Self;
8799        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8800            value
8801        }
8802    }
8803
8804    unsafe impl fidl::encoding::TypeMarker for SecureHeapAndRange {
8805        type Owned = Self;
8806
8807        #[inline(always)]
8808        fn inline_align(_context: fidl::encoding::Context) -> usize {
8809            8
8810        }
8811
8812        #[inline(always)]
8813        fn inline_size(_context: fidl::encoding::Context) -> usize {
8814            16
8815        }
8816    }
8817
8818    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SecureHeapAndRange, D>
8819        for &SecureHeapAndRange
8820    {
8821        unsafe fn encode(
8822            self,
8823            encoder: &mut fidl::encoding::Encoder<'_, D>,
8824            offset: usize,
8825            mut depth: fidl::encoding::Depth,
8826        ) -> fidl::Result<()> {
8827            encoder.debug_check_bounds::<SecureHeapAndRange>(offset);
8828            // Vector header
8829            let max_ordinal: u64 = self.max_ordinal_present();
8830            encoder.write_num(max_ordinal, offset);
8831            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8832            // Calling encoder.out_of_line_offset(0) is not allowed.
8833            if max_ordinal == 0 {
8834                return Ok(());
8835            }
8836            depth.increment()?;
8837            let envelope_size = 8;
8838            let bytes_len = max_ordinal as usize * envelope_size;
8839            #[allow(unused_variables)]
8840            let offset = encoder.out_of_line_offset(bytes_len);
8841            let mut _prev_end_offset: usize = 0;
8842            if 1 > max_ordinal {
8843                return Ok(());
8844            }
8845
8846            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8847            // are envelope_size bytes.
8848            let cur_offset: usize = (1 - 1) * envelope_size;
8849
8850            // Zero reserved fields.
8851            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8852
8853            // Safety:
8854            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8855            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8856            //   envelope_size bytes, there is always sufficient room.
8857            fidl::encoding::encode_in_envelope_optional::<Heap, D>(
8858                self.heap.as_ref().map(<Heap as fidl::encoding::ValueTypeMarker>::borrow),
8859                encoder,
8860                offset + cur_offset,
8861                depth,
8862            )?;
8863
8864            _prev_end_offset = cur_offset + envelope_size;
8865            if 2 > max_ordinal {
8866                return Ok(());
8867            }
8868
8869            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8870            // are envelope_size bytes.
8871            let cur_offset: usize = (2 - 1) * envelope_size;
8872
8873            // Zero reserved fields.
8874            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8875
8876            // Safety:
8877            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8878            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8879            //   envelope_size bytes, there is always sufficient room.
8880            fidl::encoding::encode_in_envelope_optional::<SecureHeapRange, D>(
8881                self.range
8882                    .as_ref()
8883                    .map(<SecureHeapRange as fidl::encoding::ValueTypeMarker>::borrow),
8884                encoder,
8885                offset + cur_offset,
8886                depth,
8887            )?;
8888
8889            _prev_end_offset = cur_offset + envelope_size;
8890
8891            Ok(())
8892        }
8893    }
8894
8895    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SecureHeapAndRange {
8896        #[inline(always)]
8897        fn new_empty() -> Self {
8898            Self::default()
8899        }
8900
8901        unsafe fn decode(
8902            &mut self,
8903            decoder: &mut fidl::encoding::Decoder<'_, D>,
8904            offset: usize,
8905            mut depth: fidl::encoding::Depth,
8906        ) -> fidl::Result<()> {
8907            decoder.debug_check_bounds::<Self>(offset);
8908            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8909                None => return Err(fidl::Error::NotNullable),
8910                Some(len) => len,
8911            };
8912            // Calling decoder.out_of_line_offset(0) is not allowed.
8913            if len == 0 {
8914                return Ok(());
8915            };
8916            depth.increment()?;
8917            let envelope_size = 8;
8918            let bytes_len = len * envelope_size;
8919            let offset = decoder.out_of_line_offset(bytes_len)?;
8920            // Decode the envelope for each type.
8921            let mut _next_ordinal_to_read = 0;
8922            let mut next_offset = offset;
8923            let end_offset = offset + bytes_len;
8924            _next_ordinal_to_read += 1;
8925            if next_offset >= end_offset {
8926                return Ok(());
8927            }
8928
8929            // Decode unknown envelopes for gaps in ordinals.
8930            while _next_ordinal_to_read < 1 {
8931                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8932                _next_ordinal_to_read += 1;
8933                next_offset += envelope_size;
8934            }
8935
8936            let next_out_of_line = decoder.next_out_of_line();
8937            let handles_before = decoder.remaining_handles();
8938            if let Some((inlined, num_bytes, num_handles)) =
8939                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8940            {
8941                let member_inline_size =
8942                    <Heap as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8943                if inlined != (member_inline_size <= 4) {
8944                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8945                }
8946                let inner_offset;
8947                let mut inner_depth = depth.clone();
8948                if inlined {
8949                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8950                    inner_offset = next_offset;
8951                } else {
8952                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8953                    inner_depth.increment()?;
8954                }
8955                let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(Heap, D));
8956                fidl::decode!(Heap, D, val_ref, decoder, inner_offset, inner_depth)?;
8957                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8958                {
8959                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8960                }
8961                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8962                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8963                }
8964            }
8965
8966            next_offset += envelope_size;
8967            _next_ordinal_to_read += 1;
8968            if next_offset >= end_offset {
8969                return Ok(());
8970            }
8971
8972            // Decode unknown envelopes for gaps in ordinals.
8973            while _next_ordinal_to_read < 2 {
8974                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8975                _next_ordinal_to_read += 1;
8976                next_offset += envelope_size;
8977            }
8978
8979            let next_out_of_line = decoder.next_out_of_line();
8980            let handles_before = decoder.remaining_handles();
8981            if let Some((inlined, num_bytes, num_handles)) =
8982                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8983            {
8984                let member_inline_size =
8985                    <SecureHeapRange as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8986                if inlined != (member_inline_size <= 4) {
8987                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8988                }
8989                let inner_offset;
8990                let mut inner_depth = depth.clone();
8991                if inlined {
8992                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8993                    inner_offset = next_offset;
8994                } else {
8995                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8996                    inner_depth.increment()?;
8997                }
8998                let val_ref =
8999                    self.range.get_or_insert_with(|| fidl::new_empty!(SecureHeapRange, D));
9000                fidl::decode!(SecureHeapRange, D, val_ref, decoder, inner_offset, inner_depth)?;
9001                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9002                {
9003                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9004                }
9005                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9006                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9007                }
9008            }
9009
9010            next_offset += envelope_size;
9011
9012            // Decode the remaining unknown envelopes.
9013            while next_offset < end_offset {
9014                _next_ordinal_to_read += 1;
9015                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9016                next_offset += envelope_size;
9017            }
9018
9019            Ok(())
9020        }
9021    }
9022
9023    impl SecureHeapAndRangeModification {
9024        #[inline(always)]
9025        fn max_ordinal_present(&self) -> u64 {
9026            if let Some(_) = self.new_range {
9027                return 3;
9028            }
9029            if let Some(_) = self.old_range {
9030                return 2;
9031            }
9032            if let Some(_) = self.heap {
9033                return 1;
9034            }
9035            0
9036        }
9037    }
9038
9039    impl fidl::encoding::ValueTypeMarker for SecureHeapAndRangeModification {
9040        type Borrowed<'a> = &'a Self;
9041        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9042            value
9043        }
9044    }
9045
9046    unsafe impl fidl::encoding::TypeMarker for SecureHeapAndRangeModification {
9047        type Owned = Self;
9048
9049        #[inline(always)]
9050        fn inline_align(_context: fidl::encoding::Context) -> usize {
9051            8
9052        }
9053
9054        #[inline(always)]
9055        fn inline_size(_context: fidl::encoding::Context) -> usize {
9056            16
9057        }
9058    }
9059
9060    unsafe impl<D: fidl::encoding::ResourceDialect>
9061        fidl::encoding::Encode<SecureHeapAndRangeModification, D>
9062        for &SecureHeapAndRangeModification
9063    {
9064        unsafe fn encode(
9065            self,
9066            encoder: &mut fidl::encoding::Encoder<'_, D>,
9067            offset: usize,
9068            mut depth: fidl::encoding::Depth,
9069        ) -> fidl::Result<()> {
9070            encoder.debug_check_bounds::<SecureHeapAndRangeModification>(offset);
9071            // Vector header
9072            let max_ordinal: u64 = self.max_ordinal_present();
9073            encoder.write_num(max_ordinal, offset);
9074            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9075            // Calling encoder.out_of_line_offset(0) is not allowed.
9076            if max_ordinal == 0 {
9077                return Ok(());
9078            }
9079            depth.increment()?;
9080            let envelope_size = 8;
9081            let bytes_len = max_ordinal as usize * envelope_size;
9082            #[allow(unused_variables)]
9083            let offset = encoder.out_of_line_offset(bytes_len);
9084            let mut _prev_end_offset: usize = 0;
9085            if 1 > max_ordinal {
9086                return Ok(());
9087            }
9088
9089            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9090            // are envelope_size bytes.
9091            let cur_offset: usize = (1 - 1) * envelope_size;
9092
9093            // Zero reserved fields.
9094            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9095
9096            // Safety:
9097            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9098            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9099            //   envelope_size bytes, there is always sufficient room.
9100            fidl::encoding::encode_in_envelope_optional::<Heap, D>(
9101                self.heap.as_ref().map(<Heap as fidl::encoding::ValueTypeMarker>::borrow),
9102                encoder,
9103                offset + cur_offset,
9104                depth,
9105            )?;
9106
9107            _prev_end_offset = cur_offset + envelope_size;
9108            if 2 > max_ordinal {
9109                return Ok(());
9110            }
9111
9112            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9113            // are envelope_size bytes.
9114            let cur_offset: usize = (2 - 1) * envelope_size;
9115
9116            // Zero reserved fields.
9117            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9118
9119            // Safety:
9120            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9121            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9122            //   envelope_size bytes, there is always sufficient room.
9123            fidl::encoding::encode_in_envelope_optional::<SecureHeapRange, D>(
9124                self.old_range
9125                    .as_ref()
9126                    .map(<SecureHeapRange as fidl::encoding::ValueTypeMarker>::borrow),
9127                encoder,
9128                offset + cur_offset,
9129                depth,
9130            )?;
9131
9132            _prev_end_offset = cur_offset + envelope_size;
9133            if 3 > max_ordinal {
9134                return Ok(());
9135            }
9136
9137            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9138            // are envelope_size bytes.
9139            let cur_offset: usize = (3 - 1) * envelope_size;
9140
9141            // Zero reserved fields.
9142            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9143
9144            // Safety:
9145            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9146            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9147            //   envelope_size bytes, there is always sufficient room.
9148            fidl::encoding::encode_in_envelope_optional::<SecureHeapRange, D>(
9149                self.new_range
9150                    .as_ref()
9151                    .map(<SecureHeapRange as fidl::encoding::ValueTypeMarker>::borrow),
9152                encoder,
9153                offset + cur_offset,
9154                depth,
9155            )?;
9156
9157            _prev_end_offset = cur_offset + envelope_size;
9158
9159            Ok(())
9160        }
9161    }
9162
9163    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9164        for SecureHeapAndRangeModification
9165    {
9166        #[inline(always)]
9167        fn new_empty() -> Self {
9168            Self::default()
9169        }
9170
9171        unsafe fn decode(
9172            &mut self,
9173            decoder: &mut fidl::encoding::Decoder<'_, D>,
9174            offset: usize,
9175            mut depth: fidl::encoding::Depth,
9176        ) -> fidl::Result<()> {
9177            decoder.debug_check_bounds::<Self>(offset);
9178            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9179                None => return Err(fidl::Error::NotNullable),
9180                Some(len) => len,
9181            };
9182            // Calling decoder.out_of_line_offset(0) is not allowed.
9183            if len == 0 {
9184                return Ok(());
9185            };
9186            depth.increment()?;
9187            let envelope_size = 8;
9188            let bytes_len = len * envelope_size;
9189            let offset = decoder.out_of_line_offset(bytes_len)?;
9190            // Decode the envelope for each type.
9191            let mut _next_ordinal_to_read = 0;
9192            let mut next_offset = offset;
9193            let end_offset = offset + bytes_len;
9194            _next_ordinal_to_read += 1;
9195            if next_offset >= end_offset {
9196                return Ok(());
9197            }
9198
9199            // Decode unknown envelopes for gaps in ordinals.
9200            while _next_ordinal_to_read < 1 {
9201                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9202                _next_ordinal_to_read += 1;
9203                next_offset += envelope_size;
9204            }
9205
9206            let next_out_of_line = decoder.next_out_of_line();
9207            let handles_before = decoder.remaining_handles();
9208            if let Some((inlined, num_bytes, num_handles)) =
9209                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9210            {
9211                let member_inline_size =
9212                    <Heap as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9213                if inlined != (member_inline_size <= 4) {
9214                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9215                }
9216                let inner_offset;
9217                let mut inner_depth = depth.clone();
9218                if inlined {
9219                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9220                    inner_offset = next_offset;
9221                } else {
9222                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9223                    inner_depth.increment()?;
9224                }
9225                let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(Heap, D));
9226                fidl::decode!(Heap, D, val_ref, decoder, inner_offset, inner_depth)?;
9227                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9228                {
9229                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9230                }
9231                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9232                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9233                }
9234            }
9235
9236            next_offset += envelope_size;
9237            _next_ordinal_to_read += 1;
9238            if next_offset >= end_offset {
9239                return Ok(());
9240            }
9241
9242            // Decode unknown envelopes for gaps in ordinals.
9243            while _next_ordinal_to_read < 2 {
9244                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9245                _next_ordinal_to_read += 1;
9246                next_offset += envelope_size;
9247            }
9248
9249            let next_out_of_line = decoder.next_out_of_line();
9250            let handles_before = decoder.remaining_handles();
9251            if let Some((inlined, num_bytes, num_handles)) =
9252                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9253            {
9254                let member_inline_size =
9255                    <SecureHeapRange as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9256                if inlined != (member_inline_size <= 4) {
9257                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9258                }
9259                let inner_offset;
9260                let mut inner_depth = depth.clone();
9261                if inlined {
9262                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9263                    inner_offset = next_offset;
9264                } else {
9265                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9266                    inner_depth.increment()?;
9267                }
9268                let val_ref =
9269                    self.old_range.get_or_insert_with(|| fidl::new_empty!(SecureHeapRange, D));
9270                fidl::decode!(SecureHeapRange, D, val_ref, decoder, inner_offset, inner_depth)?;
9271                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9272                {
9273                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9274                }
9275                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9276                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9277                }
9278            }
9279
9280            next_offset += envelope_size;
9281            _next_ordinal_to_read += 1;
9282            if next_offset >= end_offset {
9283                return Ok(());
9284            }
9285
9286            // Decode unknown envelopes for gaps in ordinals.
9287            while _next_ordinal_to_read < 3 {
9288                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9289                _next_ordinal_to_read += 1;
9290                next_offset += envelope_size;
9291            }
9292
9293            let next_out_of_line = decoder.next_out_of_line();
9294            let handles_before = decoder.remaining_handles();
9295            if let Some((inlined, num_bytes, num_handles)) =
9296                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9297            {
9298                let member_inline_size =
9299                    <SecureHeapRange as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9300                if inlined != (member_inline_size <= 4) {
9301                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9302                }
9303                let inner_offset;
9304                let mut inner_depth = depth.clone();
9305                if inlined {
9306                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9307                    inner_offset = next_offset;
9308                } else {
9309                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9310                    inner_depth.increment()?;
9311                }
9312                let val_ref =
9313                    self.new_range.get_or_insert_with(|| fidl::new_empty!(SecureHeapRange, D));
9314                fidl::decode!(SecureHeapRange, D, val_ref, decoder, inner_offset, inner_depth)?;
9315                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9316                {
9317                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9318                }
9319                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9320                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9321                }
9322            }
9323
9324            next_offset += envelope_size;
9325
9326            // Decode the remaining unknown envelopes.
9327            while next_offset < end_offset {
9328                _next_ordinal_to_read += 1;
9329                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9330                next_offset += envelope_size;
9331            }
9332
9333            Ok(())
9334        }
9335    }
9336
9337    impl SecureHeapAndRanges {
9338        #[inline(always)]
9339        fn max_ordinal_present(&self) -> u64 {
9340            if let Some(_) = self.ranges {
9341                return 2;
9342            }
9343            if let Some(_) = self.heap {
9344                return 1;
9345            }
9346            0
9347        }
9348    }
9349
9350    impl fidl::encoding::ValueTypeMarker for SecureHeapAndRanges {
9351        type Borrowed<'a> = &'a Self;
9352        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9353            value
9354        }
9355    }
9356
9357    unsafe impl fidl::encoding::TypeMarker for SecureHeapAndRanges {
9358        type Owned = Self;
9359
9360        #[inline(always)]
9361        fn inline_align(_context: fidl::encoding::Context) -> usize {
9362            8
9363        }
9364
9365        #[inline(always)]
9366        fn inline_size(_context: fidl::encoding::Context) -> usize {
9367            16
9368        }
9369    }
9370
9371    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SecureHeapAndRanges, D>
9372        for &SecureHeapAndRanges
9373    {
9374        unsafe fn encode(
9375            self,
9376            encoder: &mut fidl::encoding::Encoder<'_, D>,
9377            offset: usize,
9378            mut depth: fidl::encoding::Depth,
9379        ) -> fidl::Result<()> {
9380            encoder.debug_check_bounds::<SecureHeapAndRanges>(offset);
9381            // Vector header
9382            let max_ordinal: u64 = self.max_ordinal_present();
9383            encoder.write_num(max_ordinal, offset);
9384            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9385            // Calling encoder.out_of_line_offset(0) is not allowed.
9386            if max_ordinal == 0 {
9387                return Ok(());
9388            }
9389            depth.increment()?;
9390            let envelope_size = 8;
9391            let bytes_len = max_ordinal as usize * envelope_size;
9392            #[allow(unused_variables)]
9393            let offset = encoder.out_of_line_offset(bytes_len);
9394            let mut _prev_end_offset: usize = 0;
9395            if 1 > max_ordinal {
9396                return Ok(());
9397            }
9398
9399            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9400            // are envelope_size bytes.
9401            let cur_offset: usize = (1 - 1) * envelope_size;
9402
9403            // Zero reserved fields.
9404            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9405
9406            // Safety:
9407            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9408            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9409            //   envelope_size bytes, there is always sufficient room.
9410            fidl::encoding::encode_in_envelope_optional::<Heap, D>(
9411                self.heap.as_ref().map(<Heap as fidl::encoding::ValueTypeMarker>::borrow),
9412                encoder,
9413                offset + cur_offset,
9414                depth,
9415            )?;
9416
9417            _prev_end_offset = cur_offset + envelope_size;
9418            if 2 > max_ordinal {
9419                return Ok(());
9420            }
9421
9422            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9423            // are envelope_size bytes.
9424            let cur_offset: usize = (2 - 1) * envelope_size;
9425
9426            // Zero reserved fields.
9427            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9428
9429            // Safety:
9430            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9431            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9432            //   envelope_size bytes, there is always sufficient room.
9433            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<SecureHeapRange, 128>, D>(
9434            self.ranges.as_ref().map(<fidl::encoding::Vector<SecureHeapRange, 128> as fidl::encoding::ValueTypeMarker>::borrow),
9435            encoder, offset + cur_offset, depth
9436        )?;
9437
9438            _prev_end_offset = cur_offset + envelope_size;
9439
9440            Ok(())
9441        }
9442    }
9443
9444    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SecureHeapAndRanges {
9445        #[inline(always)]
9446        fn new_empty() -> Self {
9447            Self::default()
9448        }
9449
9450        unsafe fn decode(
9451            &mut self,
9452            decoder: &mut fidl::encoding::Decoder<'_, D>,
9453            offset: usize,
9454            mut depth: fidl::encoding::Depth,
9455        ) -> fidl::Result<()> {
9456            decoder.debug_check_bounds::<Self>(offset);
9457            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9458                None => return Err(fidl::Error::NotNullable),
9459                Some(len) => len,
9460            };
9461            // Calling decoder.out_of_line_offset(0) is not allowed.
9462            if len == 0 {
9463                return Ok(());
9464            };
9465            depth.increment()?;
9466            let envelope_size = 8;
9467            let bytes_len = len * envelope_size;
9468            let offset = decoder.out_of_line_offset(bytes_len)?;
9469            // Decode the envelope for each type.
9470            let mut _next_ordinal_to_read = 0;
9471            let mut next_offset = offset;
9472            let end_offset = offset + bytes_len;
9473            _next_ordinal_to_read += 1;
9474            if next_offset >= end_offset {
9475                return Ok(());
9476            }
9477
9478            // Decode unknown envelopes for gaps in ordinals.
9479            while _next_ordinal_to_read < 1 {
9480                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9481                _next_ordinal_to_read += 1;
9482                next_offset += envelope_size;
9483            }
9484
9485            let next_out_of_line = decoder.next_out_of_line();
9486            let handles_before = decoder.remaining_handles();
9487            if let Some((inlined, num_bytes, num_handles)) =
9488                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9489            {
9490                let member_inline_size =
9491                    <Heap as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9492                if inlined != (member_inline_size <= 4) {
9493                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9494                }
9495                let inner_offset;
9496                let mut inner_depth = depth.clone();
9497                if inlined {
9498                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9499                    inner_offset = next_offset;
9500                } else {
9501                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9502                    inner_depth.increment()?;
9503                }
9504                let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(Heap, D));
9505                fidl::decode!(Heap, D, val_ref, decoder, inner_offset, inner_depth)?;
9506                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9507                {
9508                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9509                }
9510                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9511                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9512                }
9513            }
9514
9515            next_offset += envelope_size;
9516            _next_ordinal_to_read += 1;
9517            if next_offset >= end_offset {
9518                return Ok(());
9519            }
9520
9521            // Decode unknown envelopes for gaps in ordinals.
9522            while _next_ordinal_to_read < 2 {
9523                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9524                _next_ordinal_to_read += 1;
9525                next_offset += envelope_size;
9526            }
9527
9528            let next_out_of_line = decoder.next_out_of_line();
9529            let handles_before = decoder.remaining_handles();
9530            if let Some((inlined, num_bytes, num_handles)) =
9531                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9532            {
9533                let member_inline_size = <fidl::encoding::Vector<SecureHeapRange, 128> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9534                if inlined != (member_inline_size <= 4) {
9535                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9536                }
9537                let inner_offset;
9538                let mut inner_depth = depth.clone();
9539                if inlined {
9540                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9541                    inner_offset = next_offset;
9542                } else {
9543                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9544                    inner_depth.increment()?;
9545                }
9546                let val_ref = self.ranges.get_or_insert_with(
9547                    || fidl::new_empty!(fidl::encoding::Vector<SecureHeapRange, 128>, D),
9548                );
9549                fidl::decode!(fidl::encoding::Vector<SecureHeapRange, 128>, D, val_ref, decoder, inner_offset, inner_depth)?;
9550                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9551                {
9552                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9553                }
9554                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9555                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9556                }
9557            }
9558
9559            next_offset += envelope_size;
9560
9561            // Decode the remaining unknown envelopes.
9562            while next_offset < end_offset {
9563                _next_ordinal_to_read += 1;
9564                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9565                next_offset += envelope_size;
9566            }
9567
9568            Ok(())
9569        }
9570    }
9571
9572    impl SecureHeapProperties {
9573        #[inline(always)]
9574        fn max_ordinal_present(&self) -> u64 {
9575            if let Some(_) = self.is_mod_protected_range_available {
9576                return 5;
9577            }
9578            if let Some(_) = self.max_protected_range_count {
9579                return 4;
9580            }
9581            if let Some(_) = self.protected_range_granularity {
9582                return 3;
9583            }
9584            if let Some(_) = self.dynamic_protection_ranges {
9585                return 2;
9586            }
9587            if let Some(_) = self.heap {
9588                return 1;
9589            }
9590            0
9591        }
9592    }
9593
9594    impl fidl::encoding::ValueTypeMarker for SecureHeapProperties {
9595        type Borrowed<'a> = &'a Self;
9596        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9597            value
9598        }
9599    }
9600
9601    unsafe impl fidl::encoding::TypeMarker for SecureHeapProperties {
9602        type Owned = Self;
9603
9604        #[inline(always)]
9605        fn inline_align(_context: fidl::encoding::Context) -> usize {
9606            8
9607        }
9608
9609        #[inline(always)]
9610        fn inline_size(_context: fidl::encoding::Context) -> usize {
9611            16
9612        }
9613    }
9614
9615    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SecureHeapProperties, D>
9616        for &SecureHeapProperties
9617    {
9618        unsafe fn encode(
9619            self,
9620            encoder: &mut fidl::encoding::Encoder<'_, D>,
9621            offset: usize,
9622            mut depth: fidl::encoding::Depth,
9623        ) -> fidl::Result<()> {
9624            encoder.debug_check_bounds::<SecureHeapProperties>(offset);
9625            // Vector header
9626            let max_ordinal: u64 = self.max_ordinal_present();
9627            encoder.write_num(max_ordinal, offset);
9628            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9629            // Calling encoder.out_of_line_offset(0) is not allowed.
9630            if max_ordinal == 0 {
9631                return Ok(());
9632            }
9633            depth.increment()?;
9634            let envelope_size = 8;
9635            let bytes_len = max_ordinal as usize * envelope_size;
9636            #[allow(unused_variables)]
9637            let offset = encoder.out_of_line_offset(bytes_len);
9638            let mut _prev_end_offset: usize = 0;
9639            if 1 > max_ordinal {
9640                return Ok(());
9641            }
9642
9643            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9644            // are envelope_size bytes.
9645            let cur_offset: usize = (1 - 1) * envelope_size;
9646
9647            // Zero reserved fields.
9648            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9649
9650            // Safety:
9651            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9652            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9653            //   envelope_size bytes, there is always sufficient room.
9654            fidl::encoding::encode_in_envelope_optional::<Heap, D>(
9655                self.heap.as_ref().map(<Heap as fidl::encoding::ValueTypeMarker>::borrow),
9656                encoder,
9657                offset + cur_offset,
9658                depth,
9659            )?;
9660
9661            _prev_end_offset = cur_offset + envelope_size;
9662            if 2 > max_ordinal {
9663                return Ok(());
9664            }
9665
9666            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9667            // are envelope_size bytes.
9668            let cur_offset: usize = (2 - 1) * envelope_size;
9669
9670            // Zero reserved fields.
9671            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9672
9673            // Safety:
9674            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9675            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9676            //   envelope_size bytes, there is always sufficient room.
9677            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9678                self.dynamic_protection_ranges
9679                    .as_ref()
9680                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9681                encoder,
9682                offset + cur_offset,
9683                depth,
9684            )?;
9685
9686            _prev_end_offset = cur_offset + envelope_size;
9687            if 3 > max_ordinal {
9688                return Ok(());
9689            }
9690
9691            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9692            // are envelope_size bytes.
9693            let cur_offset: usize = (3 - 1) * envelope_size;
9694
9695            // Zero reserved fields.
9696            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9697
9698            // Safety:
9699            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9700            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9701            //   envelope_size bytes, there is always sufficient room.
9702            fidl::encoding::encode_in_envelope_optional::<u32, D>(
9703                self.protected_range_granularity
9704                    .as_ref()
9705                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
9706                encoder,
9707                offset + cur_offset,
9708                depth,
9709            )?;
9710
9711            _prev_end_offset = cur_offset + envelope_size;
9712            if 4 > max_ordinal {
9713                return Ok(());
9714            }
9715
9716            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9717            // are envelope_size bytes.
9718            let cur_offset: usize = (4 - 1) * envelope_size;
9719
9720            // Zero reserved fields.
9721            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9722
9723            // Safety:
9724            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9725            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9726            //   envelope_size bytes, there is always sufficient room.
9727            fidl::encoding::encode_in_envelope_optional::<u64, D>(
9728                self.max_protected_range_count
9729                    .as_ref()
9730                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9731                encoder,
9732                offset + cur_offset,
9733                depth,
9734            )?;
9735
9736            _prev_end_offset = cur_offset + envelope_size;
9737            if 5 > max_ordinal {
9738                return Ok(());
9739            }
9740
9741            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9742            // are envelope_size bytes.
9743            let cur_offset: usize = (5 - 1) * envelope_size;
9744
9745            // Zero reserved fields.
9746            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9747
9748            // Safety:
9749            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9750            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9751            //   envelope_size bytes, there is always sufficient room.
9752            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9753                self.is_mod_protected_range_available
9754                    .as_ref()
9755                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9756                encoder,
9757                offset + cur_offset,
9758                depth,
9759            )?;
9760
9761            _prev_end_offset = cur_offset + envelope_size;
9762
9763            Ok(())
9764        }
9765    }
9766
9767    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SecureHeapProperties {
9768        #[inline(always)]
9769        fn new_empty() -> Self {
9770            Self::default()
9771        }
9772
9773        unsafe fn decode(
9774            &mut self,
9775            decoder: &mut fidl::encoding::Decoder<'_, D>,
9776            offset: usize,
9777            mut depth: fidl::encoding::Depth,
9778        ) -> fidl::Result<()> {
9779            decoder.debug_check_bounds::<Self>(offset);
9780            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9781                None => return Err(fidl::Error::NotNullable),
9782                Some(len) => len,
9783            };
9784            // Calling decoder.out_of_line_offset(0) is not allowed.
9785            if len == 0 {
9786                return Ok(());
9787            };
9788            depth.increment()?;
9789            let envelope_size = 8;
9790            let bytes_len = len * envelope_size;
9791            let offset = decoder.out_of_line_offset(bytes_len)?;
9792            // Decode the envelope for each type.
9793            let mut _next_ordinal_to_read = 0;
9794            let mut next_offset = offset;
9795            let end_offset = offset + bytes_len;
9796            _next_ordinal_to_read += 1;
9797            if next_offset >= end_offset {
9798                return Ok(());
9799            }
9800
9801            // Decode unknown envelopes for gaps in ordinals.
9802            while _next_ordinal_to_read < 1 {
9803                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9804                _next_ordinal_to_read += 1;
9805                next_offset += envelope_size;
9806            }
9807
9808            let next_out_of_line = decoder.next_out_of_line();
9809            let handles_before = decoder.remaining_handles();
9810            if let Some((inlined, num_bytes, num_handles)) =
9811                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9812            {
9813                let member_inline_size =
9814                    <Heap as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9815                if inlined != (member_inline_size <= 4) {
9816                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9817                }
9818                let inner_offset;
9819                let mut inner_depth = depth.clone();
9820                if inlined {
9821                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9822                    inner_offset = next_offset;
9823                } else {
9824                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9825                    inner_depth.increment()?;
9826                }
9827                let val_ref = self.heap.get_or_insert_with(|| fidl::new_empty!(Heap, D));
9828                fidl::decode!(Heap, D, val_ref, decoder, inner_offset, inner_depth)?;
9829                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9830                {
9831                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9832                }
9833                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9834                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9835                }
9836            }
9837
9838            next_offset += envelope_size;
9839            _next_ordinal_to_read += 1;
9840            if next_offset >= end_offset {
9841                return Ok(());
9842            }
9843
9844            // Decode unknown envelopes for gaps in ordinals.
9845            while _next_ordinal_to_read < 2 {
9846                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9847                _next_ordinal_to_read += 1;
9848                next_offset += envelope_size;
9849            }
9850
9851            let next_out_of_line = decoder.next_out_of_line();
9852            let handles_before = decoder.remaining_handles();
9853            if let Some((inlined, num_bytes, num_handles)) =
9854                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9855            {
9856                let member_inline_size =
9857                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9858                if inlined != (member_inline_size <= 4) {
9859                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9860                }
9861                let inner_offset;
9862                let mut inner_depth = depth.clone();
9863                if inlined {
9864                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9865                    inner_offset = next_offset;
9866                } else {
9867                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9868                    inner_depth.increment()?;
9869                }
9870                let val_ref =
9871                    self.dynamic_protection_ranges.get_or_insert_with(|| fidl::new_empty!(bool, D));
9872                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9873                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9874                {
9875                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9876                }
9877                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9878                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9879                }
9880            }
9881
9882            next_offset += envelope_size;
9883            _next_ordinal_to_read += 1;
9884            if next_offset >= end_offset {
9885                return Ok(());
9886            }
9887
9888            // Decode unknown envelopes for gaps in ordinals.
9889            while _next_ordinal_to_read < 3 {
9890                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9891                _next_ordinal_to_read += 1;
9892                next_offset += envelope_size;
9893            }
9894
9895            let next_out_of_line = decoder.next_out_of_line();
9896            let handles_before = decoder.remaining_handles();
9897            if let Some((inlined, num_bytes, num_handles)) =
9898                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9899            {
9900                let member_inline_size =
9901                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9902                if inlined != (member_inline_size <= 4) {
9903                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9904                }
9905                let inner_offset;
9906                let mut inner_depth = depth.clone();
9907                if inlined {
9908                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9909                    inner_offset = next_offset;
9910                } else {
9911                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9912                    inner_depth.increment()?;
9913                }
9914                let val_ref = self
9915                    .protected_range_granularity
9916                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
9917                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
9918                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9919                {
9920                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9921                }
9922                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9923                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9924                }
9925            }
9926
9927            next_offset += envelope_size;
9928            _next_ordinal_to_read += 1;
9929            if next_offset >= end_offset {
9930                return Ok(());
9931            }
9932
9933            // Decode unknown envelopes for gaps in ordinals.
9934            while _next_ordinal_to_read < 4 {
9935                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9936                _next_ordinal_to_read += 1;
9937                next_offset += envelope_size;
9938            }
9939
9940            let next_out_of_line = decoder.next_out_of_line();
9941            let handles_before = decoder.remaining_handles();
9942            if let Some((inlined, num_bytes, num_handles)) =
9943                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9944            {
9945                let member_inline_size =
9946                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9947                if inlined != (member_inline_size <= 4) {
9948                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9949                }
9950                let inner_offset;
9951                let mut inner_depth = depth.clone();
9952                if inlined {
9953                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9954                    inner_offset = next_offset;
9955                } else {
9956                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9957                    inner_depth.increment()?;
9958                }
9959                let val_ref =
9960                    self.max_protected_range_count.get_or_insert_with(|| fidl::new_empty!(u64, D));
9961                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9962                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9963                {
9964                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9965                }
9966                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9967                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9968                }
9969            }
9970
9971            next_offset += envelope_size;
9972            _next_ordinal_to_read += 1;
9973            if next_offset >= end_offset {
9974                return Ok(());
9975            }
9976
9977            // Decode unknown envelopes for gaps in ordinals.
9978            while _next_ordinal_to_read < 5 {
9979                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9980                _next_ordinal_to_read += 1;
9981                next_offset += envelope_size;
9982            }
9983
9984            let next_out_of_line = decoder.next_out_of_line();
9985            let handles_before = decoder.remaining_handles();
9986            if let Some((inlined, num_bytes, num_handles)) =
9987                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9988            {
9989                let member_inline_size =
9990                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9991                if inlined != (member_inline_size <= 4) {
9992                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9993                }
9994                let inner_offset;
9995                let mut inner_depth = depth.clone();
9996                if inlined {
9997                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9998                    inner_offset = next_offset;
9999                } else {
10000                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10001                    inner_depth.increment()?;
10002                }
10003                let val_ref = self
10004                    .is_mod_protected_range_available
10005                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
10006                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10007                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10008                {
10009                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10010                }
10011                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10012                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10013                }
10014            }
10015
10016            next_offset += envelope_size;
10017
10018            // Decode the remaining unknown envelopes.
10019            while next_offset < end_offset {
10020                _next_ordinal_to_read += 1;
10021                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10022                next_offset += envelope_size;
10023            }
10024
10025            Ok(())
10026        }
10027    }
10028
10029    impl SecureHeapRange {
10030        #[inline(always)]
10031        fn max_ordinal_present(&self) -> u64 {
10032            if let Some(_) = self.size_bytes {
10033                return 2;
10034            }
10035            if let Some(_) = self.physical_address {
10036                return 1;
10037            }
10038            0
10039        }
10040    }
10041
10042    impl fidl::encoding::ValueTypeMarker for SecureHeapRange {
10043        type Borrowed<'a> = &'a Self;
10044        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10045            value
10046        }
10047    }
10048
10049    unsafe impl fidl::encoding::TypeMarker for SecureHeapRange {
10050        type Owned = Self;
10051
10052        #[inline(always)]
10053        fn inline_align(_context: fidl::encoding::Context) -> usize {
10054            8
10055        }
10056
10057        #[inline(always)]
10058        fn inline_size(_context: fidl::encoding::Context) -> usize {
10059            16
10060        }
10061    }
10062
10063    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SecureHeapRange, D>
10064        for &SecureHeapRange
10065    {
10066        unsafe fn encode(
10067            self,
10068            encoder: &mut fidl::encoding::Encoder<'_, D>,
10069            offset: usize,
10070            mut depth: fidl::encoding::Depth,
10071        ) -> fidl::Result<()> {
10072            encoder.debug_check_bounds::<SecureHeapRange>(offset);
10073            // Vector header
10074            let max_ordinal: u64 = self.max_ordinal_present();
10075            encoder.write_num(max_ordinal, offset);
10076            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10077            // Calling encoder.out_of_line_offset(0) is not allowed.
10078            if max_ordinal == 0 {
10079                return Ok(());
10080            }
10081            depth.increment()?;
10082            let envelope_size = 8;
10083            let bytes_len = max_ordinal as usize * envelope_size;
10084            #[allow(unused_variables)]
10085            let offset = encoder.out_of_line_offset(bytes_len);
10086            let mut _prev_end_offset: usize = 0;
10087            if 1 > max_ordinal {
10088                return Ok(());
10089            }
10090
10091            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10092            // are envelope_size bytes.
10093            let cur_offset: usize = (1 - 1) * envelope_size;
10094
10095            // Zero reserved fields.
10096            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10097
10098            // Safety:
10099            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10100            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10101            //   envelope_size bytes, there is always sufficient room.
10102            fidl::encoding::encode_in_envelope_optional::<u64, D>(
10103                self.physical_address
10104                    .as_ref()
10105                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10106                encoder,
10107                offset + cur_offset,
10108                depth,
10109            )?;
10110
10111            _prev_end_offset = cur_offset + envelope_size;
10112            if 2 > max_ordinal {
10113                return Ok(());
10114            }
10115
10116            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10117            // are envelope_size bytes.
10118            let cur_offset: usize = (2 - 1) * envelope_size;
10119
10120            // Zero reserved fields.
10121            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10122
10123            // Safety:
10124            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10125            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10126            //   envelope_size bytes, there is always sufficient room.
10127            fidl::encoding::encode_in_envelope_optional::<u64, D>(
10128                self.size_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10129                encoder,
10130                offset + cur_offset,
10131                depth,
10132            )?;
10133
10134            _prev_end_offset = cur_offset + envelope_size;
10135
10136            Ok(())
10137        }
10138    }
10139
10140    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SecureHeapRange {
10141        #[inline(always)]
10142        fn new_empty() -> Self {
10143            Self::default()
10144        }
10145
10146        unsafe fn decode(
10147            &mut self,
10148            decoder: &mut fidl::encoding::Decoder<'_, D>,
10149            offset: usize,
10150            mut depth: fidl::encoding::Depth,
10151        ) -> fidl::Result<()> {
10152            decoder.debug_check_bounds::<Self>(offset);
10153            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10154                None => return Err(fidl::Error::NotNullable),
10155                Some(len) => len,
10156            };
10157            // Calling decoder.out_of_line_offset(0) is not allowed.
10158            if len == 0 {
10159                return Ok(());
10160            };
10161            depth.increment()?;
10162            let envelope_size = 8;
10163            let bytes_len = len * envelope_size;
10164            let offset = decoder.out_of_line_offset(bytes_len)?;
10165            // Decode the envelope for each type.
10166            let mut _next_ordinal_to_read = 0;
10167            let mut next_offset = offset;
10168            let end_offset = offset + bytes_len;
10169            _next_ordinal_to_read += 1;
10170            if next_offset >= end_offset {
10171                return Ok(());
10172            }
10173
10174            // Decode unknown envelopes for gaps in ordinals.
10175            while _next_ordinal_to_read < 1 {
10176                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10177                _next_ordinal_to_read += 1;
10178                next_offset += envelope_size;
10179            }
10180
10181            let next_out_of_line = decoder.next_out_of_line();
10182            let handles_before = decoder.remaining_handles();
10183            if let Some((inlined, num_bytes, num_handles)) =
10184                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10185            {
10186                let member_inline_size =
10187                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10188                if inlined != (member_inline_size <= 4) {
10189                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10190                }
10191                let inner_offset;
10192                let mut inner_depth = depth.clone();
10193                if inlined {
10194                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10195                    inner_offset = next_offset;
10196                } else {
10197                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10198                    inner_depth.increment()?;
10199                }
10200                let val_ref = self.physical_address.get_or_insert_with(|| fidl::new_empty!(u64, D));
10201                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10202                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10203                {
10204                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10205                }
10206                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10207                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10208                }
10209            }
10210
10211            next_offset += envelope_size;
10212            _next_ordinal_to_read += 1;
10213            if next_offset >= end_offset {
10214                return Ok(());
10215            }
10216
10217            // Decode unknown envelopes for gaps in ordinals.
10218            while _next_ordinal_to_read < 2 {
10219                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10220                _next_ordinal_to_read += 1;
10221                next_offset += envelope_size;
10222            }
10223
10224            let next_out_of_line = decoder.next_out_of_line();
10225            let handles_before = decoder.remaining_handles();
10226            if let Some((inlined, num_bytes, num_handles)) =
10227                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10228            {
10229                let member_inline_size =
10230                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10231                if inlined != (member_inline_size <= 4) {
10232                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10233                }
10234                let inner_offset;
10235                let mut inner_depth = depth.clone();
10236                if inlined {
10237                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10238                    inner_offset = next_offset;
10239                } else {
10240                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10241                    inner_depth.increment()?;
10242                }
10243                let val_ref = self.size_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
10244                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10245                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10246                {
10247                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10248                }
10249                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10250                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10251                }
10252            }
10253
10254            next_offset += envelope_size;
10255
10256            // Decode the remaining unknown envelopes.
10257            while next_offset < end_offset {
10258                _next_ordinal_to_read += 1;
10259                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10260                next_offset += envelope_size;
10261            }
10262
10263            Ok(())
10264        }
10265    }
10266
10267    impl SecureMemAddSecureHeapPhysicalRangeRequest {
10268        #[inline(always)]
10269        fn max_ordinal_present(&self) -> u64 {
10270            if let Some(_) = self.heap_range {
10271                return 1;
10272            }
10273            0
10274        }
10275    }
10276
10277    impl fidl::encoding::ValueTypeMarker for SecureMemAddSecureHeapPhysicalRangeRequest {
10278        type Borrowed<'a> = &'a Self;
10279        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10280            value
10281        }
10282    }
10283
10284    unsafe impl fidl::encoding::TypeMarker for SecureMemAddSecureHeapPhysicalRangeRequest {
10285        type Owned = Self;
10286
10287        #[inline(always)]
10288        fn inline_align(_context: fidl::encoding::Context) -> usize {
10289            8
10290        }
10291
10292        #[inline(always)]
10293        fn inline_size(_context: fidl::encoding::Context) -> usize {
10294            16
10295        }
10296    }
10297
10298    unsafe impl<D: fidl::encoding::ResourceDialect>
10299        fidl::encoding::Encode<SecureMemAddSecureHeapPhysicalRangeRequest, D>
10300        for &SecureMemAddSecureHeapPhysicalRangeRequest
10301    {
10302        unsafe fn encode(
10303            self,
10304            encoder: &mut fidl::encoding::Encoder<'_, D>,
10305            offset: usize,
10306            mut depth: fidl::encoding::Depth,
10307        ) -> fidl::Result<()> {
10308            encoder.debug_check_bounds::<SecureMemAddSecureHeapPhysicalRangeRequest>(offset);
10309            // Vector header
10310            let max_ordinal: u64 = self.max_ordinal_present();
10311            encoder.write_num(max_ordinal, offset);
10312            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10313            // Calling encoder.out_of_line_offset(0) is not allowed.
10314            if max_ordinal == 0 {
10315                return Ok(());
10316            }
10317            depth.increment()?;
10318            let envelope_size = 8;
10319            let bytes_len = max_ordinal as usize * envelope_size;
10320            #[allow(unused_variables)]
10321            let offset = encoder.out_of_line_offset(bytes_len);
10322            let mut _prev_end_offset: usize = 0;
10323            if 1 > max_ordinal {
10324                return Ok(());
10325            }
10326
10327            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10328            // are envelope_size bytes.
10329            let cur_offset: usize = (1 - 1) * envelope_size;
10330
10331            // Zero reserved fields.
10332            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10333
10334            // Safety:
10335            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10336            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10337            //   envelope_size bytes, there is always sufficient room.
10338            fidl::encoding::encode_in_envelope_optional::<SecureHeapAndRange, D>(
10339                self.heap_range
10340                    .as_ref()
10341                    .map(<SecureHeapAndRange as fidl::encoding::ValueTypeMarker>::borrow),
10342                encoder,
10343                offset + cur_offset,
10344                depth,
10345            )?;
10346
10347            _prev_end_offset = cur_offset + envelope_size;
10348
10349            Ok(())
10350        }
10351    }
10352
10353    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10354        for SecureMemAddSecureHeapPhysicalRangeRequest
10355    {
10356        #[inline(always)]
10357        fn new_empty() -> Self {
10358            Self::default()
10359        }
10360
10361        unsafe fn decode(
10362            &mut self,
10363            decoder: &mut fidl::encoding::Decoder<'_, D>,
10364            offset: usize,
10365            mut depth: fidl::encoding::Depth,
10366        ) -> fidl::Result<()> {
10367            decoder.debug_check_bounds::<Self>(offset);
10368            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10369                None => return Err(fidl::Error::NotNullable),
10370                Some(len) => len,
10371            };
10372            // Calling decoder.out_of_line_offset(0) is not allowed.
10373            if len == 0 {
10374                return Ok(());
10375            };
10376            depth.increment()?;
10377            let envelope_size = 8;
10378            let bytes_len = len * envelope_size;
10379            let offset = decoder.out_of_line_offset(bytes_len)?;
10380            // Decode the envelope for each type.
10381            let mut _next_ordinal_to_read = 0;
10382            let mut next_offset = offset;
10383            let end_offset = offset + bytes_len;
10384            _next_ordinal_to_read += 1;
10385            if next_offset >= end_offset {
10386                return Ok(());
10387            }
10388
10389            // Decode unknown envelopes for gaps in ordinals.
10390            while _next_ordinal_to_read < 1 {
10391                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10392                _next_ordinal_to_read += 1;
10393                next_offset += envelope_size;
10394            }
10395
10396            let next_out_of_line = decoder.next_out_of_line();
10397            let handles_before = decoder.remaining_handles();
10398            if let Some((inlined, num_bytes, num_handles)) =
10399                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10400            {
10401                let member_inline_size =
10402                    <SecureHeapAndRange as fidl::encoding::TypeMarker>::inline_size(
10403                        decoder.context,
10404                    );
10405                if inlined != (member_inline_size <= 4) {
10406                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10407                }
10408                let inner_offset;
10409                let mut inner_depth = depth.clone();
10410                if inlined {
10411                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10412                    inner_offset = next_offset;
10413                } else {
10414                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10415                    inner_depth.increment()?;
10416                }
10417                let val_ref =
10418                    self.heap_range.get_or_insert_with(|| fidl::new_empty!(SecureHeapAndRange, D));
10419                fidl::decode!(SecureHeapAndRange, D, val_ref, decoder, inner_offset, inner_depth)?;
10420                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10421                {
10422                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10423                }
10424                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10425                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10426                }
10427            }
10428
10429            next_offset += envelope_size;
10430
10431            // Decode the remaining unknown envelopes.
10432            while next_offset < end_offset {
10433                _next_ordinal_to_read += 1;
10434                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10435                next_offset += envelope_size;
10436            }
10437
10438            Ok(())
10439        }
10440    }
10441
10442    impl SecureMemDeleteSecureHeapPhysicalRangeRequest {
10443        #[inline(always)]
10444        fn max_ordinal_present(&self) -> u64 {
10445            if let Some(_) = self.heap_range {
10446                return 1;
10447            }
10448            0
10449        }
10450    }
10451
10452    impl fidl::encoding::ValueTypeMarker for SecureMemDeleteSecureHeapPhysicalRangeRequest {
10453        type Borrowed<'a> = &'a Self;
10454        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10455            value
10456        }
10457    }
10458
10459    unsafe impl fidl::encoding::TypeMarker for SecureMemDeleteSecureHeapPhysicalRangeRequest {
10460        type Owned = Self;
10461
10462        #[inline(always)]
10463        fn inline_align(_context: fidl::encoding::Context) -> usize {
10464            8
10465        }
10466
10467        #[inline(always)]
10468        fn inline_size(_context: fidl::encoding::Context) -> usize {
10469            16
10470        }
10471    }
10472
10473    unsafe impl<D: fidl::encoding::ResourceDialect>
10474        fidl::encoding::Encode<SecureMemDeleteSecureHeapPhysicalRangeRequest, D>
10475        for &SecureMemDeleteSecureHeapPhysicalRangeRequest
10476    {
10477        unsafe fn encode(
10478            self,
10479            encoder: &mut fidl::encoding::Encoder<'_, D>,
10480            offset: usize,
10481            mut depth: fidl::encoding::Depth,
10482        ) -> fidl::Result<()> {
10483            encoder.debug_check_bounds::<SecureMemDeleteSecureHeapPhysicalRangeRequest>(offset);
10484            // Vector header
10485            let max_ordinal: u64 = self.max_ordinal_present();
10486            encoder.write_num(max_ordinal, offset);
10487            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10488            // Calling encoder.out_of_line_offset(0) is not allowed.
10489            if max_ordinal == 0 {
10490                return Ok(());
10491            }
10492            depth.increment()?;
10493            let envelope_size = 8;
10494            let bytes_len = max_ordinal as usize * envelope_size;
10495            #[allow(unused_variables)]
10496            let offset = encoder.out_of_line_offset(bytes_len);
10497            let mut _prev_end_offset: usize = 0;
10498            if 1 > max_ordinal {
10499                return Ok(());
10500            }
10501
10502            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10503            // are envelope_size bytes.
10504            let cur_offset: usize = (1 - 1) * envelope_size;
10505
10506            // Zero reserved fields.
10507            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10508
10509            // Safety:
10510            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10511            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10512            //   envelope_size bytes, there is always sufficient room.
10513            fidl::encoding::encode_in_envelope_optional::<SecureHeapAndRange, D>(
10514                self.heap_range
10515                    .as_ref()
10516                    .map(<SecureHeapAndRange as fidl::encoding::ValueTypeMarker>::borrow),
10517                encoder,
10518                offset + cur_offset,
10519                depth,
10520            )?;
10521
10522            _prev_end_offset = cur_offset + envelope_size;
10523
10524            Ok(())
10525        }
10526    }
10527
10528    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10529        for SecureMemDeleteSecureHeapPhysicalRangeRequest
10530    {
10531        #[inline(always)]
10532        fn new_empty() -> Self {
10533            Self::default()
10534        }
10535
10536        unsafe fn decode(
10537            &mut self,
10538            decoder: &mut fidl::encoding::Decoder<'_, D>,
10539            offset: usize,
10540            mut depth: fidl::encoding::Depth,
10541        ) -> fidl::Result<()> {
10542            decoder.debug_check_bounds::<Self>(offset);
10543            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10544                None => return Err(fidl::Error::NotNullable),
10545                Some(len) => len,
10546            };
10547            // Calling decoder.out_of_line_offset(0) is not allowed.
10548            if len == 0 {
10549                return Ok(());
10550            };
10551            depth.increment()?;
10552            let envelope_size = 8;
10553            let bytes_len = len * envelope_size;
10554            let offset = decoder.out_of_line_offset(bytes_len)?;
10555            // Decode the envelope for each type.
10556            let mut _next_ordinal_to_read = 0;
10557            let mut next_offset = offset;
10558            let end_offset = offset + bytes_len;
10559            _next_ordinal_to_read += 1;
10560            if next_offset >= end_offset {
10561                return Ok(());
10562            }
10563
10564            // Decode unknown envelopes for gaps in ordinals.
10565            while _next_ordinal_to_read < 1 {
10566                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10567                _next_ordinal_to_read += 1;
10568                next_offset += envelope_size;
10569            }
10570
10571            let next_out_of_line = decoder.next_out_of_line();
10572            let handles_before = decoder.remaining_handles();
10573            if let Some((inlined, num_bytes, num_handles)) =
10574                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10575            {
10576                let member_inline_size =
10577                    <SecureHeapAndRange as fidl::encoding::TypeMarker>::inline_size(
10578                        decoder.context,
10579                    );
10580                if inlined != (member_inline_size <= 4) {
10581                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10582                }
10583                let inner_offset;
10584                let mut inner_depth = depth.clone();
10585                if inlined {
10586                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10587                    inner_offset = next_offset;
10588                } else {
10589                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10590                    inner_depth.increment()?;
10591                }
10592                let val_ref =
10593                    self.heap_range.get_or_insert_with(|| fidl::new_empty!(SecureHeapAndRange, D));
10594                fidl::decode!(SecureHeapAndRange, D, val_ref, decoder, inner_offset, inner_depth)?;
10595                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10596                {
10597                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10598                }
10599                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10600                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10601                }
10602            }
10603
10604            next_offset += envelope_size;
10605
10606            // Decode the remaining unknown envelopes.
10607            while next_offset < end_offset {
10608                _next_ordinal_to_read += 1;
10609                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10610                next_offset += envelope_size;
10611            }
10612
10613            Ok(())
10614        }
10615    }
10616
10617    impl SecureMemGetPhysicalSecureHeapPropertiesRequest {
10618        #[inline(always)]
10619        fn max_ordinal_present(&self) -> u64 {
10620            if let Some(_) = self.entire_heap {
10621                return 1;
10622            }
10623            0
10624        }
10625    }
10626
10627    impl fidl::encoding::ValueTypeMarker for SecureMemGetPhysicalSecureHeapPropertiesRequest {
10628        type Borrowed<'a> = &'a Self;
10629        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10630            value
10631        }
10632    }
10633
10634    unsafe impl fidl::encoding::TypeMarker for SecureMemGetPhysicalSecureHeapPropertiesRequest {
10635        type Owned = Self;
10636
10637        #[inline(always)]
10638        fn inline_align(_context: fidl::encoding::Context) -> usize {
10639            8
10640        }
10641
10642        #[inline(always)]
10643        fn inline_size(_context: fidl::encoding::Context) -> usize {
10644            16
10645        }
10646    }
10647
10648    unsafe impl<D: fidl::encoding::ResourceDialect>
10649        fidl::encoding::Encode<SecureMemGetPhysicalSecureHeapPropertiesRequest, D>
10650        for &SecureMemGetPhysicalSecureHeapPropertiesRequest
10651    {
10652        unsafe fn encode(
10653            self,
10654            encoder: &mut fidl::encoding::Encoder<'_, D>,
10655            offset: usize,
10656            mut depth: fidl::encoding::Depth,
10657        ) -> fidl::Result<()> {
10658            encoder.debug_check_bounds::<SecureMemGetPhysicalSecureHeapPropertiesRequest>(offset);
10659            // Vector header
10660            let max_ordinal: u64 = self.max_ordinal_present();
10661            encoder.write_num(max_ordinal, offset);
10662            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10663            // Calling encoder.out_of_line_offset(0) is not allowed.
10664            if max_ordinal == 0 {
10665                return Ok(());
10666            }
10667            depth.increment()?;
10668            let envelope_size = 8;
10669            let bytes_len = max_ordinal as usize * envelope_size;
10670            #[allow(unused_variables)]
10671            let offset = encoder.out_of_line_offset(bytes_len);
10672            let mut _prev_end_offset: usize = 0;
10673            if 1 > max_ordinal {
10674                return Ok(());
10675            }
10676
10677            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10678            // are envelope_size bytes.
10679            let cur_offset: usize = (1 - 1) * envelope_size;
10680
10681            // Zero reserved fields.
10682            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10683
10684            // Safety:
10685            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10686            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10687            //   envelope_size bytes, there is always sufficient room.
10688            fidl::encoding::encode_in_envelope_optional::<SecureHeapAndRange, D>(
10689                self.entire_heap
10690                    .as_ref()
10691                    .map(<SecureHeapAndRange as fidl::encoding::ValueTypeMarker>::borrow),
10692                encoder,
10693                offset + cur_offset,
10694                depth,
10695            )?;
10696
10697            _prev_end_offset = cur_offset + envelope_size;
10698
10699            Ok(())
10700        }
10701    }
10702
10703    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10704        for SecureMemGetPhysicalSecureHeapPropertiesRequest
10705    {
10706        #[inline(always)]
10707        fn new_empty() -> Self {
10708            Self::default()
10709        }
10710
10711        unsafe fn decode(
10712            &mut self,
10713            decoder: &mut fidl::encoding::Decoder<'_, D>,
10714            offset: usize,
10715            mut depth: fidl::encoding::Depth,
10716        ) -> fidl::Result<()> {
10717            decoder.debug_check_bounds::<Self>(offset);
10718            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10719                None => return Err(fidl::Error::NotNullable),
10720                Some(len) => len,
10721            };
10722            // Calling decoder.out_of_line_offset(0) is not allowed.
10723            if len == 0 {
10724                return Ok(());
10725            };
10726            depth.increment()?;
10727            let envelope_size = 8;
10728            let bytes_len = len * envelope_size;
10729            let offset = decoder.out_of_line_offset(bytes_len)?;
10730            // Decode the envelope for each type.
10731            let mut _next_ordinal_to_read = 0;
10732            let mut next_offset = offset;
10733            let end_offset = offset + bytes_len;
10734            _next_ordinal_to_read += 1;
10735            if next_offset >= end_offset {
10736                return Ok(());
10737            }
10738
10739            // Decode unknown envelopes for gaps in ordinals.
10740            while _next_ordinal_to_read < 1 {
10741                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10742                _next_ordinal_to_read += 1;
10743                next_offset += envelope_size;
10744            }
10745
10746            let next_out_of_line = decoder.next_out_of_line();
10747            let handles_before = decoder.remaining_handles();
10748            if let Some((inlined, num_bytes, num_handles)) =
10749                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10750            {
10751                let member_inline_size =
10752                    <SecureHeapAndRange as fidl::encoding::TypeMarker>::inline_size(
10753                        decoder.context,
10754                    );
10755                if inlined != (member_inline_size <= 4) {
10756                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10757                }
10758                let inner_offset;
10759                let mut inner_depth = depth.clone();
10760                if inlined {
10761                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10762                    inner_offset = next_offset;
10763                } else {
10764                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10765                    inner_depth.increment()?;
10766                }
10767                let val_ref =
10768                    self.entire_heap.get_or_insert_with(|| fidl::new_empty!(SecureHeapAndRange, D));
10769                fidl::decode!(SecureHeapAndRange, D, val_ref, decoder, inner_offset, inner_depth)?;
10770                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10771                {
10772                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10773                }
10774                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10775                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10776                }
10777            }
10778
10779            next_offset += envelope_size;
10780
10781            // Decode the remaining unknown envelopes.
10782            while next_offset < end_offset {
10783                _next_ordinal_to_read += 1;
10784                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10785                next_offset += envelope_size;
10786            }
10787
10788            Ok(())
10789        }
10790    }
10791
10792    impl SecureMemModifySecureHeapPhysicalRangeRequest {
10793        #[inline(always)]
10794        fn max_ordinal_present(&self) -> u64 {
10795            if let Some(_) = self.range_modification {
10796                return 1;
10797            }
10798            0
10799        }
10800    }
10801
10802    impl fidl::encoding::ValueTypeMarker for SecureMemModifySecureHeapPhysicalRangeRequest {
10803        type Borrowed<'a> = &'a Self;
10804        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10805            value
10806        }
10807    }
10808
10809    unsafe impl fidl::encoding::TypeMarker for SecureMemModifySecureHeapPhysicalRangeRequest {
10810        type Owned = Self;
10811
10812        #[inline(always)]
10813        fn inline_align(_context: fidl::encoding::Context) -> usize {
10814            8
10815        }
10816
10817        #[inline(always)]
10818        fn inline_size(_context: fidl::encoding::Context) -> usize {
10819            16
10820        }
10821    }
10822
10823    unsafe impl<D: fidl::encoding::ResourceDialect>
10824        fidl::encoding::Encode<SecureMemModifySecureHeapPhysicalRangeRequest, D>
10825        for &SecureMemModifySecureHeapPhysicalRangeRequest
10826    {
10827        unsafe fn encode(
10828            self,
10829            encoder: &mut fidl::encoding::Encoder<'_, D>,
10830            offset: usize,
10831            mut depth: fidl::encoding::Depth,
10832        ) -> fidl::Result<()> {
10833            encoder.debug_check_bounds::<SecureMemModifySecureHeapPhysicalRangeRequest>(offset);
10834            // Vector header
10835            let max_ordinal: u64 = self.max_ordinal_present();
10836            encoder.write_num(max_ordinal, offset);
10837            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10838            // Calling encoder.out_of_line_offset(0) is not allowed.
10839            if max_ordinal == 0 {
10840                return Ok(());
10841            }
10842            depth.increment()?;
10843            let envelope_size = 8;
10844            let bytes_len = max_ordinal as usize * envelope_size;
10845            #[allow(unused_variables)]
10846            let offset = encoder.out_of_line_offset(bytes_len);
10847            let mut _prev_end_offset: usize = 0;
10848            if 1 > max_ordinal {
10849                return Ok(());
10850            }
10851
10852            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10853            // are envelope_size bytes.
10854            let cur_offset: usize = (1 - 1) * envelope_size;
10855
10856            // Zero reserved fields.
10857            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10858
10859            // Safety:
10860            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10861            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10862            //   envelope_size bytes, there is always sufficient room.
10863            fidl::encoding::encode_in_envelope_optional::<SecureHeapAndRangeModification, D>(
10864                self.range_modification.as_ref().map(
10865                    <SecureHeapAndRangeModification as fidl::encoding::ValueTypeMarker>::borrow,
10866                ),
10867                encoder,
10868                offset + cur_offset,
10869                depth,
10870            )?;
10871
10872            _prev_end_offset = cur_offset + envelope_size;
10873
10874            Ok(())
10875        }
10876    }
10877
10878    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10879        for SecureMemModifySecureHeapPhysicalRangeRequest
10880    {
10881        #[inline(always)]
10882        fn new_empty() -> Self {
10883            Self::default()
10884        }
10885
10886        unsafe fn decode(
10887            &mut self,
10888            decoder: &mut fidl::encoding::Decoder<'_, D>,
10889            offset: usize,
10890            mut depth: fidl::encoding::Depth,
10891        ) -> fidl::Result<()> {
10892            decoder.debug_check_bounds::<Self>(offset);
10893            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10894                None => return Err(fidl::Error::NotNullable),
10895                Some(len) => len,
10896            };
10897            // Calling decoder.out_of_line_offset(0) is not allowed.
10898            if len == 0 {
10899                return Ok(());
10900            };
10901            depth.increment()?;
10902            let envelope_size = 8;
10903            let bytes_len = len * envelope_size;
10904            let offset = decoder.out_of_line_offset(bytes_len)?;
10905            // Decode the envelope for each type.
10906            let mut _next_ordinal_to_read = 0;
10907            let mut next_offset = offset;
10908            let end_offset = offset + bytes_len;
10909            _next_ordinal_to_read += 1;
10910            if next_offset >= end_offset {
10911                return Ok(());
10912            }
10913
10914            // Decode unknown envelopes for gaps in ordinals.
10915            while _next_ordinal_to_read < 1 {
10916                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10917                _next_ordinal_to_read += 1;
10918                next_offset += envelope_size;
10919            }
10920
10921            let next_out_of_line = decoder.next_out_of_line();
10922            let handles_before = decoder.remaining_handles();
10923            if let Some((inlined, num_bytes, num_handles)) =
10924                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10925            {
10926                let member_inline_size =
10927                    <SecureHeapAndRangeModification as fidl::encoding::TypeMarker>::inline_size(
10928                        decoder.context,
10929                    );
10930                if inlined != (member_inline_size <= 4) {
10931                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10932                }
10933                let inner_offset;
10934                let mut inner_depth = depth.clone();
10935                if inlined {
10936                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10937                    inner_offset = next_offset;
10938                } else {
10939                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10940                    inner_depth.increment()?;
10941                }
10942                let val_ref = self
10943                    .range_modification
10944                    .get_or_insert_with(|| fidl::new_empty!(SecureHeapAndRangeModification, D));
10945                fidl::decode!(
10946                    SecureHeapAndRangeModification,
10947                    D,
10948                    val_ref,
10949                    decoder,
10950                    inner_offset,
10951                    inner_depth
10952                )?;
10953                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10954                {
10955                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10956                }
10957                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10958                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10959                }
10960            }
10961
10962            next_offset += envelope_size;
10963
10964            // Decode the remaining unknown envelopes.
10965            while next_offset < end_offset {
10966                _next_ordinal_to_read += 1;
10967                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10968                next_offset += envelope_size;
10969            }
10970
10971            Ok(())
10972        }
10973    }
10974
10975    impl SecureMemZeroSubRangeRequest {
10976        #[inline(always)]
10977        fn max_ordinal_present(&self) -> u64 {
10978            if let Some(_) = self.heap_range {
10979                return 2;
10980            }
10981            if let Some(_) = self.is_covering_range_explicit {
10982                return 1;
10983            }
10984            0
10985        }
10986    }
10987
10988    impl fidl::encoding::ValueTypeMarker for SecureMemZeroSubRangeRequest {
10989        type Borrowed<'a> = &'a Self;
10990        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10991            value
10992        }
10993    }
10994
10995    unsafe impl fidl::encoding::TypeMarker for SecureMemZeroSubRangeRequest {
10996        type Owned = Self;
10997
10998        #[inline(always)]
10999        fn inline_align(_context: fidl::encoding::Context) -> usize {
11000            8
11001        }
11002
11003        #[inline(always)]
11004        fn inline_size(_context: fidl::encoding::Context) -> usize {
11005            16
11006        }
11007    }
11008
11009    unsafe impl<D: fidl::encoding::ResourceDialect>
11010        fidl::encoding::Encode<SecureMemZeroSubRangeRequest, D> for &SecureMemZeroSubRangeRequest
11011    {
11012        unsafe fn encode(
11013            self,
11014            encoder: &mut fidl::encoding::Encoder<'_, D>,
11015            offset: usize,
11016            mut depth: fidl::encoding::Depth,
11017        ) -> fidl::Result<()> {
11018            encoder.debug_check_bounds::<SecureMemZeroSubRangeRequest>(offset);
11019            // Vector header
11020            let max_ordinal: u64 = self.max_ordinal_present();
11021            encoder.write_num(max_ordinal, offset);
11022            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11023            // Calling encoder.out_of_line_offset(0) is not allowed.
11024            if max_ordinal == 0 {
11025                return Ok(());
11026            }
11027            depth.increment()?;
11028            let envelope_size = 8;
11029            let bytes_len = max_ordinal as usize * envelope_size;
11030            #[allow(unused_variables)]
11031            let offset = encoder.out_of_line_offset(bytes_len);
11032            let mut _prev_end_offset: usize = 0;
11033            if 1 > max_ordinal {
11034                return Ok(());
11035            }
11036
11037            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11038            // are envelope_size bytes.
11039            let cur_offset: usize = (1 - 1) * envelope_size;
11040
11041            // Zero reserved fields.
11042            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11043
11044            // Safety:
11045            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11046            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11047            //   envelope_size bytes, there is always sufficient room.
11048            fidl::encoding::encode_in_envelope_optional::<bool, D>(
11049                self.is_covering_range_explicit
11050                    .as_ref()
11051                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
11052                encoder,
11053                offset + cur_offset,
11054                depth,
11055            )?;
11056
11057            _prev_end_offset = cur_offset + envelope_size;
11058            if 2 > max_ordinal {
11059                return Ok(());
11060            }
11061
11062            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11063            // are envelope_size bytes.
11064            let cur_offset: usize = (2 - 1) * envelope_size;
11065
11066            // Zero reserved fields.
11067            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11068
11069            // Safety:
11070            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11071            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11072            //   envelope_size bytes, there is always sufficient room.
11073            fidl::encoding::encode_in_envelope_optional::<SecureHeapAndRange, D>(
11074                self.heap_range
11075                    .as_ref()
11076                    .map(<SecureHeapAndRange as fidl::encoding::ValueTypeMarker>::borrow),
11077                encoder,
11078                offset + cur_offset,
11079                depth,
11080            )?;
11081
11082            _prev_end_offset = cur_offset + envelope_size;
11083
11084            Ok(())
11085        }
11086    }
11087
11088    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11089        for SecureMemZeroSubRangeRequest
11090    {
11091        #[inline(always)]
11092        fn new_empty() -> Self {
11093            Self::default()
11094        }
11095
11096        unsafe fn decode(
11097            &mut self,
11098            decoder: &mut fidl::encoding::Decoder<'_, D>,
11099            offset: usize,
11100            mut depth: fidl::encoding::Depth,
11101        ) -> fidl::Result<()> {
11102            decoder.debug_check_bounds::<Self>(offset);
11103            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11104                None => return Err(fidl::Error::NotNullable),
11105                Some(len) => len,
11106            };
11107            // Calling decoder.out_of_line_offset(0) is not allowed.
11108            if len == 0 {
11109                return Ok(());
11110            };
11111            depth.increment()?;
11112            let envelope_size = 8;
11113            let bytes_len = len * envelope_size;
11114            let offset = decoder.out_of_line_offset(bytes_len)?;
11115            // Decode the envelope for each type.
11116            let mut _next_ordinal_to_read = 0;
11117            let mut next_offset = offset;
11118            let end_offset = offset + bytes_len;
11119            _next_ordinal_to_read += 1;
11120            if next_offset >= end_offset {
11121                return Ok(());
11122            }
11123
11124            // Decode unknown envelopes for gaps in ordinals.
11125            while _next_ordinal_to_read < 1 {
11126                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11127                _next_ordinal_to_read += 1;
11128                next_offset += envelope_size;
11129            }
11130
11131            let next_out_of_line = decoder.next_out_of_line();
11132            let handles_before = decoder.remaining_handles();
11133            if let Some((inlined, num_bytes, num_handles)) =
11134                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11135            {
11136                let member_inline_size =
11137                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11138                if inlined != (member_inline_size <= 4) {
11139                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11140                }
11141                let inner_offset;
11142                let mut inner_depth = depth.clone();
11143                if inlined {
11144                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11145                    inner_offset = next_offset;
11146                } else {
11147                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11148                    inner_depth.increment()?;
11149                }
11150                let val_ref = self
11151                    .is_covering_range_explicit
11152                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
11153                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11154                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11155                {
11156                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11157                }
11158                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11159                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11160                }
11161            }
11162
11163            next_offset += envelope_size;
11164            _next_ordinal_to_read += 1;
11165            if next_offset >= end_offset {
11166                return Ok(());
11167            }
11168
11169            // Decode unknown envelopes for gaps in ordinals.
11170            while _next_ordinal_to_read < 2 {
11171                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11172                _next_ordinal_to_read += 1;
11173                next_offset += envelope_size;
11174            }
11175
11176            let next_out_of_line = decoder.next_out_of_line();
11177            let handles_before = decoder.remaining_handles();
11178            if let Some((inlined, num_bytes, num_handles)) =
11179                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11180            {
11181                let member_inline_size =
11182                    <SecureHeapAndRange as fidl::encoding::TypeMarker>::inline_size(
11183                        decoder.context,
11184                    );
11185                if inlined != (member_inline_size <= 4) {
11186                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11187                }
11188                let inner_offset;
11189                let mut inner_depth = depth.clone();
11190                if inlined {
11191                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11192                    inner_offset = next_offset;
11193                } else {
11194                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11195                    inner_depth.increment()?;
11196                }
11197                let val_ref =
11198                    self.heap_range.get_or_insert_with(|| fidl::new_empty!(SecureHeapAndRange, D));
11199                fidl::decode!(SecureHeapAndRange, D, val_ref, decoder, inner_offset, inner_depth)?;
11200                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11201                {
11202                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11203                }
11204                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11205                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11206                }
11207            }
11208
11209            next_offset += envelope_size;
11210
11211            // Decode the remaining unknown envelopes.
11212            while next_offset < end_offset {
11213                _next_ordinal_to_read += 1;
11214                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11215                next_offset += envelope_size;
11216            }
11217
11218            Ok(())
11219        }
11220    }
11221
11222    impl SecureMemGetDynamicSecureHeapsResponse {
11223        #[inline(always)]
11224        fn max_ordinal_present(&self) -> u64 {
11225            if let Some(_) = self.heaps {
11226                return 1;
11227            }
11228            0
11229        }
11230    }
11231
11232    impl fidl::encoding::ValueTypeMarker for SecureMemGetDynamicSecureHeapsResponse {
11233        type Borrowed<'a> = &'a Self;
11234        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11235            value
11236        }
11237    }
11238
11239    unsafe impl fidl::encoding::TypeMarker for SecureMemGetDynamicSecureHeapsResponse {
11240        type Owned = Self;
11241
11242        #[inline(always)]
11243        fn inline_align(_context: fidl::encoding::Context) -> usize {
11244            8
11245        }
11246
11247        #[inline(always)]
11248        fn inline_size(_context: fidl::encoding::Context) -> usize {
11249            16
11250        }
11251    }
11252
11253    unsafe impl<D: fidl::encoding::ResourceDialect>
11254        fidl::encoding::Encode<SecureMemGetDynamicSecureHeapsResponse, D>
11255        for &SecureMemGetDynamicSecureHeapsResponse
11256    {
11257        unsafe fn encode(
11258            self,
11259            encoder: &mut fidl::encoding::Encoder<'_, D>,
11260            offset: usize,
11261            mut depth: fidl::encoding::Depth,
11262        ) -> fidl::Result<()> {
11263            encoder.debug_check_bounds::<SecureMemGetDynamicSecureHeapsResponse>(offset);
11264            // Vector header
11265            let max_ordinal: u64 = self.max_ordinal_present();
11266            encoder.write_num(max_ordinal, offset);
11267            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11268            // Calling encoder.out_of_line_offset(0) is not allowed.
11269            if max_ordinal == 0 {
11270                return Ok(());
11271            }
11272            depth.increment()?;
11273            let envelope_size = 8;
11274            let bytes_len = max_ordinal as usize * envelope_size;
11275            #[allow(unused_variables)]
11276            let offset = encoder.out_of_line_offset(bytes_len);
11277            let mut _prev_end_offset: usize = 0;
11278            if 1 > max_ordinal {
11279                return Ok(());
11280            }
11281
11282            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11283            // are envelope_size bytes.
11284            let cur_offset: usize = (1 - 1) * envelope_size;
11285
11286            // Zero reserved fields.
11287            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11288
11289            // Safety:
11290            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11291            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11292            //   envelope_size bytes, there is always sufficient room.
11293            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<DynamicSecureHeap, 32>, D>(
11294            self.heaps.as_ref().map(<fidl::encoding::Vector<DynamicSecureHeap, 32> as fidl::encoding::ValueTypeMarker>::borrow),
11295            encoder, offset + cur_offset, depth
11296        )?;
11297
11298            _prev_end_offset = cur_offset + envelope_size;
11299
11300            Ok(())
11301        }
11302    }
11303
11304    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11305        for SecureMemGetDynamicSecureHeapsResponse
11306    {
11307        #[inline(always)]
11308        fn new_empty() -> Self {
11309            Self::default()
11310        }
11311
11312        unsafe fn decode(
11313            &mut self,
11314            decoder: &mut fidl::encoding::Decoder<'_, D>,
11315            offset: usize,
11316            mut depth: fidl::encoding::Depth,
11317        ) -> fidl::Result<()> {
11318            decoder.debug_check_bounds::<Self>(offset);
11319            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11320                None => return Err(fidl::Error::NotNullable),
11321                Some(len) => len,
11322            };
11323            // Calling decoder.out_of_line_offset(0) is not allowed.
11324            if len == 0 {
11325                return Ok(());
11326            };
11327            depth.increment()?;
11328            let envelope_size = 8;
11329            let bytes_len = len * envelope_size;
11330            let offset = decoder.out_of_line_offset(bytes_len)?;
11331            // Decode the envelope for each type.
11332            let mut _next_ordinal_to_read = 0;
11333            let mut next_offset = offset;
11334            let end_offset = offset + bytes_len;
11335            _next_ordinal_to_read += 1;
11336            if next_offset >= end_offset {
11337                return Ok(());
11338            }
11339
11340            // Decode unknown envelopes for gaps in ordinals.
11341            while _next_ordinal_to_read < 1 {
11342                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11343                _next_ordinal_to_read += 1;
11344                next_offset += envelope_size;
11345            }
11346
11347            let next_out_of_line = decoder.next_out_of_line();
11348            let handles_before = decoder.remaining_handles();
11349            if let Some((inlined, num_bytes, num_handles)) =
11350                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11351            {
11352                let member_inline_size = <fidl::encoding::Vector<DynamicSecureHeap, 32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11353                if inlined != (member_inline_size <= 4) {
11354                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11355                }
11356                let inner_offset;
11357                let mut inner_depth = depth.clone();
11358                if inlined {
11359                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11360                    inner_offset = next_offset;
11361                } else {
11362                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11363                    inner_depth.increment()?;
11364                }
11365                let val_ref = self.heaps.get_or_insert_with(
11366                    || fidl::new_empty!(fidl::encoding::Vector<DynamicSecureHeap, 32>, D),
11367                );
11368                fidl::decode!(fidl::encoding::Vector<DynamicSecureHeap, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
11369                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11370                {
11371                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11372                }
11373                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11374                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11375                }
11376            }
11377
11378            next_offset += envelope_size;
11379
11380            // Decode the remaining unknown envelopes.
11381            while next_offset < end_offset {
11382                _next_ordinal_to_read += 1;
11383                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11384                next_offset += envelope_size;
11385            }
11386
11387            Ok(())
11388        }
11389    }
11390
11391    impl SecureMemGetPhysicalSecureHeapPropertiesResponse {
11392        #[inline(always)]
11393        fn max_ordinal_present(&self) -> u64 {
11394            if let Some(_) = self.properties {
11395                return 1;
11396            }
11397            0
11398        }
11399    }
11400
11401    impl fidl::encoding::ValueTypeMarker for SecureMemGetPhysicalSecureHeapPropertiesResponse {
11402        type Borrowed<'a> = &'a Self;
11403        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11404            value
11405        }
11406    }
11407
11408    unsafe impl fidl::encoding::TypeMarker for SecureMemGetPhysicalSecureHeapPropertiesResponse {
11409        type Owned = Self;
11410
11411        #[inline(always)]
11412        fn inline_align(_context: fidl::encoding::Context) -> usize {
11413            8
11414        }
11415
11416        #[inline(always)]
11417        fn inline_size(_context: fidl::encoding::Context) -> usize {
11418            16
11419        }
11420    }
11421
11422    unsafe impl<D: fidl::encoding::ResourceDialect>
11423        fidl::encoding::Encode<SecureMemGetPhysicalSecureHeapPropertiesResponse, D>
11424        for &SecureMemGetPhysicalSecureHeapPropertiesResponse
11425    {
11426        unsafe fn encode(
11427            self,
11428            encoder: &mut fidl::encoding::Encoder<'_, D>,
11429            offset: usize,
11430            mut depth: fidl::encoding::Depth,
11431        ) -> fidl::Result<()> {
11432            encoder.debug_check_bounds::<SecureMemGetPhysicalSecureHeapPropertiesResponse>(offset);
11433            // Vector header
11434            let max_ordinal: u64 = self.max_ordinal_present();
11435            encoder.write_num(max_ordinal, offset);
11436            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11437            // Calling encoder.out_of_line_offset(0) is not allowed.
11438            if max_ordinal == 0 {
11439                return Ok(());
11440            }
11441            depth.increment()?;
11442            let envelope_size = 8;
11443            let bytes_len = max_ordinal as usize * envelope_size;
11444            #[allow(unused_variables)]
11445            let offset = encoder.out_of_line_offset(bytes_len);
11446            let mut _prev_end_offset: usize = 0;
11447            if 1 > max_ordinal {
11448                return Ok(());
11449            }
11450
11451            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11452            // are envelope_size bytes.
11453            let cur_offset: usize = (1 - 1) * envelope_size;
11454
11455            // Zero reserved fields.
11456            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11457
11458            // Safety:
11459            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11460            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11461            //   envelope_size bytes, there is always sufficient room.
11462            fidl::encoding::encode_in_envelope_optional::<SecureHeapProperties, D>(
11463                self.properties
11464                    .as_ref()
11465                    .map(<SecureHeapProperties as fidl::encoding::ValueTypeMarker>::borrow),
11466                encoder,
11467                offset + cur_offset,
11468                depth,
11469            )?;
11470
11471            _prev_end_offset = cur_offset + envelope_size;
11472
11473            Ok(())
11474        }
11475    }
11476
11477    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11478        for SecureMemGetPhysicalSecureHeapPropertiesResponse
11479    {
11480        #[inline(always)]
11481        fn new_empty() -> Self {
11482            Self::default()
11483        }
11484
11485        unsafe fn decode(
11486            &mut self,
11487            decoder: &mut fidl::encoding::Decoder<'_, D>,
11488            offset: usize,
11489            mut depth: fidl::encoding::Depth,
11490        ) -> fidl::Result<()> {
11491            decoder.debug_check_bounds::<Self>(offset);
11492            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11493                None => return Err(fidl::Error::NotNullable),
11494                Some(len) => len,
11495            };
11496            // Calling decoder.out_of_line_offset(0) is not allowed.
11497            if len == 0 {
11498                return Ok(());
11499            };
11500            depth.increment()?;
11501            let envelope_size = 8;
11502            let bytes_len = len * envelope_size;
11503            let offset = decoder.out_of_line_offset(bytes_len)?;
11504            // Decode the envelope for each type.
11505            let mut _next_ordinal_to_read = 0;
11506            let mut next_offset = offset;
11507            let end_offset = offset + bytes_len;
11508            _next_ordinal_to_read += 1;
11509            if next_offset >= end_offset {
11510                return Ok(());
11511            }
11512
11513            // Decode unknown envelopes for gaps in ordinals.
11514            while _next_ordinal_to_read < 1 {
11515                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11516                _next_ordinal_to_read += 1;
11517                next_offset += envelope_size;
11518            }
11519
11520            let next_out_of_line = decoder.next_out_of_line();
11521            let handles_before = decoder.remaining_handles();
11522            if let Some((inlined, num_bytes, num_handles)) =
11523                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11524            {
11525                let member_inline_size =
11526                    <SecureHeapProperties as fidl::encoding::TypeMarker>::inline_size(
11527                        decoder.context,
11528                    );
11529                if inlined != (member_inline_size <= 4) {
11530                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11531                }
11532                let inner_offset;
11533                let mut inner_depth = depth.clone();
11534                if inlined {
11535                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11536                    inner_offset = next_offset;
11537                } else {
11538                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11539                    inner_depth.increment()?;
11540                }
11541                let val_ref = self
11542                    .properties
11543                    .get_or_insert_with(|| fidl::new_empty!(SecureHeapProperties, D));
11544                fidl::decode!(
11545                    SecureHeapProperties,
11546                    D,
11547                    val_ref,
11548                    decoder,
11549                    inner_offset,
11550                    inner_depth
11551                )?;
11552                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11553                {
11554                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11555                }
11556                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11557                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11558                }
11559            }
11560
11561            next_offset += envelope_size;
11562
11563            // Decode the remaining unknown envelopes.
11564            while next_offset < end_offset {
11565                _next_ordinal_to_read += 1;
11566                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11567                next_offset += envelope_size;
11568            }
11569
11570            Ok(())
11571        }
11572    }
11573
11574    impl SecureMemGetPhysicalSecureHeapsResponse {
11575        #[inline(always)]
11576        fn max_ordinal_present(&self) -> u64 {
11577            if let Some(_) = self.heaps {
11578                return 1;
11579            }
11580            0
11581        }
11582    }
11583
11584    impl fidl::encoding::ValueTypeMarker for SecureMemGetPhysicalSecureHeapsResponse {
11585        type Borrowed<'a> = &'a Self;
11586        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11587            value
11588        }
11589    }
11590
11591    unsafe impl fidl::encoding::TypeMarker for SecureMemGetPhysicalSecureHeapsResponse {
11592        type Owned = Self;
11593
11594        #[inline(always)]
11595        fn inline_align(_context: fidl::encoding::Context) -> usize {
11596            8
11597        }
11598
11599        #[inline(always)]
11600        fn inline_size(_context: fidl::encoding::Context) -> usize {
11601            16
11602        }
11603    }
11604
11605    unsafe impl<D: fidl::encoding::ResourceDialect>
11606        fidl::encoding::Encode<SecureMemGetPhysicalSecureHeapsResponse, D>
11607        for &SecureMemGetPhysicalSecureHeapsResponse
11608    {
11609        unsafe fn encode(
11610            self,
11611            encoder: &mut fidl::encoding::Encoder<'_, D>,
11612            offset: usize,
11613            mut depth: fidl::encoding::Depth,
11614        ) -> fidl::Result<()> {
11615            encoder.debug_check_bounds::<SecureMemGetPhysicalSecureHeapsResponse>(offset);
11616            // Vector header
11617            let max_ordinal: u64 = self.max_ordinal_present();
11618            encoder.write_num(max_ordinal, offset);
11619            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11620            // Calling encoder.out_of_line_offset(0) is not allowed.
11621            if max_ordinal == 0 {
11622                return Ok(());
11623            }
11624            depth.increment()?;
11625            let envelope_size = 8;
11626            let bytes_len = max_ordinal as usize * envelope_size;
11627            #[allow(unused_variables)]
11628            let offset = encoder.out_of_line_offset(bytes_len);
11629            let mut _prev_end_offset: usize = 0;
11630            if 1 > max_ordinal {
11631                return Ok(());
11632            }
11633
11634            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11635            // are envelope_size bytes.
11636            let cur_offset: usize = (1 - 1) * envelope_size;
11637
11638            // Zero reserved fields.
11639            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11640
11641            // Safety:
11642            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11643            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11644            //   envelope_size bytes, there is always sufficient room.
11645            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<SecureHeapAndRanges, 32>, D>(
11646            self.heaps.as_ref().map(<fidl::encoding::Vector<SecureHeapAndRanges, 32> as fidl::encoding::ValueTypeMarker>::borrow),
11647            encoder, offset + cur_offset, depth
11648        )?;
11649
11650            _prev_end_offset = cur_offset + envelope_size;
11651
11652            Ok(())
11653        }
11654    }
11655
11656    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11657        for SecureMemGetPhysicalSecureHeapsResponse
11658    {
11659        #[inline(always)]
11660        fn new_empty() -> Self {
11661            Self::default()
11662        }
11663
11664        unsafe fn decode(
11665            &mut self,
11666            decoder: &mut fidl::encoding::Decoder<'_, D>,
11667            offset: usize,
11668            mut depth: fidl::encoding::Depth,
11669        ) -> fidl::Result<()> {
11670            decoder.debug_check_bounds::<Self>(offset);
11671            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11672                None => return Err(fidl::Error::NotNullable),
11673                Some(len) => len,
11674            };
11675            // Calling decoder.out_of_line_offset(0) is not allowed.
11676            if len == 0 {
11677                return Ok(());
11678            };
11679            depth.increment()?;
11680            let envelope_size = 8;
11681            let bytes_len = len * envelope_size;
11682            let offset = decoder.out_of_line_offset(bytes_len)?;
11683            // Decode the envelope for each type.
11684            let mut _next_ordinal_to_read = 0;
11685            let mut next_offset = offset;
11686            let end_offset = offset + bytes_len;
11687            _next_ordinal_to_read += 1;
11688            if next_offset >= end_offset {
11689                return Ok(());
11690            }
11691
11692            // Decode unknown envelopes for gaps in ordinals.
11693            while _next_ordinal_to_read < 1 {
11694                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11695                _next_ordinal_to_read += 1;
11696                next_offset += envelope_size;
11697            }
11698
11699            let next_out_of_line = decoder.next_out_of_line();
11700            let handles_before = decoder.remaining_handles();
11701            if let Some((inlined, num_bytes, num_handles)) =
11702                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11703            {
11704                let member_inline_size = <fidl::encoding::Vector<SecureHeapAndRanges, 32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11705                if inlined != (member_inline_size <= 4) {
11706                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11707                }
11708                let inner_offset;
11709                let mut inner_depth = depth.clone();
11710                if inlined {
11711                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11712                    inner_offset = next_offset;
11713                } else {
11714                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11715                    inner_depth.increment()?;
11716                }
11717                let val_ref = self.heaps.get_or_insert_with(
11718                    || fidl::new_empty!(fidl::encoding::Vector<SecureHeapAndRanges, 32>, D),
11719                );
11720                fidl::decode!(fidl::encoding::Vector<SecureHeapAndRanges, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
11721                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11722                {
11723                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11724                }
11725                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11726                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11727                }
11728            }
11729
11730            next_offset += envelope_size;
11731
11732            // Decode the remaining unknown envelopes.
11733            while next_offset < end_offset {
11734                _next_ordinal_to_read += 1;
11735                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11736                next_offset += envelope_size;
11737            }
11738
11739            Ok(())
11740        }
11741    }
11742
11743    impl SingleBufferSettings {
11744        #[inline(always)]
11745        fn max_ordinal_present(&self) -> u64 {
11746            if let Some(_) = self.image_format_constraints {
11747                return 2;
11748            }
11749            if let Some(_) = self.buffer_settings {
11750                return 1;
11751            }
11752            0
11753        }
11754    }
11755
11756    impl fidl::encoding::ValueTypeMarker for SingleBufferSettings {
11757        type Borrowed<'a> = &'a Self;
11758        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11759            value
11760        }
11761    }
11762
11763    unsafe impl fidl::encoding::TypeMarker for SingleBufferSettings {
11764        type Owned = Self;
11765
11766        #[inline(always)]
11767        fn inline_align(_context: fidl::encoding::Context) -> usize {
11768            8
11769        }
11770
11771        #[inline(always)]
11772        fn inline_size(_context: fidl::encoding::Context) -> usize {
11773            16
11774        }
11775    }
11776
11777    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SingleBufferSettings, D>
11778        for &SingleBufferSettings
11779    {
11780        unsafe fn encode(
11781            self,
11782            encoder: &mut fidl::encoding::Encoder<'_, D>,
11783            offset: usize,
11784            mut depth: fidl::encoding::Depth,
11785        ) -> fidl::Result<()> {
11786            encoder.debug_check_bounds::<SingleBufferSettings>(offset);
11787            // Vector header
11788            let max_ordinal: u64 = self.max_ordinal_present();
11789            encoder.write_num(max_ordinal, offset);
11790            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11791            // Calling encoder.out_of_line_offset(0) is not allowed.
11792            if max_ordinal == 0 {
11793                return Ok(());
11794            }
11795            depth.increment()?;
11796            let envelope_size = 8;
11797            let bytes_len = max_ordinal as usize * envelope_size;
11798            #[allow(unused_variables)]
11799            let offset = encoder.out_of_line_offset(bytes_len);
11800            let mut _prev_end_offset: usize = 0;
11801            if 1 > max_ordinal {
11802                return Ok(());
11803            }
11804
11805            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11806            // are envelope_size bytes.
11807            let cur_offset: usize = (1 - 1) * envelope_size;
11808
11809            // Zero reserved fields.
11810            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11811
11812            // Safety:
11813            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11814            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11815            //   envelope_size bytes, there is always sufficient room.
11816            fidl::encoding::encode_in_envelope_optional::<BufferMemorySettings, D>(
11817                self.buffer_settings
11818                    .as_ref()
11819                    .map(<BufferMemorySettings as fidl::encoding::ValueTypeMarker>::borrow),
11820                encoder,
11821                offset + cur_offset,
11822                depth,
11823            )?;
11824
11825            _prev_end_offset = cur_offset + envelope_size;
11826            if 2 > max_ordinal {
11827                return Ok(());
11828            }
11829
11830            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11831            // are envelope_size bytes.
11832            let cur_offset: usize = (2 - 1) * envelope_size;
11833
11834            // Zero reserved fields.
11835            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11836
11837            // Safety:
11838            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11839            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11840            //   envelope_size bytes, there is always sufficient room.
11841            fidl::encoding::encode_in_envelope_optional::<ImageFormatConstraints, D>(
11842                self.image_format_constraints
11843                    .as_ref()
11844                    .map(<ImageFormatConstraints as fidl::encoding::ValueTypeMarker>::borrow),
11845                encoder,
11846                offset + cur_offset,
11847                depth,
11848            )?;
11849
11850            _prev_end_offset = cur_offset + envelope_size;
11851
11852            Ok(())
11853        }
11854    }
11855
11856    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SingleBufferSettings {
11857        #[inline(always)]
11858        fn new_empty() -> Self {
11859            Self::default()
11860        }
11861
11862        unsafe fn decode(
11863            &mut self,
11864            decoder: &mut fidl::encoding::Decoder<'_, D>,
11865            offset: usize,
11866            mut depth: fidl::encoding::Depth,
11867        ) -> fidl::Result<()> {
11868            decoder.debug_check_bounds::<Self>(offset);
11869            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11870                None => return Err(fidl::Error::NotNullable),
11871                Some(len) => len,
11872            };
11873            // Calling decoder.out_of_line_offset(0) is not allowed.
11874            if len == 0 {
11875                return Ok(());
11876            };
11877            depth.increment()?;
11878            let envelope_size = 8;
11879            let bytes_len = len * envelope_size;
11880            let offset = decoder.out_of_line_offset(bytes_len)?;
11881            // Decode the envelope for each type.
11882            let mut _next_ordinal_to_read = 0;
11883            let mut next_offset = offset;
11884            let end_offset = offset + bytes_len;
11885            _next_ordinal_to_read += 1;
11886            if next_offset >= end_offset {
11887                return Ok(());
11888            }
11889
11890            // Decode unknown envelopes for gaps in ordinals.
11891            while _next_ordinal_to_read < 1 {
11892                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11893                _next_ordinal_to_read += 1;
11894                next_offset += envelope_size;
11895            }
11896
11897            let next_out_of_line = decoder.next_out_of_line();
11898            let handles_before = decoder.remaining_handles();
11899            if let Some((inlined, num_bytes, num_handles)) =
11900                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11901            {
11902                let member_inline_size =
11903                    <BufferMemorySettings as fidl::encoding::TypeMarker>::inline_size(
11904                        decoder.context,
11905                    );
11906                if inlined != (member_inline_size <= 4) {
11907                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11908                }
11909                let inner_offset;
11910                let mut inner_depth = depth.clone();
11911                if inlined {
11912                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11913                    inner_offset = next_offset;
11914                } else {
11915                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11916                    inner_depth.increment()?;
11917                }
11918                let val_ref = self
11919                    .buffer_settings
11920                    .get_or_insert_with(|| fidl::new_empty!(BufferMemorySettings, D));
11921                fidl::decode!(
11922                    BufferMemorySettings,
11923                    D,
11924                    val_ref,
11925                    decoder,
11926                    inner_offset,
11927                    inner_depth
11928                )?;
11929                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11930                {
11931                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11932                }
11933                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11934                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11935                }
11936            }
11937
11938            next_offset += envelope_size;
11939            _next_ordinal_to_read += 1;
11940            if next_offset >= end_offset {
11941                return Ok(());
11942            }
11943
11944            // Decode unknown envelopes for gaps in ordinals.
11945            while _next_ordinal_to_read < 2 {
11946                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11947                _next_ordinal_to_read += 1;
11948                next_offset += envelope_size;
11949            }
11950
11951            let next_out_of_line = decoder.next_out_of_line();
11952            let handles_before = decoder.remaining_handles();
11953            if let Some((inlined, num_bytes, num_handles)) =
11954                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11955            {
11956                let member_inline_size =
11957                    <ImageFormatConstraints as fidl::encoding::TypeMarker>::inline_size(
11958                        decoder.context,
11959                    );
11960                if inlined != (member_inline_size <= 4) {
11961                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11962                }
11963                let inner_offset;
11964                let mut inner_depth = depth.clone();
11965                if inlined {
11966                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11967                    inner_offset = next_offset;
11968                } else {
11969                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11970                    inner_depth.increment()?;
11971                }
11972                let val_ref = self
11973                    .image_format_constraints
11974                    .get_or_insert_with(|| fidl::new_empty!(ImageFormatConstraints, D));
11975                fidl::decode!(
11976                    ImageFormatConstraints,
11977                    D,
11978                    val_ref,
11979                    decoder,
11980                    inner_offset,
11981                    inner_depth
11982                )?;
11983                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11984                {
11985                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11986                }
11987                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11988                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11989                }
11990            }
11991
11992            next_offset += envelope_size;
11993
11994            // Decode the remaining unknown envelopes.
11995            while next_offset < end_offset {
11996                _next_ordinal_to_read += 1;
11997                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11998                next_offset += envelope_size;
11999            }
12000
12001            Ok(())
12002        }
12003    }
12004}