fidl_fuchsia_hwinfo__common/
fidl_fuchsia_hwinfo__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 MAX_VALUE_SIZE: u8 = 255;
12
13#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
14pub enum Architecture {
15    X64,
16    Arm64,
17    #[doc(hidden)]
18    __SourceBreaking {
19        unknown_ordinal: u32,
20    },
21}
22
23/// Pattern that matches an unknown `Architecture` member.
24#[macro_export]
25macro_rules! ArchitectureUnknown {
26    () => {
27        _
28    };
29}
30
31impl Architecture {
32    #[inline]
33    pub fn from_primitive(prim: u32) -> Option<Self> {
34        match prim {
35            1 => Some(Self::X64),
36            2 => Some(Self::Arm64),
37            _ => None,
38        }
39    }
40
41    #[inline]
42    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
43        match prim {
44            1 => Self::X64,
45            2 => Self::Arm64,
46            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
47        }
48    }
49
50    #[inline]
51    pub fn unknown() -> Self {
52        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
53    }
54
55    #[inline]
56    pub const fn into_primitive(self) -> u32 {
57        match self {
58            Self::X64 => 1,
59            Self::Arm64 => 2,
60            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
61        }
62    }
63
64    #[inline]
65    pub fn is_unknown(&self) -> bool {
66        match self {
67            Self::__SourceBreaking { unknown_ordinal: _ } => true,
68            _ => false,
69        }
70    }
71}
72
73#[derive(Clone, Debug, PartialEq)]
74pub struct BoardGetInfoResponse {
75    pub info: BoardInfo,
76}
77
78impl fidl::Persistable for BoardGetInfoResponse {}
79
80#[derive(Clone, Debug, PartialEq)]
81pub struct DeviceGetInfoResponse {
82    pub info: DeviceInfo,
83}
84
85impl fidl::Persistable for DeviceGetInfoResponse {}
86
87#[derive(Clone, Debug, PartialEq)]
88pub struct ProductGetInfoResponse {
89    pub info: ProductInfo,
90}
91
92impl fidl::Persistable for ProductGetInfoResponse {}
93
94/// Collection of properties that are common among a set of devices based on
95/// hardware type
96#[derive(Clone, Debug, Default, PartialEq)]
97pub struct BoardInfo {
98    pub name: Option<String>,
99    pub revision: Option<String>,
100    pub cpu_architecture: Option<Architecture>,
101    #[doc(hidden)]
102    pub __source_breaking: fidl::marker::SourceBreaking,
103}
104
105impl fidl::Persistable for BoardInfo {}
106
107/// Collection of properties that is unique per device.
108#[derive(Clone, Debug, Default, PartialEq)]
109pub struct DeviceInfo {
110    pub serial_number: Option<String>,
111    pub is_retail_demo: Option<bool>,
112    pub retail_sku: Option<String>,
113    #[doc(hidden)]
114    pub __source_breaking: fidl::marker::SourceBreaking,
115}
116
117impl fidl::Persistable for DeviceInfo {}
118
119/// Collection of properties that is shared with other devices within the same
120/// product line.
121#[derive(Clone, Debug, Default, PartialEq)]
122pub struct ProductInfo {
123    pub sku: Option<String>,
124    pub language: Option<String>,
125    pub regulatory_domain: Option<fidl_fuchsia_intl__common::RegulatoryDomain>,
126    pub locale_list: Option<Vec<fidl_fuchsia_intl__common::LocaleId>>,
127    pub name: Option<String>,
128    pub model: Option<String>,
129    pub manufacturer: Option<String>,
130    pub build_date: Option<String>,
131    pub build_name: Option<String>,
132    pub colorway: Option<String>,
133    pub display: Option<String>,
134    pub memory: Option<String>,
135    pub nand_storage: Option<String>,
136    pub emmc_storage: Option<String>,
137    pub microphone: Option<String>,
138    pub audio_amplifier: Option<String>,
139    #[doc(hidden)]
140    pub __source_breaking: fidl::marker::SourceBreaking,
141}
142
143impl fidl::Persistable for ProductInfo {}
144
145pub mod board_ordinals {
146    pub const GET_INFO: u64 = 0x878a093531d0904;
147}
148
149pub mod device_ordinals {
150    pub const GET_INFO: u64 = 0x4cc66c5e52b0a7d1;
151}
152
153pub mod product_ordinals {
154    pub const GET_INFO: u64 = 0x11a4825cda315828;
155}
156
157mod internal {
158    use super::*;
159    unsafe impl fidl::encoding::TypeMarker for Architecture {
160        type Owned = Self;
161
162        #[inline(always)]
163        fn inline_align(_context: fidl::encoding::Context) -> usize {
164            std::mem::align_of::<u32>()
165        }
166
167        #[inline(always)]
168        fn inline_size(_context: fidl::encoding::Context) -> usize {
169            std::mem::size_of::<u32>()
170        }
171
172        #[inline(always)]
173        fn encode_is_copy() -> bool {
174            false
175        }
176
177        #[inline(always)]
178        fn decode_is_copy() -> bool {
179            false
180        }
181    }
182
183    impl fidl::encoding::ValueTypeMarker for Architecture {
184        type Borrowed<'a> = Self;
185        #[inline(always)]
186        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
187            *value
188        }
189    }
190
191    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Architecture {
192        #[inline]
193        unsafe fn encode(
194            self,
195            encoder: &mut fidl::encoding::Encoder<'_, D>,
196            offset: usize,
197            _depth: fidl::encoding::Depth,
198        ) -> fidl::Result<()> {
199            encoder.debug_check_bounds::<Self>(offset);
200            encoder.write_num(self.into_primitive(), offset);
201            Ok(())
202        }
203    }
204
205    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Architecture {
206        #[inline(always)]
207        fn new_empty() -> Self {
208            Self::unknown()
209        }
210
211        #[inline]
212        unsafe fn decode(
213            &mut self,
214            decoder: &mut fidl::encoding::Decoder<'_, D>,
215            offset: usize,
216            _depth: fidl::encoding::Depth,
217        ) -> fidl::Result<()> {
218            decoder.debug_check_bounds::<Self>(offset);
219            let prim = decoder.read_num::<u32>(offset);
220
221            *self = Self::from_primitive_allow_unknown(prim);
222            Ok(())
223        }
224    }
225
226    impl fidl::encoding::ValueTypeMarker for BoardGetInfoResponse {
227        type Borrowed<'a> = &'a Self;
228        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
229            value
230        }
231    }
232
233    unsafe impl fidl::encoding::TypeMarker for BoardGetInfoResponse {
234        type Owned = Self;
235
236        #[inline(always)]
237        fn inline_align(_context: fidl::encoding::Context) -> usize {
238            8
239        }
240
241        #[inline(always)]
242        fn inline_size(_context: fidl::encoding::Context) -> usize {
243            16
244        }
245    }
246
247    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BoardGetInfoResponse, D>
248        for &BoardGetInfoResponse
249    {
250        #[inline]
251        unsafe fn encode(
252            self,
253            encoder: &mut fidl::encoding::Encoder<'_, D>,
254            offset: usize,
255            _depth: fidl::encoding::Depth,
256        ) -> fidl::Result<()> {
257            encoder.debug_check_bounds::<BoardGetInfoResponse>(offset);
258            // Delegate to tuple encoding.
259            fidl::encoding::Encode::<BoardGetInfoResponse, D>::encode(
260                (<BoardInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
261                encoder,
262                offset,
263                _depth,
264            )
265        }
266    }
267    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BoardInfo, D>>
268        fidl::encoding::Encode<BoardGetInfoResponse, D> for (T0,)
269    {
270        #[inline]
271        unsafe fn encode(
272            self,
273            encoder: &mut fidl::encoding::Encoder<'_, D>,
274            offset: usize,
275            depth: fidl::encoding::Depth,
276        ) -> fidl::Result<()> {
277            encoder.debug_check_bounds::<BoardGetInfoResponse>(offset);
278            // Zero out padding regions. There's no need to apply masks
279            // because the unmasked parts will be overwritten by fields.
280            // Write the fields.
281            self.0.encode(encoder, offset + 0, depth)?;
282            Ok(())
283        }
284    }
285
286    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BoardGetInfoResponse {
287        #[inline(always)]
288        fn new_empty() -> Self {
289            Self { info: fidl::new_empty!(BoardInfo, D) }
290        }
291
292        #[inline]
293        unsafe fn decode(
294            &mut self,
295            decoder: &mut fidl::encoding::Decoder<'_, D>,
296            offset: usize,
297            _depth: fidl::encoding::Depth,
298        ) -> fidl::Result<()> {
299            decoder.debug_check_bounds::<Self>(offset);
300            // Verify that padding bytes are zero.
301            fidl::decode!(BoardInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
302            Ok(())
303        }
304    }
305
306    impl fidl::encoding::ValueTypeMarker for DeviceGetInfoResponse {
307        type Borrowed<'a> = &'a Self;
308        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
309            value
310        }
311    }
312
313    unsafe impl fidl::encoding::TypeMarker for DeviceGetInfoResponse {
314        type Owned = Self;
315
316        #[inline(always)]
317        fn inline_align(_context: fidl::encoding::Context) -> usize {
318            8
319        }
320
321        #[inline(always)]
322        fn inline_size(_context: fidl::encoding::Context) -> usize {
323            16
324        }
325    }
326
327    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceGetInfoResponse, D>
328        for &DeviceGetInfoResponse
329    {
330        #[inline]
331        unsafe fn encode(
332            self,
333            encoder: &mut fidl::encoding::Encoder<'_, D>,
334            offset: usize,
335            _depth: fidl::encoding::Depth,
336        ) -> fidl::Result<()> {
337            encoder.debug_check_bounds::<DeviceGetInfoResponse>(offset);
338            // Delegate to tuple encoding.
339            fidl::encoding::Encode::<DeviceGetInfoResponse, D>::encode(
340                (<DeviceInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
341                encoder,
342                offset,
343                _depth,
344            )
345        }
346    }
347    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<DeviceInfo, D>>
348        fidl::encoding::Encode<DeviceGetInfoResponse, D> for (T0,)
349    {
350        #[inline]
351        unsafe fn encode(
352            self,
353            encoder: &mut fidl::encoding::Encoder<'_, D>,
354            offset: usize,
355            depth: fidl::encoding::Depth,
356        ) -> fidl::Result<()> {
357            encoder.debug_check_bounds::<DeviceGetInfoResponse>(offset);
358            // Zero out padding regions. There's no need to apply masks
359            // because the unmasked parts will be overwritten by fields.
360            // Write the fields.
361            self.0.encode(encoder, offset + 0, depth)?;
362            Ok(())
363        }
364    }
365
366    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceGetInfoResponse {
367        #[inline(always)]
368        fn new_empty() -> Self {
369            Self { info: fidl::new_empty!(DeviceInfo, D) }
370        }
371
372        #[inline]
373        unsafe fn decode(
374            &mut self,
375            decoder: &mut fidl::encoding::Decoder<'_, D>,
376            offset: usize,
377            _depth: fidl::encoding::Depth,
378        ) -> fidl::Result<()> {
379            decoder.debug_check_bounds::<Self>(offset);
380            // Verify that padding bytes are zero.
381            fidl::decode!(DeviceInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
382            Ok(())
383        }
384    }
385
386    impl fidl::encoding::ValueTypeMarker for ProductGetInfoResponse {
387        type Borrowed<'a> = &'a Self;
388        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
389            value
390        }
391    }
392
393    unsafe impl fidl::encoding::TypeMarker for ProductGetInfoResponse {
394        type Owned = Self;
395
396        #[inline(always)]
397        fn inline_align(_context: fidl::encoding::Context) -> usize {
398            8
399        }
400
401        #[inline(always)]
402        fn inline_size(_context: fidl::encoding::Context) -> usize {
403            16
404        }
405    }
406
407    unsafe impl<D: fidl::encoding::ResourceDialect>
408        fidl::encoding::Encode<ProductGetInfoResponse, D> for &ProductGetInfoResponse
409    {
410        #[inline]
411        unsafe fn encode(
412            self,
413            encoder: &mut fidl::encoding::Encoder<'_, D>,
414            offset: usize,
415            _depth: fidl::encoding::Depth,
416        ) -> fidl::Result<()> {
417            encoder.debug_check_bounds::<ProductGetInfoResponse>(offset);
418            // Delegate to tuple encoding.
419            fidl::encoding::Encode::<ProductGetInfoResponse, D>::encode(
420                (<ProductInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
421                encoder,
422                offset,
423                _depth,
424            )
425        }
426    }
427    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ProductInfo, D>>
428        fidl::encoding::Encode<ProductGetInfoResponse, D> for (T0,)
429    {
430        #[inline]
431        unsafe fn encode(
432            self,
433            encoder: &mut fidl::encoding::Encoder<'_, D>,
434            offset: usize,
435            depth: fidl::encoding::Depth,
436        ) -> fidl::Result<()> {
437            encoder.debug_check_bounds::<ProductGetInfoResponse>(offset);
438            // Zero out padding regions. There's no need to apply masks
439            // because the unmasked parts will be overwritten by fields.
440            // Write the fields.
441            self.0.encode(encoder, offset + 0, depth)?;
442            Ok(())
443        }
444    }
445
446    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
447        for ProductGetInfoResponse
448    {
449        #[inline(always)]
450        fn new_empty() -> Self {
451            Self { info: fidl::new_empty!(ProductInfo, D) }
452        }
453
454        #[inline]
455        unsafe fn decode(
456            &mut self,
457            decoder: &mut fidl::encoding::Decoder<'_, D>,
458            offset: usize,
459            _depth: fidl::encoding::Depth,
460        ) -> fidl::Result<()> {
461            decoder.debug_check_bounds::<Self>(offset);
462            // Verify that padding bytes are zero.
463            fidl::decode!(ProductInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
464            Ok(())
465        }
466    }
467
468    impl BoardInfo {
469        #[inline(always)]
470        fn max_ordinal_present(&self) -> u64 {
471            if let Some(_) = self.cpu_architecture {
472                return 3;
473            }
474            if let Some(_) = self.revision {
475                return 2;
476            }
477            if let Some(_) = self.name {
478                return 1;
479            }
480            0
481        }
482    }
483
484    impl fidl::encoding::ValueTypeMarker for BoardInfo {
485        type Borrowed<'a> = &'a Self;
486        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
487            value
488        }
489    }
490
491    unsafe impl fidl::encoding::TypeMarker for BoardInfo {
492        type Owned = Self;
493
494        #[inline(always)]
495        fn inline_align(_context: fidl::encoding::Context) -> usize {
496            8
497        }
498
499        #[inline(always)]
500        fn inline_size(_context: fidl::encoding::Context) -> usize {
501            16
502        }
503    }
504
505    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BoardInfo, D>
506        for &BoardInfo
507    {
508        unsafe fn encode(
509            self,
510            encoder: &mut fidl::encoding::Encoder<'_, D>,
511            offset: usize,
512            mut depth: fidl::encoding::Depth,
513        ) -> fidl::Result<()> {
514            encoder.debug_check_bounds::<BoardInfo>(offset);
515            // Vector header
516            let max_ordinal: u64 = self.max_ordinal_present();
517            encoder.write_num(max_ordinal, offset);
518            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
519            // Calling encoder.out_of_line_offset(0) is not allowed.
520            if max_ordinal == 0 {
521                return Ok(());
522            }
523            depth.increment()?;
524            let envelope_size = 8;
525            let bytes_len = max_ordinal as usize * envelope_size;
526            #[allow(unused_variables)]
527            let offset = encoder.out_of_line_offset(bytes_len);
528            let mut _prev_end_offset: usize = 0;
529            if 1 > max_ordinal {
530                return Ok(());
531            }
532
533            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
534            // are envelope_size bytes.
535            let cur_offset: usize = (1 - 1) * envelope_size;
536
537            // Zero reserved fields.
538            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
539
540            // Safety:
541            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
542            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
543            //   envelope_size bytes, there is always sufficient room.
544            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
545                self.name.as_ref().map(
546                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
547                ),
548                encoder,
549                offset + cur_offset,
550                depth,
551            )?;
552
553            _prev_end_offset = cur_offset + envelope_size;
554            if 2 > max_ordinal {
555                return Ok(());
556            }
557
558            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
559            // are envelope_size bytes.
560            let cur_offset: usize = (2 - 1) * envelope_size;
561
562            // Zero reserved fields.
563            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
564
565            // Safety:
566            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
567            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
568            //   envelope_size bytes, there is always sufficient room.
569            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
570                self.revision.as_ref().map(
571                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
572                ),
573                encoder,
574                offset + cur_offset,
575                depth,
576            )?;
577
578            _prev_end_offset = cur_offset + envelope_size;
579            if 3 > max_ordinal {
580                return Ok(());
581            }
582
583            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
584            // are envelope_size bytes.
585            let cur_offset: usize = (3 - 1) * envelope_size;
586
587            // Zero reserved fields.
588            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
589
590            // Safety:
591            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
592            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
593            //   envelope_size bytes, there is always sufficient room.
594            fidl::encoding::encode_in_envelope_optional::<Architecture, D>(
595                self.cpu_architecture
596                    .as_ref()
597                    .map(<Architecture as fidl::encoding::ValueTypeMarker>::borrow),
598                encoder,
599                offset + cur_offset,
600                depth,
601            )?;
602
603            _prev_end_offset = cur_offset + envelope_size;
604
605            Ok(())
606        }
607    }
608
609    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BoardInfo {
610        #[inline(always)]
611        fn new_empty() -> Self {
612            Self::default()
613        }
614
615        unsafe fn decode(
616            &mut self,
617            decoder: &mut fidl::encoding::Decoder<'_, D>,
618            offset: usize,
619            mut depth: fidl::encoding::Depth,
620        ) -> fidl::Result<()> {
621            decoder.debug_check_bounds::<Self>(offset);
622            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
623                None => return Err(fidl::Error::NotNullable),
624                Some(len) => len,
625            };
626            // Calling decoder.out_of_line_offset(0) is not allowed.
627            if len == 0 {
628                return Ok(());
629            };
630            depth.increment()?;
631            let envelope_size = 8;
632            let bytes_len = len * envelope_size;
633            let offset = decoder.out_of_line_offset(bytes_len)?;
634            // Decode the envelope for each type.
635            let mut _next_ordinal_to_read = 0;
636            let mut next_offset = offset;
637            let end_offset = offset + bytes_len;
638            _next_ordinal_to_read += 1;
639            if next_offset >= end_offset {
640                return Ok(());
641            }
642
643            // Decode unknown envelopes for gaps in ordinals.
644            while _next_ordinal_to_read < 1 {
645                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
646                _next_ordinal_to_read += 1;
647                next_offset += envelope_size;
648            }
649
650            let next_out_of_line = decoder.next_out_of_line();
651            let handles_before = decoder.remaining_handles();
652            if let Some((inlined, num_bytes, num_handles)) =
653                fidl::encoding::decode_envelope_header(decoder, next_offset)?
654            {
655                let member_inline_size =
656                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
657                        decoder.context,
658                    );
659                if inlined != (member_inline_size <= 4) {
660                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
661                }
662                let inner_offset;
663                let mut inner_depth = depth.clone();
664                if inlined {
665                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
666                    inner_offset = next_offset;
667                } else {
668                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
669                    inner_depth.increment()?;
670                }
671                let val_ref = self
672                    .name
673                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
674                fidl::decode!(
675                    fidl::encoding::UnboundedString,
676                    D,
677                    val_ref,
678                    decoder,
679                    inner_offset,
680                    inner_depth
681                )?;
682                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
683                {
684                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
685                }
686                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
687                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
688                }
689            }
690
691            next_offset += envelope_size;
692            _next_ordinal_to_read += 1;
693            if next_offset >= end_offset {
694                return Ok(());
695            }
696
697            // Decode unknown envelopes for gaps in ordinals.
698            while _next_ordinal_to_read < 2 {
699                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
700                _next_ordinal_to_read += 1;
701                next_offset += envelope_size;
702            }
703
704            let next_out_of_line = decoder.next_out_of_line();
705            let handles_before = decoder.remaining_handles();
706            if let Some((inlined, num_bytes, num_handles)) =
707                fidl::encoding::decode_envelope_header(decoder, next_offset)?
708            {
709                let member_inline_size =
710                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
711                        decoder.context,
712                    );
713                if inlined != (member_inline_size <= 4) {
714                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
715                }
716                let inner_offset;
717                let mut inner_depth = depth.clone();
718                if inlined {
719                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
720                    inner_offset = next_offset;
721                } else {
722                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
723                    inner_depth.increment()?;
724                }
725                let val_ref = self
726                    .revision
727                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
728                fidl::decode!(
729                    fidl::encoding::UnboundedString,
730                    D,
731                    val_ref,
732                    decoder,
733                    inner_offset,
734                    inner_depth
735                )?;
736                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
737                {
738                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
739                }
740                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
741                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
742                }
743            }
744
745            next_offset += envelope_size;
746            _next_ordinal_to_read += 1;
747            if next_offset >= end_offset {
748                return Ok(());
749            }
750
751            // Decode unknown envelopes for gaps in ordinals.
752            while _next_ordinal_to_read < 3 {
753                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
754                _next_ordinal_to_read += 1;
755                next_offset += envelope_size;
756            }
757
758            let next_out_of_line = decoder.next_out_of_line();
759            let handles_before = decoder.remaining_handles();
760            if let Some((inlined, num_bytes, num_handles)) =
761                fidl::encoding::decode_envelope_header(decoder, next_offset)?
762            {
763                let member_inline_size =
764                    <Architecture as fidl::encoding::TypeMarker>::inline_size(decoder.context);
765                if inlined != (member_inline_size <= 4) {
766                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
767                }
768                let inner_offset;
769                let mut inner_depth = depth.clone();
770                if inlined {
771                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
772                    inner_offset = next_offset;
773                } else {
774                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
775                    inner_depth.increment()?;
776                }
777                let val_ref =
778                    self.cpu_architecture.get_or_insert_with(|| fidl::new_empty!(Architecture, D));
779                fidl::decode!(Architecture, D, val_ref, decoder, inner_offset, inner_depth)?;
780                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
781                {
782                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
783                }
784                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
785                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
786                }
787            }
788
789            next_offset += envelope_size;
790
791            // Decode the remaining unknown envelopes.
792            while next_offset < end_offset {
793                _next_ordinal_to_read += 1;
794                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
795                next_offset += envelope_size;
796            }
797
798            Ok(())
799        }
800    }
801
802    impl DeviceInfo {
803        #[inline(always)]
804        fn max_ordinal_present(&self) -> u64 {
805            if let Some(_) = self.retail_sku {
806                return 3;
807            }
808            if let Some(_) = self.is_retail_demo {
809                return 2;
810            }
811            if let Some(_) = self.serial_number {
812                return 1;
813            }
814            0
815        }
816    }
817
818    impl fidl::encoding::ValueTypeMarker for DeviceInfo {
819        type Borrowed<'a> = &'a Self;
820        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
821            value
822        }
823    }
824
825    unsafe impl fidl::encoding::TypeMarker for DeviceInfo {
826        type Owned = Self;
827
828        #[inline(always)]
829        fn inline_align(_context: fidl::encoding::Context) -> usize {
830            8
831        }
832
833        #[inline(always)]
834        fn inline_size(_context: fidl::encoding::Context) -> usize {
835            16
836        }
837    }
838
839    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceInfo, D>
840        for &DeviceInfo
841    {
842        unsafe fn encode(
843            self,
844            encoder: &mut fidl::encoding::Encoder<'_, D>,
845            offset: usize,
846            mut depth: fidl::encoding::Depth,
847        ) -> fidl::Result<()> {
848            encoder.debug_check_bounds::<DeviceInfo>(offset);
849            // Vector header
850            let max_ordinal: u64 = self.max_ordinal_present();
851            encoder.write_num(max_ordinal, offset);
852            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
853            // Calling encoder.out_of_line_offset(0) is not allowed.
854            if max_ordinal == 0 {
855                return Ok(());
856            }
857            depth.increment()?;
858            let envelope_size = 8;
859            let bytes_len = max_ordinal as usize * envelope_size;
860            #[allow(unused_variables)]
861            let offset = encoder.out_of_line_offset(bytes_len);
862            let mut _prev_end_offset: usize = 0;
863            if 1 > max_ordinal {
864                return Ok(());
865            }
866
867            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
868            // are envelope_size bytes.
869            let cur_offset: usize = (1 - 1) * envelope_size;
870
871            // Zero reserved fields.
872            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
873
874            // Safety:
875            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
876            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
877            //   envelope_size bytes, there is always sufficient room.
878            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
879                self.serial_number.as_ref().map(
880                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
881                ),
882                encoder,
883                offset + cur_offset,
884                depth,
885            )?;
886
887            _prev_end_offset = cur_offset + envelope_size;
888            if 2 > max_ordinal {
889                return Ok(());
890            }
891
892            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
893            // are envelope_size bytes.
894            let cur_offset: usize = (2 - 1) * envelope_size;
895
896            // Zero reserved fields.
897            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
898
899            // Safety:
900            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
901            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
902            //   envelope_size bytes, there is always sufficient room.
903            fidl::encoding::encode_in_envelope_optional::<bool, D>(
904                self.is_retail_demo.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
905                encoder,
906                offset + cur_offset,
907                depth,
908            )?;
909
910            _prev_end_offset = cur_offset + envelope_size;
911            if 3 > max_ordinal {
912                return Ok(());
913            }
914
915            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
916            // are envelope_size bytes.
917            let cur_offset: usize = (3 - 1) * envelope_size;
918
919            // Zero reserved fields.
920            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
921
922            // Safety:
923            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
924            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
925            //   envelope_size bytes, there is always sufficient room.
926            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
927                self.retail_sku.as_ref().map(
928                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
929                ),
930                encoder,
931                offset + cur_offset,
932                depth,
933            )?;
934
935            _prev_end_offset = cur_offset + envelope_size;
936
937            Ok(())
938        }
939    }
940
941    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceInfo {
942        #[inline(always)]
943        fn new_empty() -> Self {
944            Self::default()
945        }
946
947        unsafe fn decode(
948            &mut self,
949            decoder: &mut fidl::encoding::Decoder<'_, D>,
950            offset: usize,
951            mut depth: fidl::encoding::Depth,
952        ) -> fidl::Result<()> {
953            decoder.debug_check_bounds::<Self>(offset);
954            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
955                None => return Err(fidl::Error::NotNullable),
956                Some(len) => len,
957            };
958            // Calling decoder.out_of_line_offset(0) is not allowed.
959            if len == 0 {
960                return Ok(());
961            };
962            depth.increment()?;
963            let envelope_size = 8;
964            let bytes_len = len * envelope_size;
965            let offset = decoder.out_of_line_offset(bytes_len)?;
966            // Decode the envelope for each type.
967            let mut _next_ordinal_to_read = 0;
968            let mut next_offset = offset;
969            let end_offset = offset + bytes_len;
970            _next_ordinal_to_read += 1;
971            if next_offset >= end_offset {
972                return Ok(());
973            }
974
975            // Decode unknown envelopes for gaps in ordinals.
976            while _next_ordinal_to_read < 1 {
977                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
978                _next_ordinal_to_read += 1;
979                next_offset += envelope_size;
980            }
981
982            let next_out_of_line = decoder.next_out_of_line();
983            let handles_before = decoder.remaining_handles();
984            if let Some((inlined, num_bytes, num_handles)) =
985                fidl::encoding::decode_envelope_header(decoder, next_offset)?
986            {
987                let member_inline_size =
988                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
989                        decoder.context,
990                    );
991                if inlined != (member_inline_size <= 4) {
992                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
993                }
994                let inner_offset;
995                let mut inner_depth = depth.clone();
996                if inlined {
997                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
998                    inner_offset = next_offset;
999                } else {
1000                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1001                    inner_depth.increment()?;
1002                }
1003                let val_ref = self
1004                    .serial_number
1005                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
1006                fidl::decode!(
1007                    fidl::encoding::BoundedString<255>,
1008                    D,
1009                    val_ref,
1010                    decoder,
1011                    inner_offset,
1012                    inner_depth
1013                )?;
1014                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1015                {
1016                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1017                }
1018                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1019                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1020                }
1021            }
1022
1023            next_offset += envelope_size;
1024            _next_ordinal_to_read += 1;
1025            if next_offset >= end_offset {
1026                return Ok(());
1027            }
1028
1029            // Decode unknown envelopes for gaps in ordinals.
1030            while _next_ordinal_to_read < 2 {
1031                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1032                _next_ordinal_to_read += 1;
1033                next_offset += envelope_size;
1034            }
1035
1036            let next_out_of_line = decoder.next_out_of_line();
1037            let handles_before = decoder.remaining_handles();
1038            if let Some((inlined, num_bytes, num_handles)) =
1039                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1040            {
1041                let member_inline_size =
1042                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1043                if inlined != (member_inline_size <= 4) {
1044                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1045                }
1046                let inner_offset;
1047                let mut inner_depth = depth.clone();
1048                if inlined {
1049                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1050                    inner_offset = next_offset;
1051                } else {
1052                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1053                    inner_depth.increment()?;
1054                }
1055                let val_ref = self.is_retail_demo.get_or_insert_with(|| fidl::new_empty!(bool, D));
1056                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1057                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1058                {
1059                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1060                }
1061                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1062                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1063                }
1064            }
1065
1066            next_offset += envelope_size;
1067            _next_ordinal_to_read += 1;
1068            if next_offset >= end_offset {
1069                return Ok(());
1070            }
1071
1072            // Decode unknown envelopes for gaps in ordinals.
1073            while _next_ordinal_to_read < 3 {
1074                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1075                _next_ordinal_to_read += 1;
1076                next_offset += envelope_size;
1077            }
1078
1079            let next_out_of_line = decoder.next_out_of_line();
1080            let handles_before = decoder.remaining_handles();
1081            if let Some((inlined, num_bytes, num_handles)) =
1082                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1083            {
1084                let member_inline_size =
1085                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
1086                        decoder.context,
1087                    );
1088                if inlined != (member_inline_size <= 4) {
1089                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1090                }
1091                let inner_offset;
1092                let mut inner_depth = depth.clone();
1093                if inlined {
1094                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1095                    inner_offset = next_offset;
1096                } else {
1097                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1098                    inner_depth.increment()?;
1099                }
1100                let val_ref = self
1101                    .retail_sku
1102                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
1103                fidl::decode!(
1104                    fidl::encoding::BoundedString<255>,
1105                    D,
1106                    val_ref,
1107                    decoder,
1108                    inner_offset,
1109                    inner_depth
1110                )?;
1111                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1112                {
1113                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1114                }
1115                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1116                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1117                }
1118            }
1119
1120            next_offset += envelope_size;
1121
1122            // Decode the remaining unknown envelopes.
1123            while next_offset < end_offset {
1124                _next_ordinal_to_read += 1;
1125                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1126                next_offset += envelope_size;
1127            }
1128
1129            Ok(())
1130        }
1131    }
1132
1133    impl ProductInfo {
1134        #[inline(always)]
1135        fn max_ordinal_present(&self) -> u64 {
1136            if let Some(_) = self.audio_amplifier {
1137                return 16;
1138            }
1139            if let Some(_) = self.microphone {
1140                return 15;
1141            }
1142            if let Some(_) = self.emmc_storage {
1143                return 14;
1144            }
1145            if let Some(_) = self.nand_storage {
1146                return 13;
1147            }
1148            if let Some(_) = self.memory {
1149                return 12;
1150            }
1151            if let Some(_) = self.display {
1152                return 11;
1153            }
1154            if let Some(_) = self.colorway {
1155                return 10;
1156            }
1157            if let Some(_) = self.build_name {
1158                return 9;
1159            }
1160            if let Some(_) = self.build_date {
1161                return 8;
1162            }
1163            if let Some(_) = self.manufacturer {
1164                return 7;
1165            }
1166            if let Some(_) = self.model {
1167                return 6;
1168            }
1169            if let Some(_) = self.name {
1170                return 5;
1171            }
1172            if let Some(_) = self.locale_list {
1173                return 4;
1174            }
1175            if let Some(_) = self.regulatory_domain {
1176                return 3;
1177            }
1178            if let Some(_) = self.language {
1179                return 2;
1180            }
1181            if let Some(_) = self.sku {
1182                return 1;
1183            }
1184            0
1185        }
1186    }
1187
1188    impl fidl::encoding::ValueTypeMarker for ProductInfo {
1189        type Borrowed<'a> = &'a Self;
1190        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1191            value
1192        }
1193    }
1194
1195    unsafe impl fidl::encoding::TypeMarker for ProductInfo {
1196        type Owned = Self;
1197
1198        #[inline(always)]
1199        fn inline_align(_context: fidl::encoding::Context) -> usize {
1200            8
1201        }
1202
1203        #[inline(always)]
1204        fn inline_size(_context: fidl::encoding::Context) -> usize {
1205            16
1206        }
1207    }
1208
1209    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProductInfo, D>
1210        for &ProductInfo
1211    {
1212        unsafe fn encode(
1213            self,
1214            encoder: &mut fidl::encoding::Encoder<'_, D>,
1215            offset: usize,
1216            mut depth: fidl::encoding::Depth,
1217        ) -> fidl::Result<()> {
1218            encoder.debug_check_bounds::<ProductInfo>(offset);
1219            // Vector header
1220            let max_ordinal: u64 = self.max_ordinal_present();
1221            encoder.write_num(max_ordinal, offset);
1222            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1223            // Calling encoder.out_of_line_offset(0) is not allowed.
1224            if max_ordinal == 0 {
1225                return Ok(());
1226            }
1227            depth.increment()?;
1228            let envelope_size = 8;
1229            let bytes_len = max_ordinal as usize * envelope_size;
1230            #[allow(unused_variables)]
1231            let offset = encoder.out_of_line_offset(bytes_len);
1232            let mut _prev_end_offset: usize = 0;
1233            if 1 > max_ordinal {
1234                return Ok(());
1235            }
1236
1237            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1238            // are envelope_size bytes.
1239            let cur_offset: usize = (1 - 1) * envelope_size;
1240
1241            // Zero reserved fields.
1242            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1243
1244            // Safety:
1245            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1246            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1247            //   envelope_size bytes, there is always sufficient room.
1248            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1249                self.sku.as_ref().map(
1250                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1251                ),
1252                encoder,
1253                offset + cur_offset,
1254                depth,
1255            )?;
1256
1257            _prev_end_offset = cur_offset + envelope_size;
1258            if 2 > max_ordinal {
1259                return Ok(());
1260            }
1261
1262            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1263            // are envelope_size bytes.
1264            let cur_offset: usize = (2 - 1) * envelope_size;
1265
1266            // Zero reserved fields.
1267            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1268
1269            // Safety:
1270            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1271            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1272            //   envelope_size bytes, there is always sufficient room.
1273            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1274                self.language.as_ref().map(
1275                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1276                ),
1277                encoder,
1278                offset + cur_offset,
1279                depth,
1280            )?;
1281
1282            _prev_end_offset = cur_offset + envelope_size;
1283            if 3 > max_ordinal {
1284                return Ok(());
1285            }
1286
1287            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1288            // are envelope_size bytes.
1289            let cur_offset: usize = (3 - 1) * envelope_size;
1290
1291            // Zero reserved fields.
1292            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1293
1294            // Safety:
1295            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1296            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1297            //   envelope_size bytes, there is always sufficient room.
1298            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_intl__common::RegulatoryDomain, D>(
1299            self.regulatory_domain.as_ref().map(<fidl_fuchsia_intl__common::RegulatoryDomain as fidl::encoding::ValueTypeMarker>::borrow),
1300            encoder, offset + cur_offset, depth
1301        )?;
1302
1303            _prev_end_offset = cur_offset + envelope_size;
1304            if 4 > max_ordinal {
1305                return Ok(());
1306            }
1307
1308            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1309            // are envelope_size bytes.
1310            let cur_offset: usize = (4 - 1) * envelope_size;
1311
1312            // Zero reserved fields.
1313            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1314
1315            // Safety:
1316            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1317            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1318            //   envelope_size bytes, there is always sufficient room.
1319            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_intl__common::LocaleId>, D>(
1320            self.locale_list.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_intl__common::LocaleId> as fidl::encoding::ValueTypeMarker>::borrow),
1321            encoder, offset + cur_offset, depth
1322        )?;
1323
1324            _prev_end_offset = cur_offset + envelope_size;
1325            if 5 > max_ordinal {
1326                return Ok(());
1327            }
1328
1329            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1330            // are envelope_size bytes.
1331            let cur_offset: usize = (5 - 1) * envelope_size;
1332
1333            // Zero reserved fields.
1334            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1335
1336            // Safety:
1337            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1338            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1339            //   envelope_size bytes, there is always sufficient room.
1340            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1341                self.name.as_ref().map(
1342                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1343                ),
1344                encoder,
1345                offset + cur_offset,
1346                depth,
1347            )?;
1348
1349            _prev_end_offset = cur_offset + envelope_size;
1350            if 6 > max_ordinal {
1351                return Ok(());
1352            }
1353
1354            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1355            // are envelope_size bytes.
1356            let cur_offset: usize = (6 - 1) * envelope_size;
1357
1358            // Zero reserved fields.
1359            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1360
1361            // Safety:
1362            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1363            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1364            //   envelope_size bytes, there is always sufficient room.
1365            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1366                self.model.as_ref().map(
1367                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1368                ),
1369                encoder,
1370                offset + cur_offset,
1371                depth,
1372            )?;
1373
1374            _prev_end_offset = cur_offset + envelope_size;
1375            if 7 > max_ordinal {
1376                return Ok(());
1377            }
1378
1379            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1380            // are envelope_size bytes.
1381            let cur_offset: usize = (7 - 1) * envelope_size;
1382
1383            // Zero reserved fields.
1384            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1385
1386            // Safety:
1387            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1388            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1389            //   envelope_size bytes, there is always sufficient room.
1390            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1391                self.manufacturer.as_ref().map(
1392                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1393                ),
1394                encoder,
1395                offset + cur_offset,
1396                depth,
1397            )?;
1398
1399            _prev_end_offset = cur_offset + envelope_size;
1400            if 8 > max_ordinal {
1401                return Ok(());
1402            }
1403
1404            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1405            // are envelope_size bytes.
1406            let cur_offset: usize = (8 - 1) * envelope_size;
1407
1408            // Zero reserved fields.
1409            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1410
1411            // Safety:
1412            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1413            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1414            //   envelope_size bytes, there is always sufficient room.
1415            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1416                self.build_date.as_ref().map(
1417                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1418                ),
1419                encoder,
1420                offset + cur_offset,
1421                depth,
1422            )?;
1423
1424            _prev_end_offset = cur_offset + envelope_size;
1425            if 9 > max_ordinal {
1426                return Ok(());
1427            }
1428
1429            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1430            // are envelope_size bytes.
1431            let cur_offset: usize = (9 - 1) * envelope_size;
1432
1433            // Zero reserved fields.
1434            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1435
1436            // Safety:
1437            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1438            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1439            //   envelope_size bytes, there is always sufficient room.
1440            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1441                self.build_name.as_ref().map(
1442                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1443                ),
1444                encoder,
1445                offset + cur_offset,
1446                depth,
1447            )?;
1448
1449            _prev_end_offset = cur_offset + envelope_size;
1450            if 10 > max_ordinal {
1451                return Ok(());
1452            }
1453
1454            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1455            // are envelope_size bytes.
1456            let cur_offset: usize = (10 - 1) * envelope_size;
1457
1458            // Zero reserved fields.
1459            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1460
1461            // Safety:
1462            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1463            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1464            //   envelope_size bytes, there is always sufficient room.
1465            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1466                self.colorway.as_ref().map(
1467                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1468                ),
1469                encoder,
1470                offset + cur_offset,
1471                depth,
1472            )?;
1473
1474            _prev_end_offset = cur_offset + envelope_size;
1475            if 11 > max_ordinal {
1476                return Ok(());
1477            }
1478
1479            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1480            // are envelope_size bytes.
1481            let cur_offset: usize = (11 - 1) * envelope_size;
1482
1483            // Zero reserved fields.
1484            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1485
1486            // Safety:
1487            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1488            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1489            //   envelope_size bytes, there is always sufficient room.
1490            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1491                self.display.as_ref().map(
1492                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1493                ),
1494                encoder,
1495                offset + cur_offset,
1496                depth,
1497            )?;
1498
1499            _prev_end_offset = cur_offset + envelope_size;
1500            if 12 > max_ordinal {
1501                return Ok(());
1502            }
1503
1504            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1505            // are envelope_size bytes.
1506            let cur_offset: usize = (12 - 1) * envelope_size;
1507
1508            // Zero reserved fields.
1509            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1510
1511            // Safety:
1512            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1513            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1514            //   envelope_size bytes, there is always sufficient room.
1515            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1516                self.memory.as_ref().map(
1517                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1518                ),
1519                encoder,
1520                offset + cur_offset,
1521                depth,
1522            )?;
1523
1524            _prev_end_offset = cur_offset + envelope_size;
1525            if 13 > max_ordinal {
1526                return Ok(());
1527            }
1528
1529            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1530            // are envelope_size bytes.
1531            let cur_offset: usize = (13 - 1) * envelope_size;
1532
1533            // Zero reserved fields.
1534            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1535
1536            // Safety:
1537            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1538            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1539            //   envelope_size bytes, there is always sufficient room.
1540            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1541                self.nand_storage.as_ref().map(
1542                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1543                ),
1544                encoder,
1545                offset + cur_offset,
1546                depth,
1547            )?;
1548
1549            _prev_end_offset = cur_offset + envelope_size;
1550            if 14 > max_ordinal {
1551                return Ok(());
1552            }
1553
1554            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1555            // are envelope_size bytes.
1556            let cur_offset: usize = (14 - 1) * envelope_size;
1557
1558            // Zero reserved fields.
1559            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1560
1561            // Safety:
1562            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1563            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1564            //   envelope_size bytes, there is always sufficient room.
1565            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1566                self.emmc_storage.as_ref().map(
1567                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1568                ),
1569                encoder,
1570                offset + cur_offset,
1571                depth,
1572            )?;
1573
1574            _prev_end_offset = cur_offset + envelope_size;
1575            if 15 > max_ordinal {
1576                return Ok(());
1577            }
1578
1579            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1580            // are envelope_size bytes.
1581            let cur_offset: usize = (15 - 1) * envelope_size;
1582
1583            // Zero reserved fields.
1584            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1585
1586            // Safety:
1587            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1588            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1589            //   envelope_size bytes, there is always sufficient room.
1590            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1591                self.microphone.as_ref().map(
1592                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1593                ),
1594                encoder,
1595                offset + cur_offset,
1596                depth,
1597            )?;
1598
1599            _prev_end_offset = cur_offset + envelope_size;
1600            if 16 > max_ordinal {
1601                return Ok(());
1602            }
1603
1604            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1605            // are envelope_size bytes.
1606            let cur_offset: usize = (16 - 1) * envelope_size;
1607
1608            // Zero reserved fields.
1609            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1610
1611            // Safety:
1612            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1613            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1614            //   envelope_size bytes, there is always sufficient room.
1615            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1616                self.audio_amplifier.as_ref().map(
1617                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1618                ),
1619                encoder,
1620                offset + cur_offset,
1621                depth,
1622            )?;
1623
1624            _prev_end_offset = cur_offset + envelope_size;
1625
1626            Ok(())
1627        }
1628    }
1629
1630    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProductInfo {
1631        #[inline(always)]
1632        fn new_empty() -> Self {
1633            Self::default()
1634        }
1635
1636        unsafe fn decode(
1637            &mut self,
1638            decoder: &mut fidl::encoding::Decoder<'_, D>,
1639            offset: usize,
1640            mut depth: fidl::encoding::Depth,
1641        ) -> fidl::Result<()> {
1642            decoder.debug_check_bounds::<Self>(offset);
1643            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1644                None => return Err(fidl::Error::NotNullable),
1645                Some(len) => len,
1646            };
1647            // Calling decoder.out_of_line_offset(0) is not allowed.
1648            if len == 0 {
1649                return Ok(());
1650            };
1651            depth.increment()?;
1652            let envelope_size = 8;
1653            let bytes_len = len * envelope_size;
1654            let offset = decoder.out_of_line_offset(bytes_len)?;
1655            // Decode the envelope for each type.
1656            let mut _next_ordinal_to_read = 0;
1657            let mut next_offset = offset;
1658            let end_offset = offset + bytes_len;
1659            _next_ordinal_to_read += 1;
1660            if next_offset >= end_offset {
1661                return Ok(());
1662            }
1663
1664            // Decode unknown envelopes for gaps in ordinals.
1665            while _next_ordinal_to_read < 1 {
1666                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1667                _next_ordinal_to_read += 1;
1668                next_offset += envelope_size;
1669            }
1670
1671            let next_out_of_line = decoder.next_out_of_line();
1672            let handles_before = decoder.remaining_handles();
1673            if let Some((inlined, num_bytes, num_handles)) =
1674                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1675            {
1676                let member_inline_size =
1677                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
1678                        decoder.context,
1679                    );
1680                if inlined != (member_inline_size <= 4) {
1681                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1682                }
1683                let inner_offset;
1684                let mut inner_depth = depth.clone();
1685                if inlined {
1686                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1687                    inner_offset = next_offset;
1688                } else {
1689                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1690                    inner_depth.increment()?;
1691                }
1692                let val_ref = self
1693                    .sku
1694                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
1695                fidl::decode!(
1696                    fidl::encoding::UnboundedString,
1697                    D,
1698                    val_ref,
1699                    decoder,
1700                    inner_offset,
1701                    inner_depth
1702                )?;
1703                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1704                {
1705                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1706                }
1707                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1708                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1709                }
1710            }
1711
1712            next_offset += envelope_size;
1713            _next_ordinal_to_read += 1;
1714            if next_offset >= end_offset {
1715                return Ok(());
1716            }
1717
1718            // Decode unknown envelopes for gaps in ordinals.
1719            while _next_ordinal_to_read < 2 {
1720                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1721                _next_ordinal_to_read += 1;
1722                next_offset += envelope_size;
1723            }
1724
1725            let next_out_of_line = decoder.next_out_of_line();
1726            let handles_before = decoder.remaining_handles();
1727            if let Some((inlined, num_bytes, num_handles)) =
1728                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1729            {
1730                let member_inline_size =
1731                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
1732                        decoder.context,
1733                    );
1734                if inlined != (member_inline_size <= 4) {
1735                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1736                }
1737                let inner_offset;
1738                let mut inner_depth = depth.clone();
1739                if inlined {
1740                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1741                    inner_offset = next_offset;
1742                } else {
1743                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1744                    inner_depth.increment()?;
1745                }
1746                let val_ref = self
1747                    .language
1748                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
1749                fidl::decode!(
1750                    fidl::encoding::UnboundedString,
1751                    D,
1752                    val_ref,
1753                    decoder,
1754                    inner_offset,
1755                    inner_depth
1756                )?;
1757                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1758                {
1759                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1760                }
1761                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1762                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1763                }
1764            }
1765
1766            next_offset += envelope_size;
1767            _next_ordinal_to_read += 1;
1768            if next_offset >= end_offset {
1769                return Ok(());
1770            }
1771
1772            // Decode unknown envelopes for gaps in ordinals.
1773            while _next_ordinal_to_read < 3 {
1774                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1775                _next_ordinal_to_read += 1;
1776                next_offset += envelope_size;
1777            }
1778
1779            let next_out_of_line = decoder.next_out_of_line();
1780            let handles_before = decoder.remaining_handles();
1781            if let Some((inlined, num_bytes, num_handles)) =
1782                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1783            {
1784                let member_inline_size = <fidl_fuchsia_intl__common::RegulatoryDomain as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1785                if inlined != (member_inline_size <= 4) {
1786                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1787                }
1788                let inner_offset;
1789                let mut inner_depth = depth.clone();
1790                if inlined {
1791                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1792                    inner_offset = next_offset;
1793                } else {
1794                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1795                    inner_depth.increment()?;
1796                }
1797                let val_ref = self.regulatory_domain.get_or_insert_with(|| {
1798                    fidl::new_empty!(fidl_fuchsia_intl__common::RegulatoryDomain, D)
1799                });
1800                fidl::decode!(
1801                    fidl_fuchsia_intl__common::RegulatoryDomain,
1802                    D,
1803                    val_ref,
1804                    decoder,
1805                    inner_offset,
1806                    inner_depth
1807                )?;
1808                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1809                {
1810                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1811                }
1812                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1813                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1814                }
1815            }
1816
1817            next_offset += envelope_size;
1818            _next_ordinal_to_read += 1;
1819            if next_offset >= end_offset {
1820                return Ok(());
1821            }
1822
1823            // Decode unknown envelopes for gaps in ordinals.
1824            while _next_ordinal_to_read < 4 {
1825                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1826                _next_ordinal_to_read += 1;
1827                next_offset += envelope_size;
1828            }
1829
1830            let next_out_of_line = decoder.next_out_of_line();
1831            let handles_before = decoder.remaining_handles();
1832            if let Some((inlined, num_bytes, num_handles)) =
1833                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1834            {
1835                let member_inline_size = <fidl::encoding::UnboundedVector<
1836                    fidl_fuchsia_intl__common::LocaleId,
1837                > as fidl::encoding::TypeMarker>::inline_size(
1838                    decoder.context
1839                );
1840                if inlined != (member_inline_size <= 4) {
1841                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1842                }
1843                let inner_offset;
1844                let mut inner_depth = depth.clone();
1845                if inlined {
1846                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1847                    inner_offset = next_offset;
1848                } else {
1849                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1850                    inner_depth.increment()?;
1851                }
1852                let val_ref = self.locale_list.get_or_insert_with(|| {
1853                    fidl::new_empty!(
1854                        fidl::encoding::UnboundedVector<fidl_fuchsia_intl__common::LocaleId>,
1855                        D
1856                    )
1857                });
1858                fidl::decode!(
1859                    fidl::encoding::UnboundedVector<fidl_fuchsia_intl__common::LocaleId>,
1860                    D,
1861                    val_ref,
1862                    decoder,
1863                    inner_offset,
1864                    inner_depth
1865                )?;
1866                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1867                {
1868                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1869                }
1870                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1871                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1872                }
1873            }
1874
1875            next_offset += envelope_size;
1876            _next_ordinal_to_read += 1;
1877            if next_offset >= end_offset {
1878                return Ok(());
1879            }
1880
1881            // Decode unknown envelopes for gaps in ordinals.
1882            while _next_ordinal_to_read < 5 {
1883                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1884                _next_ordinal_to_read += 1;
1885                next_offset += envelope_size;
1886            }
1887
1888            let next_out_of_line = decoder.next_out_of_line();
1889            let handles_before = decoder.remaining_handles();
1890            if let Some((inlined, num_bytes, num_handles)) =
1891                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1892            {
1893                let member_inline_size =
1894                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
1895                        decoder.context,
1896                    );
1897                if inlined != (member_inline_size <= 4) {
1898                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1899                }
1900                let inner_offset;
1901                let mut inner_depth = depth.clone();
1902                if inlined {
1903                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1904                    inner_offset = next_offset;
1905                } else {
1906                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1907                    inner_depth.increment()?;
1908                }
1909                let val_ref = self
1910                    .name
1911                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
1912                fidl::decode!(
1913                    fidl::encoding::UnboundedString,
1914                    D,
1915                    val_ref,
1916                    decoder,
1917                    inner_offset,
1918                    inner_depth
1919                )?;
1920                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1921                {
1922                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1923                }
1924                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1925                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1926                }
1927            }
1928
1929            next_offset += envelope_size;
1930            _next_ordinal_to_read += 1;
1931            if next_offset >= end_offset {
1932                return Ok(());
1933            }
1934
1935            // Decode unknown envelopes for gaps in ordinals.
1936            while _next_ordinal_to_read < 6 {
1937                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1938                _next_ordinal_to_read += 1;
1939                next_offset += envelope_size;
1940            }
1941
1942            let next_out_of_line = decoder.next_out_of_line();
1943            let handles_before = decoder.remaining_handles();
1944            if let Some((inlined, num_bytes, num_handles)) =
1945                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1946            {
1947                let member_inline_size =
1948                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
1949                        decoder.context,
1950                    );
1951                if inlined != (member_inline_size <= 4) {
1952                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1953                }
1954                let inner_offset;
1955                let mut inner_depth = depth.clone();
1956                if inlined {
1957                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1958                    inner_offset = next_offset;
1959                } else {
1960                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1961                    inner_depth.increment()?;
1962                }
1963                let val_ref = self
1964                    .model
1965                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
1966                fidl::decode!(
1967                    fidl::encoding::UnboundedString,
1968                    D,
1969                    val_ref,
1970                    decoder,
1971                    inner_offset,
1972                    inner_depth
1973                )?;
1974                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1975                {
1976                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1977                }
1978                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1979                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1980                }
1981            }
1982
1983            next_offset += envelope_size;
1984            _next_ordinal_to_read += 1;
1985            if next_offset >= end_offset {
1986                return Ok(());
1987            }
1988
1989            // Decode unknown envelopes for gaps in ordinals.
1990            while _next_ordinal_to_read < 7 {
1991                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1992                _next_ordinal_to_read += 1;
1993                next_offset += envelope_size;
1994            }
1995
1996            let next_out_of_line = decoder.next_out_of_line();
1997            let handles_before = decoder.remaining_handles();
1998            if let Some((inlined, num_bytes, num_handles)) =
1999                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2000            {
2001                let member_inline_size =
2002                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
2003                        decoder.context,
2004                    );
2005                if inlined != (member_inline_size <= 4) {
2006                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2007                }
2008                let inner_offset;
2009                let mut inner_depth = depth.clone();
2010                if inlined {
2011                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2012                    inner_offset = next_offset;
2013                } else {
2014                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2015                    inner_depth.increment()?;
2016                }
2017                let val_ref = self
2018                    .manufacturer
2019                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
2020                fidl::decode!(
2021                    fidl::encoding::UnboundedString,
2022                    D,
2023                    val_ref,
2024                    decoder,
2025                    inner_offset,
2026                    inner_depth
2027                )?;
2028                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2029                {
2030                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2031                }
2032                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2033                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2034                }
2035            }
2036
2037            next_offset += envelope_size;
2038            _next_ordinal_to_read += 1;
2039            if next_offset >= end_offset {
2040                return Ok(());
2041            }
2042
2043            // Decode unknown envelopes for gaps in ordinals.
2044            while _next_ordinal_to_read < 8 {
2045                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2046                _next_ordinal_to_read += 1;
2047                next_offset += envelope_size;
2048            }
2049
2050            let next_out_of_line = decoder.next_out_of_line();
2051            let handles_before = decoder.remaining_handles();
2052            if let Some((inlined, num_bytes, num_handles)) =
2053                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2054            {
2055                let member_inline_size =
2056                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
2057                        decoder.context,
2058                    );
2059                if inlined != (member_inline_size <= 4) {
2060                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2061                }
2062                let inner_offset;
2063                let mut inner_depth = depth.clone();
2064                if inlined {
2065                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2066                    inner_offset = next_offset;
2067                } else {
2068                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2069                    inner_depth.increment()?;
2070                }
2071                let val_ref = self
2072                    .build_date
2073                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
2074                fidl::decode!(
2075                    fidl::encoding::UnboundedString,
2076                    D,
2077                    val_ref,
2078                    decoder,
2079                    inner_offset,
2080                    inner_depth
2081                )?;
2082                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2083                {
2084                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2085                }
2086                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2087                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2088                }
2089            }
2090
2091            next_offset += envelope_size;
2092            _next_ordinal_to_read += 1;
2093            if next_offset >= end_offset {
2094                return Ok(());
2095            }
2096
2097            // Decode unknown envelopes for gaps in ordinals.
2098            while _next_ordinal_to_read < 9 {
2099                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2100                _next_ordinal_to_read += 1;
2101                next_offset += envelope_size;
2102            }
2103
2104            let next_out_of_line = decoder.next_out_of_line();
2105            let handles_before = decoder.remaining_handles();
2106            if let Some((inlined, num_bytes, num_handles)) =
2107                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2108            {
2109                let member_inline_size =
2110                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2111                        decoder.context,
2112                    );
2113                if inlined != (member_inline_size <= 4) {
2114                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2115                }
2116                let inner_offset;
2117                let mut inner_depth = depth.clone();
2118                if inlined {
2119                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2120                    inner_offset = next_offset;
2121                } else {
2122                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2123                    inner_depth.increment()?;
2124                }
2125                let val_ref = self
2126                    .build_name
2127                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2128                fidl::decode!(
2129                    fidl::encoding::BoundedString<255>,
2130                    D,
2131                    val_ref,
2132                    decoder,
2133                    inner_offset,
2134                    inner_depth
2135                )?;
2136                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2137                {
2138                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2139                }
2140                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2141                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2142                }
2143            }
2144
2145            next_offset += envelope_size;
2146            _next_ordinal_to_read += 1;
2147            if next_offset >= end_offset {
2148                return Ok(());
2149            }
2150
2151            // Decode unknown envelopes for gaps in ordinals.
2152            while _next_ordinal_to_read < 10 {
2153                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2154                _next_ordinal_to_read += 1;
2155                next_offset += envelope_size;
2156            }
2157
2158            let next_out_of_line = decoder.next_out_of_line();
2159            let handles_before = decoder.remaining_handles();
2160            if let Some((inlined, num_bytes, num_handles)) =
2161                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2162            {
2163                let member_inline_size =
2164                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2165                        decoder.context,
2166                    );
2167                if inlined != (member_inline_size <= 4) {
2168                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2169                }
2170                let inner_offset;
2171                let mut inner_depth = depth.clone();
2172                if inlined {
2173                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2174                    inner_offset = next_offset;
2175                } else {
2176                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2177                    inner_depth.increment()?;
2178                }
2179                let val_ref = self
2180                    .colorway
2181                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2182                fidl::decode!(
2183                    fidl::encoding::BoundedString<255>,
2184                    D,
2185                    val_ref,
2186                    decoder,
2187                    inner_offset,
2188                    inner_depth
2189                )?;
2190                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2191                {
2192                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2193                }
2194                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2195                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2196                }
2197            }
2198
2199            next_offset += envelope_size;
2200            _next_ordinal_to_read += 1;
2201            if next_offset >= end_offset {
2202                return Ok(());
2203            }
2204
2205            // Decode unknown envelopes for gaps in ordinals.
2206            while _next_ordinal_to_read < 11 {
2207                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2208                _next_ordinal_to_read += 1;
2209                next_offset += envelope_size;
2210            }
2211
2212            let next_out_of_line = decoder.next_out_of_line();
2213            let handles_before = decoder.remaining_handles();
2214            if let Some((inlined, num_bytes, num_handles)) =
2215                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2216            {
2217                let member_inline_size =
2218                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2219                        decoder.context,
2220                    );
2221                if inlined != (member_inline_size <= 4) {
2222                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2223                }
2224                let inner_offset;
2225                let mut inner_depth = depth.clone();
2226                if inlined {
2227                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2228                    inner_offset = next_offset;
2229                } else {
2230                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2231                    inner_depth.increment()?;
2232                }
2233                let val_ref = self
2234                    .display
2235                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2236                fidl::decode!(
2237                    fidl::encoding::BoundedString<255>,
2238                    D,
2239                    val_ref,
2240                    decoder,
2241                    inner_offset,
2242                    inner_depth
2243                )?;
2244                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2245                {
2246                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2247                }
2248                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2249                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2250                }
2251            }
2252
2253            next_offset += envelope_size;
2254            _next_ordinal_to_read += 1;
2255            if next_offset >= end_offset {
2256                return Ok(());
2257            }
2258
2259            // Decode unknown envelopes for gaps in ordinals.
2260            while _next_ordinal_to_read < 12 {
2261                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2262                _next_ordinal_to_read += 1;
2263                next_offset += envelope_size;
2264            }
2265
2266            let next_out_of_line = decoder.next_out_of_line();
2267            let handles_before = decoder.remaining_handles();
2268            if let Some((inlined, num_bytes, num_handles)) =
2269                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2270            {
2271                let member_inline_size =
2272                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2273                        decoder.context,
2274                    );
2275                if inlined != (member_inline_size <= 4) {
2276                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2277                }
2278                let inner_offset;
2279                let mut inner_depth = depth.clone();
2280                if inlined {
2281                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2282                    inner_offset = next_offset;
2283                } else {
2284                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2285                    inner_depth.increment()?;
2286                }
2287                let val_ref = self
2288                    .memory
2289                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2290                fidl::decode!(
2291                    fidl::encoding::BoundedString<255>,
2292                    D,
2293                    val_ref,
2294                    decoder,
2295                    inner_offset,
2296                    inner_depth
2297                )?;
2298                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2299                {
2300                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2301                }
2302                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2303                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2304                }
2305            }
2306
2307            next_offset += envelope_size;
2308            _next_ordinal_to_read += 1;
2309            if next_offset >= end_offset {
2310                return Ok(());
2311            }
2312
2313            // Decode unknown envelopes for gaps in ordinals.
2314            while _next_ordinal_to_read < 13 {
2315                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2316                _next_ordinal_to_read += 1;
2317                next_offset += envelope_size;
2318            }
2319
2320            let next_out_of_line = decoder.next_out_of_line();
2321            let handles_before = decoder.remaining_handles();
2322            if let Some((inlined, num_bytes, num_handles)) =
2323                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2324            {
2325                let member_inline_size =
2326                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2327                        decoder.context,
2328                    );
2329                if inlined != (member_inline_size <= 4) {
2330                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2331                }
2332                let inner_offset;
2333                let mut inner_depth = depth.clone();
2334                if inlined {
2335                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2336                    inner_offset = next_offset;
2337                } else {
2338                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2339                    inner_depth.increment()?;
2340                }
2341                let val_ref = self
2342                    .nand_storage
2343                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2344                fidl::decode!(
2345                    fidl::encoding::BoundedString<255>,
2346                    D,
2347                    val_ref,
2348                    decoder,
2349                    inner_offset,
2350                    inner_depth
2351                )?;
2352                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2353                {
2354                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2355                }
2356                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2357                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2358                }
2359            }
2360
2361            next_offset += envelope_size;
2362            _next_ordinal_to_read += 1;
2363            if next_offset >= end_offset {
2364                return Ok(());
2365            }
2366
2367            // Decode unknown envelopes for gaps in ordinals.
2368            while _next_ordinal_to_read < 14 {
2369                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2370                _next_ordinal_to_read += 1;
2371                next_offset += envelope_size;
2372            }
2373
2374            let next_out_of_line = decoder.next_out_of_line();
2375            let handles_before = decoder.remaining_handles();
2376            if let Some((inlined, num_bytes, num_handles)) =
2377                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2378            {
2379                let member_inline_size =
2380                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2381                        decoder.context,
2382                    );
2383                if inlined != (member_inline_size <= 4) {
2384                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2385                }
2386                let inner_offset;
2387                let mut inner_depth = depth.clone();
2388                if inlined {
2389                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2390                    inner_offset = next_offset;
2391                } else {
2392                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2393                    inner_depth.increment()?;
2394                }
2395                let val_ref = self
2396                    .emmc_storage
2397                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2398                fidl::decode!(
2399                    fidl::encoding::BoundedString<255>,
2400                    D,
2401                    val_ref,
2402                    decoder,
2403                    inner_offset,
2404                    inner_depth
2405                )?;
2406                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2407                {
2408                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2409                }
2410                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2411                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2412                }
2413            }
2414
2415            next_offset += envelope_size;
2416            _next_ordinal_to_read += 1;
2417            if next_offset >= end_offset {
2418                return Ok(());
2419            }
2420
2421            // Decode unknown envelopes for gaps in ordinals.
2422            while _next_ordinal_to_read < 15 {
2423                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2424                _next_ordinal_to_read += 1;
2425                next_offset += envelope_size;
2426            }
2427
2428            let next_out_of_line = decoder.next_out_of_line();
2429            let handles_before = decoder.remaining_handles();
2430            if let Some((inlined, num_bytes, num_handles)) =
2431                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2432            {
2433                let member_inline_size =
2434                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2435                        decoder.context,
2436                    );
2437                if inlined != (member_inline_size <= 4) {
2438                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2439                }
2440                let inner_offset;
2441                let mut inner_depth = depth.clone();
2442                if inlined {
2443                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2444                    inner_offset = next_offset;
2445                } else {
2446                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2447                    inner_depth.increment()?;
2448                }
2449                let val_ref = self
2450                    .microphone
2451                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2452                fidl::decode!(
2453                    fidl::encoding::BoundedString<255>,
2454                    D,
2455                    val_ref,
2456                    decoder,
2457                    inner_offset,
2458                    inner_depth
2459                )?;
2460                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2461                {
2462                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2463                }
2464                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2465                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2466                }
2467            }
2468
2469            next_offset += envelope_size;
2470            _next_ordinal_to_read += 1;
2471            if next_offset >= end_offset {
2472                return Ok(());
2473            }
2474
2475            // Decode unknown envelopes for gaps in ordinals.
2476            while _next_ordinal_to_read < 16 {
2477                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2478                _next_ordinal_to_read += 1;
2479                next_offset += envelope_size;
2480            }
2481
2482            let next_out_of_line = decoder.next_out_of_line();
2483            let handles_before = decoder.remaining_handles();
2484            if let Some((inlined, num_bytes, num_handles)) =
2485                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2486            {
2487                let member_inline_size =
2488                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
2489                        decoder.context,
2490                    );
2491                if inlined != (member_inline_size <= 4) {
2492                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2493                }
2494                let inner_offset;
2495                let mut inner_depth = depth.clone();
2496                if inlined {
2497                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2498                    inner_offset = next_offset;
2499                } else {
2500                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2501                    inner_depth.increment()?;
2502                }
2503                let val_ref = self
2504                    .audio_amplifier
2505                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
2506                fidl::decode!(
2507                    fidl::encoding::BoundedString<255>,
2508                    D,
2509                    val_ref,
2510                    decoder,
2511                    inner_offset,
2512                    inner_depth
2513                )?;
2514                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2515                {
2516                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2517                }
2518                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2519                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2520                }
2521            }
2522
2523            next_offset += envelope_size;
2524
2525            // Decode the remaining unknown envelopes.
2526            while next_offset < end_offset {
2527                _next_ordinal_to_read += 1;
2528                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2529                next_offset += envelope_size;
2530            }
2531
2532            Ok(())
2533        }
2534    }
2535}