fidl_fuchsia_developer_remotecontrol__common/
fidl_fuchsia_developer_remotecontrol__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_CONNECT_MATCHES: u16 = 5;
12
13pub const MAX_NUM_MATCHES: u16 = 250;
14
15pub const NODE_NAME_MAX: u32 = 255;
16
17/// State of the compatibility between the host tools and the target.
18#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
19pub enum CompatibilityState {
20    /// An error was encountered determining the compatibility status.
21    Error,
22    /// The compatibility information is not present.
23    Absent,
24    /// ABI revision is supported
25    Supported,
26    ///  ABI revision was not recognized.
27    Unknown,
28    ///  ABI revision it presented is not supported.
29    Unsupported,
30    #[doc(hidden)]
31    __SourceBreaking { unknown_ordinal: u32 },
32}
33
34/// Pattern that matches an unknown `CompatibilityState` member.
35#[macro_export]
36macro_rules! CompatibilityStateUnknown {
37    () => {
38        _
39    };
40}
41
42impl CompatibilityState {
43    #[inline]
44    pub fn from_primitive(prim: u32) -> Option<Self> {
45        match prim {
46            0 => Some(Self::Error),
47            1 => Some(Self::Absent),
48            2 => Some(Self::Supported),
49            3 => Some(Self::Unknown),
50            4 => Some(Self::Unsupported),
51            _ => None,
52        }
53    }
54
55    #[inline]
56    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
57        match prim {
58            0 => Self::Error,
59            1 => Self::Absent,
60            2 => Self::Supported,
61            3 => Self::Unknown,
62            4 => Self::Unsupported,
63            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
64        }
65    }
66
67    #[inline]
68    pub fn unknown() -> Self {
69        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
70    }
71
72    #[inline]
73    pub const fn into_primitive(self) -> u32 {
74        match self {
75            Self::Error => 0,
76            Self::Absent => 1,
77            Self::Supported => 2,
78            Self::Unknown => 3,
79            Self::Unsupported => 4,
80            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
81        }
82    }
83
84    #[inline]
85    pub fn is_unknown(&self) -> bool {
86        match self {
87            Self::__SourceBreaking { unknown_ordinal: _ } => true,
88            _ => false,
89        }
90    }
91}
92
93#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
94pub enum ConnectCapabilityError {
95    InvalidMoniker,
96    NoMatchingCapabilities,
97    NoMatchingComponent,
98    CapabilityConnectFailed,
99    #[doc(hidden)]
100    __SourceBreaking {
101        unknown_ordinal: u32,
102    },
103}
104
105/// Pattern that matches an unknown `ConnectCapabilityError` member.
106#[macro_export]
107macro_rules! ConnectCapabilityErrorUnknown {
108    () => {
109        _
110    };
111}
112
113impl ConnectCapabilityError {
114    #[inline]
115    pub fn from_primitive(prim: u32) -> Option<Self> {
116        match prim {
117            1 => Some(Self::InvalidMoniker),
118            2 => Some(Self::NoMatchingCapabilities),
119            3 => Some(Self::NoMatchingComponent),
120            4 => Some(Self::CapabilityConnectFailed),
121            _ => None,
122        }
123    }
124
125    #[inline]
126    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
127        match prim {
128            1 => Self::InvalidMoniker,
129            2 => Self::NoMatchingCapabilities,
130            3 => Self::NoMatchingComponent,
131            4 => Self::CapabilityConnectFailed,
132            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
133        }
134    }
135
136    #[inline]
137    pub fn unknown() -> Self {
138        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
139    }
140
141    #[inline]
142    pub const fn into_primitive(self) -> u32 {
143        match self {
144            Self::InvalidMoniker => 1,
145            Self::NoMatchingCapabilities => 2,
146            Self::NoMatchingComponent => 3,
147            Self::CapabilityConnectFailed => 4,
148            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
149        }
150    }
151
152    #[inline]
153    pub fn is_unknown(&self) -> bool {
154        match self {
155            Self::__SourceBreaking { unknown_ordinal: _ } => true,
156            _ => false,
157        }
158    }
159}
160
161#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
162pub enum IdentifyHostError {
163    ListInterfacesFailed,
164    GetDeviceNameFailed,
165    ProxyConnectionFailed,
166    #[doc(hidden)]
167    __SourceBreaking {
168        unknown_ordinal: u32,
169    },
170}
171
172/// Pattern that matches an unknown `IdentifyHostError` member.
173#[macro_export]
174macro_rules! IdentifyHostErrorUnknown {
175    () => {
176        _
177    };
178}
179
180impl IdentifyHostError {
181    #[inline]
182    pub fn from_primitive(prim: u32) -> Option<Self> {
183        match prim {
184            1 => Some(Self::ListInterfacesFailed),
185            2 => Some(Self::GetDeviceNameFailed),
186            3 => Some(Self::ProxyConnectionFailed),
187            _ => None,
188        }
189    }
190
191    #[inline]
192    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
193        match prim {
194            1 => Self::ListInterfacesFailed,
195            2 => Self::GetDeviceNameFailed,
196            3 => Self::ProxyConnectionFailed,
197            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
198        }
199    }
200
201    #[inline]
202    pub fn unknown() -> Self {
203        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
204    }
205
206    #[inline]
207    pub const fn into_primitive(self) -> u32 {
208        match self {
209            Self::ListInterfacesFailed => 1,
210            Self::GetDeviceNameFailed => 2,
211            Self::ProxyConnectionFailed => 3,
212            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
213        }
214    }
215
216    #[inline]
217    pub fn is_unknown(&self) -> bool {
218        match self {
219            Self::__SourceBreaking { unknown_ordinal: _ } => true,
220            _ => false,
221        }
222    }
223}
224
225#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
226pub enum TunnelError {
227    ConnectFailed,
228    SocketFailed,
229    CallbackError,
230    #[doc(hidden)]
231    __SourceBreaking {
232        unknown_ordinal: u32,
233    },
234}
235
236/// Pattern that matches an unknown `TunnelError` member.
237#[macro_export]
238macro_rules! TunnelErrorUnknown {
239    () => {
240        _
241    };
242}
243
244impl TunnelError {
245    #[inline]
246    pub fn from_primitive(prim: u32) -> Option<Self> {
247        match prim {
248            1 => Some(Self::ConnectFailed),
249            2 => Some(Self::SocketFailed),
250            3 => Some(Self::CallbackError),
251            _ => None,
252        }
253    }
254
255    #[inline]
256    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
257        match prim {
258            1 => Self::ConnectFailed,
259            2 => Self::SocketFailed,
260            3 => Self::CallbackError,
261            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
262        }
263    }
264
265    #[inline]
266    pub fn unknown() -> Self {
267        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
268    }
269
270    #[inline]
271    pub const fn into_primitive(self) -> u32 {
272        match self {
273            Self::ConnectFailed => 1,
274            Self::SocketFailed => 2,
275            Self::CallbackError => 3,
276            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
277        }
278    }
279
280    #[inline]
281    pub fn is_unknown(&self) -> bool {
282        match self {
283            Self::__SourceBreaking { unknown_ordinal: _ } => true,
284            _ => false,
285        }
286    }
287}
288
289/// Compatibility information about the target
290#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
291pub struct CompatibilityInfo {
292    /// The state of the compatibity between the host tools and the target.
293    pub state: CompatibilityState,
294    /// The ABI revision of the target platform.
295    pub platform_abi: u64,
296    /// A status message string suitable for displaying to english reading users.
297    pub message: String,
298}
299
300impl fidl::Persistable for CompatibilityInfo {}
301
302#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
303pub struct RemoteControlEchoStringRequest {
304    pub value: String,
305}
306
307impl fidl::Persistable for RemoteControlEchoStringRequest {}
308
309#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
310pub struct RemoteControlEchoStringResponse {
311    pub response: String,
312}
313
314impl fidl::Persistable for RemoteControlEchoStringResponse {}
315
316#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
317#[repr(C)]
318pub struct RemoteControlGetBootTimeResponse {
319    pub time: fidl::BootInstant,
320}
321
322impl fidl::Persistable for RemoteControlGetBootTimeResponse {}
323
324#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
325#[repr(C)]
326pub struct RemoteControlGetTimeResponse {
327    pub time: fidl::MonotonicInstant,
328}
329
330impl fidl::Persistable for RemoteControlGetTimeResponse {}
331
332#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
333pub struct RemoteControlLogMessageRequest {
334    pub tag: String,
335    pub message: String,
336    pub severity: fidl_fuchsia_diagnostics_types__common::Severity,
337}
338
339impl fidl::Persistable for RemoteControlLogMessageRequest {}
340
341#[derive(Clone, Debug, PartialEq)]
342pub struct RemoteControlIdentifyHostResponse {
343    pub response: IdentifyHostResponse,
344}
345
346impl fidl::Persistable for RemoteControlIdentifyHostResponse {}
347
348#[derive(Clone, Debug, Default, PartialEq)]
349pub struct IdentifyHostResponse {
350    pub nodename: Option<String>,
351    pub boot_timestamp_nanos: Option<u64>,
352    pub serial_number: Option<String>,
353    pub ids: Option<Vec<u64>>,
354    pub product_config: Option<String>,
355    pub board_config: Option<String>,
356    pub addresses: Option<Vec<fidl_fuchsia_net__common::Subnet>>,
357    pub boot_id: Option<u64>,
358    #[doc(hidden)]
359    pub __source_breaking: fidl::marker::SourceBreaking,
360}
361
362impl fidl::Persistable for IdentifyHostResponse {}
363
364pub mod remote_control_ordinals {
365    pub const ECHO_STRING: u64 = 0x2bbec7ca8a72e82b;
366    pub const LOG_MESSAGE: u64 = 0x3da84acd5bbf3926;
367    pub const IDENTIFY_HOST: u64 = 0x6035e1ab368deee1;
368    pub const CONNECT_CAPABILITY: u64 = 0x3ae7a7c874dceceb;
369    pub const GET_TIME: u64 = 0x3588f31e9067748d;
370    pub const GET_BOOT_TIME: u64 = 0x55706f013cd79ebd;
371    pub const DEPRECATED_OPEN_CAPABILITY: u64 = 0x51b5801f3e27e431;
372}
373
374mod internal {
375    use super::*;
376    unsafe impl fidl::encoding::TypeMarker for CompatibilityState {
377        type Owned = Self;
378
379        #[inline(always)]
380        fn inline_align(_context: fidl::encoding::Context) -> usize {
381            std::mem::align_of::<u32>()
382        }
383
384        #[inline(always)]
385        fn inline_size(_context: fidl::encoding::Context) -> usize {
386            std::mem::size_of::<u32>()
387        }
388
389        #[inline(always)]
390        fn encode_is_copy() -> bool {
391            false
392        }
393
394        #[inline(always)]
395        fn decode_is_copy() -> bool {
396            false
397        }
398    }
399
400    impl fidl::encoding::ValueTypeMarker for CompatibilityState {
401        type Borrowed<'a> = Self;
402        #[inline(always)]
403        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
404            *value
405        }
406    }
407
408    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
409        for CompatibilityState
410    {
411        #[inline]
412        unsafe fn encode(
413            self,
414            encoder: &mut fidl::encoding::Encoder<'_, D>,
415            offset: usize,
416            _depth: fidl::encoding::Depth,
417        ) -> fidl::Result<()> {
418            encoder.debug_check_bounds::<Self>(offset);
419            encoder.write_num(self.into_primitive(), offset);
420            Ok(())
421        }
422    }
423
424    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompatibilityState {
425        #[inline(always)]
426        fn new_empty() -> Self {
427            Self::unknown()
428        }
429
430        #[inline]
431        unsafe fn decode(
432            &mut self,
433            decoder: &mut fidl::encoding::Decoder<'_, D>,
434            offset: usize,
435            _depth: fidl::encoding::Depth,
436        ) -> fidl::Result<()> {
437            decoder.debug_check_bounds::<Self>(offset);
438            let prim = decoder.read_num::<u32>(offset);
439
440            *self = Self::from_primitive_allow_unknown(prim);
441            Ok(())
442        }
443    }
444    unsafe impl fidl::encoding::TypeMarker for ConnectCapabilityError {
445        type Owned = Self;
446
447        #[inline(always)]
448        fn inline_align(_context: fidl::encoding::Context) -> usize {
449            std::mem::align_of::<u32>()
450        }
451
452        #[inline(always)]
453        fn inline_size(_context: fidl::encoding::Context) -> usize {
454            std::mem::size_of::<u32>()
455        }
456
457        #[inline(always)]
458        fn encode_is_copy() -> bool {
459            false
460        }
461
462        #[inline(always)]
463        fn decode_is_copy() -> bool {
464            false
465        }
466    }
467
468    impl fidl::encoding::ValueTypeMarker for ConnectCapabilityError {
469        type Borrowed<'a> = Self;
470        #[inline(always)]
471        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
472            *value
473        }
474    }
475
476    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
477        for ConnectCapabilityError
478    {
479        #[inline]
480        unsafe fn encode(
481            self,
482            encoder: &mut fidl::encoding::Encoder<'_, D>,
483            offset: usize,
484            _depth: fidl::encoding::Depth,
485        ) -> fidl::Result<()> {
486            encoder.debug_check_bounds::<Self>(offset);
487            encoder.write_num(self.into_primitive(), offset);
488            Ok(())
489        }
490    }
491
492    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
493        for ConnectCapabilityError
494    {
495        #[inline(always)]
496        fn new_empty() -> Self {
497            Self::unknown()
498        }
499
500        #[inline]
501        unsafe fn decode(
502            &mut self,
503            decoder: &mut fidl::encoding::Decoder<'_, D>,
504            offset: usize,
505            _depth: fidl::encoding::Depth,
506        ) -> fidl::Result<()> {
507            decoder.debug_check_bounds::<Self>(offset);
508            let prim = decoder.read_num::<u32>(offset);
509
510            *self = Self::from_primitive_allow_unknown(prim);
511            Ok(())
512        }
513    }
514    unsafe impl fidl::encoding::TypeMarker for IdentifyHostError {
515        type Owned = Self;
516
517        #[inline(always)]
518        fn inline_align(_context: fidl::encoding::Context) -> usize {
519            std::mem::align_of::<u32>()
520        }
521
522        #[inline(always)]
523        fn inline_size(_context: fidl::encoding::Context) -> usize {
524            std::mem::size_of::<u32>()
525        }
526
527        #[inline(always)]
528        fn encode_is_copy() -> bool {
529            false
530        }
531
532        #[inline(always)]
533        fn decode_is_copy() -> bool {
534            false
535        }
536    }
537
538    impl fidl::encoding::ValueTypeMarker for IdentifyHostError {
539        type Borrowed<'a> = Self;
540        #[inline(always)]
541        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
542            *value
543        }
544    }
545
546    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
547        for IdentifyHostError
548    {
549        #[inline]
550        unsafe fn encode(
551            self,
552            encoder: &mut fidl::encoding::Encoder<'_, D>,
553            offset: usize,
554            _depth: fidl::encoding::Depth,
555        ) -> fidl::Result<()> {
556            encoder.debug_check_bounds::<Self>(offset);
557            encoder.write_num(self.into_primitive(), offset);
558            Ok(())
559        }
560    }
561
562    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IdentifyHostError {
563        #[inline(always)]
564        fn new_empty() -> Self {
565            Self::unknown()
566        }
567
568        #[inline]
569        unsafe fn decode(
570            &mut self,
571            decoder: &mut fidl::encoding::Decoder<'_, D>,
572            offset: usize,
573            _depth: fidl::encoding::Depth,
574        ) -> fidl::Result<()> {
575            decoder.debug_check_bounds::<Self>(offset);
576            let prim = decoder.read_num::<u32>(offset);
577
578            *self = Self::from_primitive_allow_unknown(prim);
579            Ok(())
580        }
581    }
582    unsafe impl fidl::encoding::TypeMarker for TunnelError {
583        type Owned = Self;
584
585        #[inline(always)]
586        fn inline_align(_context: fidl::encoding::Context) -> usize {
587            std::mem::align_of::<u32>()
588        }
589
590        #[inline(always)]
591        fn inline_size(_context: fidl::encoding::Context) -> usize {
592            std::mem::size_of::<u32>()
593        }
594
595        #[inline(always)]
596        fn encode_is_copy() -> bool {
597            false
598        }
599
600        #[inline(always)]
601        fn decode_is_copy() -> bool {
602            false
603        }
604    }
605
606    impl fidl::encoding::ValueTypeMarker for TunnelError {
607        type Borrowed<'a> = Self;
608        #[inline(always)]
609        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
610            *value
611        }
612    }
613
614    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for TunnelError {
615        #[inline]
616        unsafe fn encode(
617            self,
618            encoder: &mut fidl::encoding::Encoder<'_, D>,
619            offset: usize,
620            _depth: fidl::encoding::Depth,
621        ) -> fidl::Result<()> {
622            encoder.debug_check_bounds::<Self>(offset);
623            encoder.write_num(self.into_primitive(), offset);
624            Ok(())
625        }
626    }
627
628    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TunnelError {
629        #[inline(always)]
630        fn new_empty() -> Self {
631            Self::unknown()
632        }
633
634        #[inline]
635        unsafe fn decode(
636            &mut self,
637            decoder: &mut fidl::encoding::Decoder<'_, D>,
638            offset: usize,
639            _depth: fidl::encoding::Depth,
640        ) -> fidl::Result<()> {
641            decoder.debug_check_bounds::<Self>(offset);
642            let prim = decoder.read_num::<u32>(offset);
643
644            *self = Self::from_primitive_allow_unknown(prim);
645            Ok(())
646        }
647    }
648
649    impl fidl::encoding::ValueTypeMarker for CompatibilityInfo {
650        type Borrowed<'a> = &'a Self;
651        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
652            value
653        }
654    }
655
656    unsafe impl fidl::encoding::TypeMarker for CompatibilityInfo {
657        type Owned = Self;
658
659        #[inline(always)]
660        fn inline_align(_context: fidl::encoding::Context) -> usize {
661            8
662        }
663
664        #[inline(always)]
665        fn inline_size(_context: fidl::encoding::Context) -> usize {
666            32
667        }
668    }
669
670    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompatibilityInfo, D>
671        for &CompatibilityInfo
672    {
673        #[inline]
674        unsafe fn encode(
675            self,
676            encoder: &mut fidl::encoding::Encoder<'_, D>,
677            offset: usize,
678            _depth: fidl::encoding::Depth,
679        ) -> fidl::Result<()> {
680            encoder.debug_check_bounds::<CompatibilityInfo>(offset);
681            // Delegate to tuple encoding.
682            fidl::encoding::Encode::<CompatibilityInfo, D>::encode(
683                (
684                    <CompatibilityState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
685                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.platform_abi),
686                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
687                        &self.message,
688                    ),
689                ),
690                encoder,
691                offset,
692                _depth,
693            )
694        }
695    }
696    unsafe impl<
697            D: fidl::encoding::ResourceDialect,
698            T0: fidl::encoding::Encode<CompatibilityState, D>,
699            T1: fidl::encoding::Encode<u64, D>,
700            T2: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
701        > fidl::encoding::Encode<CompatibilityInfo, D> for (T0, T1, T2)
702    {
703        #[inline]
704        unsafe fn encode(
705            self,
706            encoder: &mut fidl::encoding::Encoder<'_, D>,
707            offset: usize,
708            depth: fidl::encoding::Depth,
709        ) -> fidl::Result<()> {
710            encoder.debug_check_bounds::<CompatibilityInfo>(offset);
711            // Zero out padding regions. There's no need to apply masks
712            // because the unmasked parts will be overwritten by fields.
713            unsafe {
714                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
715                (ptr as *mut u64).write_unaligned(0);
716            }
717            // Write the fields.
718            self.0.encode(encoder, offset + 0, depth)?;
719            self.1.encode(encoder, offset + 8, depth)?;
720            self.2.encode(encoder, offset + 16, depth)?;
721            Ok(())
722        }
723    }
724
725    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompatibilityInfo {
726        #[inline(always)]
727        fn new_empty() -> Self {
728            Self {
729                state: fidl::new_empty!(CompatibilityState, D),
730                platform_abi: fidl::new_empty!(u64, D),
731                message: fidl::new_empty!(fidl::encoding::UnboundedString, D),
732            }
733        }
734
735        #[inline]
736        unsafe fn decode(
737            &mut self,
738            decoder: &mut fidl::encoding::Decoder<'_, D>,
739            offset: usize,
740            _depth: fidl::encoding::Depth,
741        ) -> fidl::Result<()> {
742            decoder.debug_check_bounds::<Self>(offset);
743            // Verify that padding bytes are zero.
744            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
745            let padval = unsafe { (ptr as *const u64).read_unaligned() };
746            let mask = 0xffffffff00000000u64;
747            let maskedval = padval & mask;
748            if maskedval != 0 {
749                return Err(fidl::Error::NonZeroPadding {
750                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
751                });
752            }
753            fidl::decode!(CompatibilityState, D, &mut self.state, decoder, offset + 0, _depth)?;
754            fidl::decode!(u64, D, &mut self.platform_abi, decoder, offset + 8, _depth)?;
755            fidl::decode!(
756                fidl::encoding::UnboundedString,
757                D,
758                &mut self.message,
759                decoder,
760                offset + 16,
761                _depth
762            )?;
763            Ok(())
764        }
765    }
766
767    impl fidl::encoding::ValueTypeMarker for RemoteControlEchoStringRequest {
768        type Borrowed<'a> = &'a Self;
769        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
770            value
771        }
772    }
773
774    unsafe impl fidl::encoding::TypeMarker for RemoteControlEchoStringRequest {
775        type Owned = Self;
776
777        #[inline(always)]
778        fn inline_align(_context: fidl::encoding::Context) -> usize {
779            8
780        }
781
782        #[inline(always)]
783        fn inline_size(_context: fidl::encoding::Context) -> usize {
784            16
785        }
786    }
787
788    unsafe impl<D: fidl::encoding::ResourceDialect>
789        fidl::encoding::Encode<RemoteControlEchoStringRequest, D>
790        for &RemoteControlEchoStringRequest
791    {
792        #[inline]
793        unsafe fn encode(
794            self,
795            encoder: &mut fidl::encoding::Encoder<'_, D>,
796            offset: usize,
797            _depth: fidl::encoding::Depth,
798        ) -> fidl::Result<()> {
799            encoder.debug_check_bounds::<RemoteControlEchoStringRequest>(offset);
800            // Delegate to tuple encoding.
801            fidl::encoding::Encode::<RemoteControlEchoStringRequest, D>::encode(
802                (<fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
803                    &self.value,
804                ),),
805                encoder,
806                offset,
807                _depth,
808            )
809        }
810    }
811    unsafe impl<
812            D: fidl::encoding::ResourceDialect,
813            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
814        > fidl::encoding::Encode<RemoteControlEchoStringRequest, D> for (T0,)
815    {
816        #[inline]
817        unsafe fn encode(
818            self,
819            encoder: &mut fidl::encoding::Encoder<'_, D>,
820            offset: usize,
821            depth: fidl::encoding::Depth,
822        ) -> fidl::Result<()> {
823            encoder.debug_check_bounds::<RemoteControlEchoStringRequest>(offset);
824            // Zero out padding regions. There's no need to apply masks
825            // because the unmasked parts will be overwritten by fields.
826            // Write the fields.
827            self.0.encode(encoder, offset + 0, depth)?;
828            Ok(())
829        }
830    }
831
832    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
833        for RemoteControlEchoStringRequest
834    {
835        #[inline(always)]
836        fn new_empty() -> Self {
837            Self { value: fidl::new_empty!(fidl::encoding::BoundedString<255>, D) }
838        }
839
840        #[inline]
841        unsafe fn decode(
842            &mut self,
843            decoder: &mut fidl::encoding::Decoder<'_, D>,
844            offset: usize,
845            _depth: fidl::encoding::Depth,
846        ) -> fidl::Result<()> {
847            decoder.debug_check_bounds::<Self>(offset);
848            // Verify that padding bytes are zero.
849            fidl::decode!(
850                fidl::encoding::BoundedString<255>,
851                D,
852                &mut self.value,
853                decoder,
854                offset + 0,
855                _depth
856            )?;
857            Ok(())
858        }
859    }
860
861    impl fidl::encoding::ValueTypeMarker for RemoteControlEchoStringResponse {
862        type Borrowed<'a> = &'a Self;
863        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
864            value
865        }
866    }
867
868    unsafe impl fidl::encoding::TypeMarker for RemoteControlEchoStringResponse {
869        type Owned = Self;
870
871        #[inline(always)]
872        fn inline_align(_context: fidl::encoding::Context) -> usize {
873            8
874        }
875
876        #[inline(always)]
877        fn inline_size(_context: fidl::encoding::Context) -> usize {
878            16
879        }
880    }
881
882    unsafe impl<D: fidl::encoding::ResourceDialect>
883        fidl::encoding::Encode<RemoteControlEchoStringResponse, D>
884        for &RemoteControlEchoStringResponse
885    {
886        #[inline]
887        unsafe fn encode(
888            self,
889            encoder: &mut fidl::encoding::Encoder<'_, D>,
890            offset: usize,
891            _depth: fidl::encoding::Depth,
892        ) -> fidl::Result<()> {
893            encoder.debug_check_bounds::<RemoteControlEchoStringResponse>(offset);
894            // Delegate to tuple encoding.
895            fidl::encoding::Encode::<RemoteControlEchoStringResponse, D>::encode(
896                (<fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
897                    &self.response,
898                ),),
899                encoder,
900                offset,
901                _depth,
902            )
903        }
904    }
905    unsafe impl<
906            D: fidl::encoding::ResourceDialect,
907            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
908        > fidl::encoding::Encode<RemoteControlEchoStringResponse, D> for (T0,)
909    {
910        #[inline]
911        unsafe fn encode(
912            self,
913            encoder: &mut fidl::encoding::Encoder<'_, D>,
914            offset: usize,
915            depth: fidl::encoding::Depth,
916        ) -> fidl::Result<()> {
917            encoder.debug_check_bounds::<RemoteControlEchoStringResponse>(offset);
918            // Zero out padding regions. There's no need to apply masks
919            // because the unmasked parts will be overwritten by fields.
920            // Write the fields.
921            self.0.encode(encoder, offset + 0, depth)?;
922            Ok(())
923        }
924    }
925
926    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
927        for RemoteControlEchoStringResponse
928    {
929        #[inline(always)]
930        fn new_empty() -> Self {
931            Self { response: fidl::new_empty!(fidl::encoding::BoundedString<255>, D) }
932        }
933
934        #[inline]
935        unsafe fn decode(
936            &mut self,
937            decoder: &mut fidl::encoding::Decoder<'_, D>,
938            offset: usize,
939            _depth: fidl::encoding::Depth,
940        ) -> fidl::Result<()> {
941            decoder.debug_check_bounds::<Self>(offset);
942            // Verify that padding bytes are zero.
943            fidl::decode!(
944                fidl::encoding::BoundedString<255>,
945                D,
946                &mut self.response,
947                decoder,
948                offset + 0,
949                _depth
950            )?;
951            Ok(())
952        }
953    }
954
955    impl fidl::encoding::ValueTypeMarker for RemoteControlGetBootTimeResponse {
956        type Borrowed<'a> = &'a Self;
957        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
958            value
959        }
960    }
961
962    unsafe impl fidl::encoding::TypeMarker for RemoteControlGetBootTimeResponse {
963        type Owned = Self;
964
965        #[inline(always)]
966        fn inline_align(_context: fidl::encoding::Context) -> usize {
967            8
968        }
969
970        #[inline(always)]
971        fn inline_size(_context: fidl::encoding::Context) -> usize {
972            8
973        }
974        #[inline(always)]
975        fn encode_is_copy() -> bool {
976            true
977        }
978
979        #[inline(always)]
980        fn decode_is_copy() -> bool {
981            true
982        }
983    }
984
985    unsafe impl<D: fidl::encoding::ResourceDialect>
986        fidl::encoding::Encode<RemoteControlGetBootTimeResponse, D>
987        for &RemoteControlGetBootTimeResponse
988    {
989        #[inline]
990        unsafe fn encode(
991            self,
992            encoder: &mut fidl::encoding::Encoder<'_, D>,
993            offset: usize,
994            _depth: fidl::encoding::Depth,
995        ) -> fidl::Result<()> {
996            encoder.debug_check_bounds::<RemoteControlGetBootTimeResponse>(offset);
997            unsafe {
998                // Copy the object into the buffer.
999                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1000                (buf_ptr as *mut RemoteControlGetBootTimeResponse)
1001                    .write_unaligned((self as *const RemoteControlGetBootTimeResponse).read());
1002                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1003                // done second because the memcpy will write garbage to these bytes.
1004            }
1005            Ok(())
1006        }
1007    }
1008    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<fidl::BootInstant, D>>
1009        fidl::encoding::Encode<RemoteControlGetBootTimeResponse, D> for (T0,)
1010    {
1011        #[inline]
1012        unsafe fn encode(
1013            self,
1014            encoder: &mut fidl::encoding::Encoder<'_, D>,
1015            offset: usize,
1016            depth: fidl::encoding::Depth,
1017        ) -> fidl::Result<()> {
1018            encoder.debug_check_bounds::<RemoteControlGetBootTimeResponse>(offset);
1019            // Zero out padding regions. There's no need to apply masks
1020            // because the unmasked parts will be overwritten by fields.
1021            // Write the fields.
1022            self.0.encode(encoder, offset + 0, depth)?;
1023            Ok(())
1024        }
1025    }
1026
1027    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1028        for RemoteControlGetBootTimeResponse
1029    {
1030        #[inline(always)]
1031        fn new_empty() -> Self {
1032            Self { time: fidl::new_empty!(fidl::BootInstant, D) }
1033        }
1034
1035        #[inline]
1036        unsafe fn decode(
1037            &mut self,
1038            decoder: &mut fidl::encoding::Decoder<'_, D>,
1039            offset: usize,
1040            _depth: fidl::encoding::Depth,
1041        ) -> fidl::Result<()> {
1042            decoder.debug_check_bounds::<Self>(offset);
1043            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1044            // Verify that padding bytes are zero.
1045            // Copy from the buffer into the object.
1046            unsafe {
1047                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
1048            }
1049            Ok(())
1050        }
1051    }
1052
1053    impl fidl::encoding::ValueTypeMarker for RemoteControlGetTimeResponse {
1054        type Borrowed<'a> = &'a Self;
1055        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1056            value
1057        }
1058    }
1059
1060    unsafe impl fidl::encoding::TypeMarker for RemoteControlGetTimeResponse {
1061        type Owned = Self;
1062
1063        #[inline(always)]
1064        fn inline_align(_context: fidl::encoding::Context) -> usize {
1065            8
1066        }
1067
1068        #[inline(always)]
1069        fn inline_size(_context: fidl::encoding::Context) -> usize {
1070            8
1071        }
1072        #[inline(always)]
1073        fn encode_is_copy() -> bool {
1074            true
1075        }
1076
1077        #[inline(always)]
1078        fn decode_is_copy() -> bool {
1079            true
1080        }
1081    }
1082
1083    unsafe impl<D: fidl::encoding::ResourceDialect>
1084        fidl::encoding::Encode<RemoteControlGetTimeResponse, D> for &RemoteControlGetTimeResponse
1085    {
1086        #[inline]
1087        unsafe fn encode(
1088            self,
1089            encoder: &mut fidl::encoding::Encoder<'_, D>,
1090            offset: usize,
1091            _depth: fidl::encoding::Depth,
1092        ) -> fidl::Result<()> {
1093            encoder.debug_check_bounds::<RemoteControlGetTimeResponse>(offset);
1094            unsafe {
1095                // Copy the object into the buffer.
1096                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1097                (buf_ptr as *mut RemoteControlGetTimeResponse)
1098                    .write_unaligned((self as *const RemoteControlGetTimeResponse).read());
1099                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1100                // done second because the memcpy will write garbage to these bytes.
1101            }
1102            Ok(())
1103        }
1104    }
1105    unsafe impl<
1106            D: fidl::encoding::ResourceDialect,
1107            T0: fidl::encoding::Encode<fidl::MonotonicInstant, D>,
1108        > fidl::encoding::Encode<RemoteControlGetTimeResponse, D> for (T0,)
1109    {
1110        #[inline]
1111        unsafe fn encode(
1112            self,
1113            encoder: &mut fidl::encoding::Encoder<'_, D>,
1114            offset: usize,
1115            depth: fidl::encoding::Depth,
1116        ) -> fidl::Result<()> {
1117            encoder.debug_check_bounds::<RemoteControlGetTimeResponse>(offset);
1118            // Zero out padding regions. There's no need to apply masks
1119            // because the unmasked parts will be overwritten by fields.
1120            // Write the fields.
1121            self.0.encode(encoder, offset + 0, depth)?;
1122            Ok(())
1123        }
1124    }
1125
1126    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1127        for RemoteControlGetTimeResponse
1128    {
1129        #[inline(always)]
1130        fn new_empty() -> Self {
1131            Self { time: fidl::new_empty!(fidl::MonotonicInstant, D) }
1132        }
1133
1134        #[inline]
1135        unsafe fn decode(
1136            &mut self,
1137            decoder: &mut fidl::encoding::Decoder<'_, D>,
1138            offset: usize,
1139            _depth: fidl::encoding::Depth,
1140        ) -> fidl::Result<()> {
1141            decoder.debug_check_bounds::<Self>(offset);
1142            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1143            // Verify that padding bytes are zero.
1144            // Copy from the buffer into the object.
1145            unsafe {
1146                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
1147            }
1148            Ok(())
1149        }
1150    }
1151
1152    impl fidl::encoding::ValueTypeMarker for RemoteControlLogMessageRequest {
1153        type Borrowed<'a> = &'a Self;
1154        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1155            value
1156        }
1157    }
1158
1159    unsafe impl fidl::encoding::TypeMarker for RemoteControlLogMessageRequest {
1160        type Owned = Self;
1161
1162        #[inline(always)]
1163        fn inline_align(_context: fidl::encoding::Context) -> usize {
1164            8
1165        }
1166
1167        #[inline(always)]
1168        fn inline_size(_context: fidl::encoding::Context) -> usize {
1169            40
1170        }
1171    }
1172
1173    unsafe impl<D: fidl::encoding::ResourceDialect>
1174        fidl::encoding::Encode<RemoteControlLogMessageRequest, D>
1175        for &RemoteControlLogMessageRequest
1176    {
1177        #[inline]
1178        unsafe fn encode(
1179            self,
1180            encoder: &mut fidl::encoding::Encoder<'_, D>,
1181            offset: usize,
1182            _depth: fidl::encoding::Depth,
1183        ) -> fidl::Result<()> {
1184            encoder.debug_check_bounds::<RemoteControlLogMessageRequest>(offset);
1185            // Delegate to tuple encoding.
1186            fidl::encoding::Encode::<RemoteControlLogMessageRequest, D>::encode(
1187                (
1188                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.tag),
1189                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.message),
1190                    <fidl_fuchsia_diagnostics_types__common::Severity as fidl::encoding::ValueTypeMarker>::borrow(&self.severity),
1191                ),
1192                encoder, offset, _depth
1193            )
1194        }
1195    }
1196    unsafe impl<
1197            D: fidl::encoding::ResourceDialect,
1198            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
1199            T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
1200            T2: fidl::encoding::Encode<fidl_fuchsia_diagnostics_types__common::Severity, D>,
1201        > fidl::encoding::Encode<RemoteControlLogMessageRequest, D> for (T0, T1, T2)
1202    {
1203        #[inline]
1204        unsafe fn encode(
1205            self,
1206            encoder: &mut fidl::encoding::Encoder<'_, D>,
1207            offset: usize,
1208            depth: fidl::encoding::Depth,
1209        ) -> fidl::Result<()> {
1210            encoder.debug_check_bounds::<RemoteControlLogMessageRequest>(offset);
1211            // Zero out padding regions. There's no need to apply masks
1212            // because the unmasked parts will be overwritten by fields.
1213            unsafe {
1214                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
1215                (ptr as *mut u64).write_unaligned(0);
1216            }
1217            // Write the fields.
1218            self.0.encode(encoder, offset + 0, depth)?;
1219            self.1.encode(encoder, offset + 16, depth)?;
1220            self.2.encode(encoder, offset + 32, depth)?;
1221            Ok(())
1222        }
1223    }
1224
1225    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1226        for RemoteControlLogMessageRequest
1227    {
1228        #[inline(always)]
1229        fn new_empty() -> Self {
1230            Self {
1231                tag: fidl::new_empty!(fidl::encoding::UnboundedString, D),
1232                message: fidl::new_empty!(fidl::encoding::UnboundedString, D),
1233                severity: fidl::new_empty!(fidl_fuchsia_diagnostics_types__common::Severity, D),
1234            }
1235        }
1236
1237        #[inline]
1238        unsafe fn decode(
1239            &mut self,
1240            decoder: &mut fidl::encoding::Decoder<'_, D>,
1241            offset: usize,
1242            _depth: fidl::encoding::Depth,
1243        ) -> fidl::Result<()> {
1244            decoder.debug_check_bounds::<Self>(offset);
1245            // Verify that padding bytes are zero.
1246            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
1247            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1248            let mask = 0xffffffffffffff00u64;
1249            let maskedval = padval & mask;
1250            if maskedval != 0 {
1251                return Err(fidl::Error::NonZeroPadding {
1252                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
1253                });
1254            }
1255            fidl::decode!(
1256                fidl::encoding::UnboundedString,
1257                D,
1258                &mut self.tag,
1259                decoder,
1260                offset + 0,
1261                _depth
1262            )?;
1263            fidl::decode!(
1264                fidl::encoding::UnboundedString,
1265                D,
1266                &mut self.message,
1267                decoder,
1268                offset + 16,
1269                _depth
1270            )?;
1271            fidl::decode!(
1272                fidl_fuchsia_diagnostics_types__common::Severity,
1273                D,
1274                &mut self.severity,
1275                decoder,
1276                offset + 32,
1277                _depth
1278            )?;
1279            Ok(())
1280        }
1281    }
1282
1283    impl fidl::encoding::ValueTypeMarker for RemoteControlIdentifyHostResponse {
1284        type Borrowed<'a> = &'a Self;
1285        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1286            value
1287        }
1288    }
1289
1290    unsafe impl fidl::encoding::TypeMarker for RemoteControlIdentifyHostResponse {
1291        type Owned = Self;
1292
1293        #[inline(always)]
1294        fn inline_align(_context: fidl::encoding::Context) -> usize {
1295            8
1296        }
1297
1298        #[inline(always)]
1299        fn inline_size(_context: fidl::encoding::Context) -> usize {
1300            16
1301        }
1302    }
1303
1304    unsafe impl<D: fidl::encoding::ResourceDialect>
1305        fidl::encoding::Encode<RemoteControlIdentifyHostResponse, D>
1306        for &RemoteControlIdentifyHostResponse
1307    {
1308        #[inline]
1309        unsafe fn encode(
1310            self,
1311            encoder: &mut fidl::encoding::Encoder<'_, D>,
1312            offset: usize,
1313            _depth: fidl::encoding::Depth,
1314        ) -> fidl::Result<()> {
1315            encoder.debug_check_bounds::<RemoteControlIdentifyHostResponse>(offset);
1316            // Delegate to tuple encoding.
1317            fidl::encoding::Encode::<RemoteControlIdentifyHostResponse, D>::encode(
1318                (<IdentifyHostResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.response),),
1319                encoder,
1320                offset,
1321                _depth,
1322            )
1323        }
1324    }
1325    unsafe impl<
1326            D: fidl::encoding::ResourceDialect,
1327            T0: fidl::encoding::Encode<IdentifyHostResponse, D>,
1328        > fidl::encoding::Encode<RemoteControlIdentifyHostResponse, D> for (T0,)
1329    {
1330        #[inline]
1331        unsafe fn encode(
1332            self,
1333            encoder: &mut fidl::encoding::Encoder<'_, D>,
1334            offset: usize,
1335            depth: fidl::encoding::Depth,
1336        ) -> fidl::Result<()> {
1337            encoder.debug_check_bounds::<RemoteControlIdentifyHostResponse>(offset);
1338            // Zero out padding regions. There's no need to apply masks
1339            // because the unmasked parts will be overwritten by fields.
1340            // Write the fields.
1341            self.0.encode(encoder, offset + 0, depth)?;
1342            Ok(())
1343        }
1344    }
1345
1346    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1347        for RemoteControlIdentifyHostResponse
1348    {
1349        #[inline(always)]
1350        fn new_empty() -> Self {
1351            Self { response: fidl::new_empty!(IdentifyHostResponse, D) }
1352        }
1353
1354        #[inline]
1355        unsafe fn decode(
1356            &mut self,
1357            decoder: &mut fidl::encoding::Decoder<'_, D>,
1358            offset: usize,
1359            _depth: fidl::encoding::Depth,
1360        ) -> fidl::Result<()> {
1361            decoder.debug_check_bounds::<Self>(offset);
1362            // Verify that padding bytes are zero.
1363            fidl::decode!(
1364                IdentifyHostResponse,
1365                D,
1366                &mut self.response,
1367                decoder,
1368                offset + 0,
1369                _depth
1370            )?;
1371            Ok(())
1372        }
1373    }
1374
1375    impl IdentifyHostResponse {
1376        #[inline(always)]
1377        fn max_ordinal_present(&self) -> u64 {
1378            if let Some(_) = self.boot_id {
1379                return 9;
1380            }
1381            if let Some(_) = self.addresses {
1382                return 8;
1383            }
1384            if let Some(_) = self.board_config {
1385                return 7;
1386            }
1387            if let Some(_) = self.product_config {
1388                return 6;
1389            }
1390            if let Some(_) = self.ids {
1391                return 5;
1392            }
1393            if let Some(_) = self.serial_number {
1394                return 4;
1395            }
1396            if let Some(_) = self.boot_timestamp_nanos {
1397                return 3;
1398            }
1399            if let Some(_) = self.nodename {
1400                return 2;
1401            }
1402            0
1403        }
1404    }
1405
1406    impl fidl::encoding::ValueTypeMarker for IdentifyHostResponse {
1407        type Borrowed<'a> = &'a Self;
1408        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1409            value
1410        }
1411    }
1412
1413    unsafe impl fidl::encoding::TypeMarker for IdentifyHostResponse {
1414        type Owned = Self;
1415
1416        #[inline(always)]
1417        fn inline_align(_context: fidl::encoding::Context) -> usize {
1418            8
1419        }
1420
1421        #[inline(always)]
1422        fn inline_size(_context: fidl::encoding::Context) -> usize {
1423            16
1424        }
1425    }
1426
1427    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<IdentifyHostResponse, D>
1428        for &IdentifyHostResponse
1429    {
1430        unsafe fn encode(
1431            self,
1432            encoder: &mut fidl::encoding::Encoder<'_, D>,
1433            offset: usize,
1434            mut depth: fidl::encoding::Depth,
1435        ) -> fidl::Result<()> {
1436            encoder.debug_check_bounds::<IdentifyHostResponse>(offset);
1437            // Vector header
1438            let max_ordinal: u64 = self.max_ordinal_present();
1439            encoder.write_num(max_ordinal, offset);
1440            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1441            // Calling encoder.out_of_line_offset(0) is not allowed.
1442            if max_ordinal == 0 {
1443                return Ok(());
1444            }
1445            depth.increment()?;
1446            let envelope_size = 8;
1447            let bytes_len = max_ordinal as usize * envelope_size;
1448            #[allow(unused_variables)]
1449            let offset = encoder.out_of_line_offset(bytes_len);
1450            let mut _prev_end_offset: usize = 0;
1451            if 2 > max_ordinal {
1452                return Ok(());
1453            }
1454
1455            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1456            // are envelope_size bytes.
1457            let cur_offset: usize = (2 - 1) * envelope_size;
1458
1459            // Zero reserved fields.
1460            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1461
1462            // Safety:
1463            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1464            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1465            //   envelope_size bytes, there is always sufficient room.
1466            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1467                self.nodename.as_ref().map(
1468                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1469                ),
1470                encoder,
1471                offset + cur_offset,
1472                depth,
1473            )?;
1474
1475            _prev_end_offset = cur_offset + envelope_size;
1476            if 3 > max_ordinal {
1477                return Ok(());
1478            }
1479
1480            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1481            // are envelope_size bytes.
1482            let cur_offset: usize = (3 - 1) * envelope_size;
1483
1484            // Zero reserved fields.
1485            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1486
1487            // Safety:
1488            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1489            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1490            //   envelope_size bytes, there is always sufficient room.
1491            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1492                self.boot_timestamp_nanos
1493                    .as_ref()
1494                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1495                encoder,
1496                offset + cur_offset,
1497                depth,
1498            )?;
1499
1500            _prev_end_offset = cur_offset + envelope_size;
1501            if 4 > max_ordinal {
1502                return Ok(());
1503            }
1504
1505            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1506            // are envelope_size bytes.
1507            let cur_offset: usize = (4 - 1) * envelope_size;
1508
1509            // Zero reserved fields.
1510            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1511
1512            // Safety:
1513            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1514            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1515            //   envelope_size bytes, there is always sufficient room.
1516            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
1517                self.serial_number.as_ref().map(
1518                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
1519                ),
1520                encoder,
1521                offset + cur_offset,
1522                depth,
1523            )?;
1524
1525            _prev_end_offset = cur_offset + envelope_size;
1526            if 5 > max_ordinal {
1527                return Ok(());
1528            }
1529
1530            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1531            // are envelope_size bytes.
1532            let cur_offset: usize = (5 - 1) * envelope_size;
1533
1534            // Zero reserved fields.
1535            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1536
1537            // Safety:
1538            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1539            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1540            //   envelope_size bytes, there is always sufficient room.
1541            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u64>, D>(
1542            self.ids.as_ref().map(<fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow),
1543            encoder, offset + cur_offset, depth
1544        )?;
1545
1546            _prev_end_offset = cur_offset + envelope_size;
1547            if 6 > max_ordinal {
1548                return Ok(());
1549            }
1550
1551            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1552            // are envelope_size bytes.
1553            let cur_offset: usize = (6 - 1) * envelope_size;
1554
1555            // Zero reserved fields.
1556            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1557
1558            // Safety:
1559            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1560            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1561            //   envelope_size bytes, there is always sufficient room.
1562            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
1563                self.product_config.as_ref().map(
1564                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
1565                ),
1566                encoder,
1567                offset + cur_offset,
1568                depth,
1569            )?;
1570
1571            _prev_end_offset = cur_offset + envelope_size;
1572            if 7 > max_ordinal {
1573                return Ok(());
1574            }
1575
1576            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1577            // are envelope_size bytes.
1578            let cur_offset: usize = (7 - 1) * envelope_size;
1579
1580            // Zero reserved fields.
1581            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1582
1583            // Safety:
1584            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1585            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1586            //   envelope_size bytes, there is always sufficient room.
1587            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
1588                self.board_config.as_ref().map(
1589                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
1590                ),
1591                encoder,
1592                offset + cur_offset,
1593                depth,
1594            )?;
1595
1596            _prev_end_offset = cur_offset + envelope_size;
1597            if 8 > max_ordinal {
1598                return Ok(());
1599            }
1600
1601            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1602            // are envelope_size bytes.
1603            let cur_offset: usize = (8 - 1) * envelope_size;
1604
1605            // Zero reserved fields.
1606            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1607
1608            // Safety:
1609            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1610            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1611            //   envelope_size bytes, there is always sufficient room.
1612            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_net__common::Subnet>, D>(
1613            self.addresses.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_net__common::Subnet> as fidl::encoding::ValueTypeMarker>::borrow),
1614            encoder, offset + cur_offset, depth
1615        )?;
1616
1617            _prev_end_offset = cur_offset + envelope_size;
1618            if 9 > max_ordinal {
1619                return Ok(());
1620            }
1621
1622            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1623            // are envelope_size bytes.
1624            let cur_offset: usize = (9 - 1) * envelope_size;
1625
1626            // Zero reserved fields.
1627            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1628
1629            // Safety:
1630            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1631            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1632            //   envelope_size bytes, there is always sufficient room.
1633            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1634                self.boot_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1635                encoder,
1636                offset + cur_offset,
1637                depth,
1638            )?;
1639
1640            _prev_end_offset = cur_offset + envelope_size;
1641
1642            Ok(())
1643        }
1644    }
1645
1646    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IdentifyHostResponse {
1647        #[inline(always)]
1648        fn new_empty() -> Self {
1649            Self::default()
1650        }
1651
1652        unsafe fn decode(
1653            &mut self,
1654            decoder: &mut fidl::encoding::Decoder<'_, D>,
1655            offset: usize,
1656            mut depth: fidl::encoding::Depth,
1657        ) -> fidl::Result<()> {
1658            decoder.debug_check_bounds::<Self>(offset);
1659            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1660                None => return Err(fidl::Error::NotNullable),
1661                Some(len) => len,
1662            };
1663            // Calling decoder.out_of_line_offset(0) is not allowed.
1664            if len == 0 {
1665                return Ok(());
1666            };
1667            depth.increment()?;
1668            let envelope_size = 8;
1669            let bytes_len = len * envelope_size;
1670            let offset = decoder.out_of_line_offset(bytes_len)?;
1671            // Decode the envelope for each type.
1672            let mut _next_ordinal_to_read = 0;
1673            let mut next_offset = offset;
1674            let end_offset = offset + bytes_len;
1675            _next_ordinal_to_read += 1;
1676            if next_offset >= end_offset {
1677                return Ok(());
1678            }
1679
1680            // Decode unknown envelopes for gaps in ordinals.
1681            while _next_ordinal_to_read < 2 {
1682                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1683                _next_ordinal_to_read += 1;
1684                next_offset += envelope_size;
1685            }
1686
1687            let next_out_of_line = decoder.next_out_of_line();
1688            let handles_before = decoder.remaining_handles();
1689            if let Some((inlined, num_bytes, num_handles)) =
1690                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1691            {
1692                let member_inline_size =
1693                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
1694                        decoder.context,
1695                    );
1696                if inlined != (member_inline_size <= 4) {
1697                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1698                }
1699                let inner_offset;
1700                let mut inner_depth = depth.clone();
1701                if inlined {
1702                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1703                    inner_offset = next_offset;
1704                } else {
1705                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1706                    inner_depth.increment()?;
1707                }
1708                let val_ref = self
1709                    .nodename
1710                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
1711                fidl::decode!(
1712                    fidl::encoding::BoundedString<255>,
1713                    D,
1714                    val_ref,
1715                    decoder,
1716                    inner_offset,
1717                    inner_depth
1718                )?;
1719                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1720                {
1721                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1722                }
1723                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1724                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1725                }
1726            }
1727
1728            next_offset += envelope_size;
1729            _next_ordinal_to_read += 1;
1730            if next_offset >= end_offset {
1731                return Ok(());
1732            }
1733
1734            // Decode unknown envelopes for gaps in ordinals.
1735            while _next_ordinal_to_read < 3 {
1736                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1737                _next_ordinal_to_read += 1;
1738                next_offset += envelope_size;
1739            }
1740
1741            let next_out_of_line = decoder.next_out_of_line();
1742            let handles_before = decoder.remaining_handles();
1743            if let Some((inlined, num_bytes, num_handles)) =
1744                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1745            {
1746                let member_inline_size =
1747                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1748                if inlined != (member_inline_size <= 4) {
1749                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1750                }
1751                let inner_offset;
1752                let mut inner_depth = depth.clone();
1753                if inlined {
1754                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1755                    inner_offset = next_offset;
1756                } else {
1757                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1758                    inner_depth.increment()?;
1759                }
1760                let val_ref =
1761                    self.boot_timestamp_nanos.get_or_insert_with(|| fidl::new_empty!(u64, D));
1762                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1763                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1764                {
1765                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1766                }
1767                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1768                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1769                }
1770            }
1771
1772            next_offset += envelope_size;
1773            _next_ordinal_to_read += 1;
1774            if next_offset >= end_offset {
1775                return Ok(());
1776            }
1777
1778            // Decode unknown envelopes for gaps in ordinals.
1779            while _next_ordinal_to_read < 4 {
1780                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1781                _next_ordinal_to_read += 1;
1782                next_offset += envelope_size;
1783            }
1784
1785            let next_out_of_line = decoder.next_out_of_line();
1786            let handles_before = decoder.remaining_handles();
1787            if let Some((inlined, num_bytes, num_handles)) =
1788                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1789            {
1790                let member_inline_size =
1791                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
1792                        decoder.context,
1793                    );
1794                if inlined != (member_inline_size <= 4) {
1795                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1796                }
1797                let inner_offset;
1798                let mut inner_depth = depth.clone();
1799                if inlined {
1800                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1801                    inner_offset = next_offset;
1802                } else {
1803                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1804                    inner_depth.increment()?;
1805                }
1806                let val_ref = self
1807                    .serial_number
1808                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
1809                fidl::decode!(
1810                    fidl::encoding::BoundedString<255>,
1811                    D,
1812                    val_ref,
1813                    decoder,
1814                    inner_offset,
1815                    inner_depth
1816                )?;
1817                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1818                {
1819                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1820                }
1821                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1822                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1823                }
1824            }
1825
1826            next_offset += envelope_size;
1827            _next_ordinal_to_read += 1;
1828            if next_offset >= end_offset {
1829                return Ok(());
1830            }
1831
1832            // Decode unknown envelopes for gaps in ordinals.
1833            while _next_ordinal_to_read < 5 {
1834                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1835                _next_ordinal_to_read += 1;
1836                next_offset += envelope_size;
1837            }
1838
1839            let next_out_of_line = decoder.next_out_of_line();
1840            let handles_before = decoder.remaining_handles();
1841            if let Some((inlined, num_bytes, num_handles)) =
1842                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1843            {
1844                let member_inline_size = <fidl::encoding::UnboundedVector<u64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1845                if inlined != (member_inline_size <= 4) {
1846                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1847                }
1848                let inner_offset;
1849                let mut inner_depth = depth.clone();
1850                if inlined {
1851                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1852                    inner_offset = next_offset;
1853                } else {
1854                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1855                    inner_depth.increment()?;
1856                }
1857                let val_ref = self.ids.get_or_insert_with(|| {
1858                    fidl::new_empty!(fidl::encoding::UnboundedVector<u64>, D)
1859                });
1860                fidl::decode!(
1861                    fidl::encoding::UnboundedVector<u64>,
1862                    D,
1863                    val_ref,
1864                    decoder,
1865                    inner_offset,
1866                    inner_depth
1867                )?;
1868                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1869                {
1870                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1871                }
1872                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1873                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1874                }
1875            }
1876
1877            next_offset += envelope_size;
1878            _next_ordinal_to_read += 1;
1879            if next_offset >= end_offset {
1880                return Ok(());
1881            }
1882
1883            // Decode unknown envelopes for gaps in ordinals.
1884            while _next_ordinal_to_read < 6 {
1885                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1886                _next_ordinal_to_read += 1;
1887                next_offset += envelope_size;
1888            }
1889
1890            let next_out_of_line = decoder.next_out_of_line();
1891            let handles_before = decoder.remaining_handles();
1892            if let Some((inlined, num_bytes, num_handles)) =
1893                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1894            {
1895                let member_inline_size =
1896                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
1897                        decoder.context,
1898                    );
1899                if inlined != (member_inline_size <= 4) {
1900                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1901                }
1902                let inner_offset;
1903                let mut inner_depth = depth.clone();
1904                if inlined {
1905                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1906                    inner_offset = next_offset;
1907                } else {
1908                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1909                    inner_depth.increment()?;
1910                }
1911                let val_ref = self
1912                    .product_config
1913                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
1914                fidl::decode!(
1915                    fidl::encoding::BoundedString<100>,
1916                    D,
1917                    val_ref,
1918                    decoder,
1919                    inner_offset,
1920                    inner_depth
1921                )?;
1922                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1923                {
1924                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1925                }
1926                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1927                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1928                }
1929            }
1930
1931            next_offset += envelope_size;
1932            _next_ordinal_to_read += 1;
1933            if next_offset >= end_offset {
1934                return Ok(());
1935            }
1936
1937            // Decode unknown envelopes for gaps in ordinals.
1938            while _next_ordinal_to_read < 7 {
1939                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1940                _next_ordinal_to_read += 1;
1941                next_offset += envelope_size;
1942            }
1943
1944            let next_out_of_line = decoder.next_out_of_line();
1945            let handles_before = decoder.remaining_handles();
1946            if let Some((inlined, num_bytes, num_handles)) =
1947                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1948            {
1949                let member_inline_size =
1950                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
1951                        decoder.context,
1952                    );
1953                if inlined != (member_inline_size <= 4) {
1954                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1955                }
1956                let inner_offset;
1957                let mut inner_depth = depth.clone();
1958                if inlined {
1959                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1960                    inner_offset = next_offset;
1961                } else {
1962                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1963                    inner_depth.increment()?;
1964                }
1965                let val_ref = self
1966                    .board_config
1967                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
1968                fidl::decode!(
1969                    fidl::encoding::BoundedString<100>,
1970                    D,
1971                    val_ref,
1972                    decoder,
1973                    inner_offset,
1974                    inner_depth
1975                )?;
1976                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1977                {
1978                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1979                }
1980                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1981                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1982                }
1983            }
1984
1985            next_offset += envelope_size;
1986            _next_ordinal_to_read += 1;
1987            if next_offset >= end_offset {
1988                return Ok(());
1989            }
1990
1991            // Decode unknown envelopes for gaps in ordinals.
1992            while _next_ordinal_to_read < 8 {
1993                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1994                _next_ordinal_to_read += 1;
1995                next_offset += envelope_size;
1996            }
1997
1998            let next_out_of_line = decoder.next_out_of_line();
1999            let handles_before = decoder.remaining_handles();
2000            if let Some((inlined, num_bytes, num_handles)) =
2001                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2002            {
2003                let member_inline_size = <fidl::encoding::UnboundedVector<
2004                    fidl_fuchsia_net__common::Subnet,
2005                > as fidl::encoding::TypeMarker>::inline_size(
2006                    decoder.context
2007                );
2008                if inlined != (member_inline_size <= 4) {
2009                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2010                }
2011                let inner_offset;
2012                let mut inner_depth = depth.clone();
2013                if inlined {
2014                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2015                    inner_offset = next_offset;
2016                } else {
2017                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2018                    inner_depth.increment()?;
2019                }
2020                let val_ref = self.addresses.get_or_insert_with(|| {
2021                    fidl::new_empty!(
2022                        fidl::encoding::UnboundedVector<fidl_fuchsia_net__common::Subnet>,
2023                        D
2024                    )
2025                });
2026                fidl::decode!(
2027                    fidl::encoding::UnboundedVector<fidl_fuchsia_net__common::Subnet>,
2028                    D,
2029                    val_ref,
2030                    decoder,
2031                    inner_offset,
2032                    inner_depth
2033                )?;
2034                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2035                {
2036                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2037                }
2038                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2039                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2040                }
2041            }
2042
2043            next_offset += envelope_size;
2044            _next_ordinal_to_read += 1;
2045            if next_offset >= end_offset {
2046                return Ok(());
2047            }
2048
2049            // Decode unknown envelopes for gaps in ordinals.
2050            while _next_ordinal_to_read < 9 {
2051                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2052                _next_ordinal_to_read += 1;
2053                next_offset += envelope_size;
2054            }
2055
2056            let next_out_of_line = decoder.next_out_of_line();
2057            let handles_before = decoder.remaining_handles();
2058            if let Some((inlined, num_bytes, num_handles)) =
2059                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2060            {
2061                let member_inline_size =
2062                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2063                if inlined != (member_inline_size <= 4) {
2064                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2065                }
2066                let inner_offset;
2067                let mut inner_depth = depth.clone();
2068                if inlined {
2069                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2070                    inner_offset = next_offset;
2071                } else {
2072                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2073                    inner_depth.increment()?;
2074                }
2075                let val_ref = self.boot_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
2076                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2077                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2078                {
2079                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2080                }
2081                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2082                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2083                }
2084            }
2085
2086            next_offset += envelope_size;
2087
2088            // Decode the remaining unknown envelopes.
2089            while next_offset < end_offset {
2090                _next_ordinal_to_read += 1;
2091                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2092                next_offset += envelope_size;
2093            }
2094
2095            Ok(())
2096        }
2097    }
2098}