fidl_fuchsia_lowpan_test__common/
fidl_fuchsia_lowpan_test__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
11/// Maximum number of addresses that can be in the address filter list.
12pub const MAX_FILTERED: u16 = 100;
13
14pub const MAX_NEIGHBORS: u32 = 1024;
15
16/// Describes the address filtering mode of the interface.
17#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
18#[repr(i32)]
19pub enum MacAddressFilterMode {
20    /// Address filtering is disabled. All packets that are
21    /// received are processed normally.
22    Disabled = 0,
23    /// Only packets that have addresses matching an address
24    /// in the filter list will be allowed to be processed.
25    /// All other packets are dropped as if they were never
26    /// received.
27    ///
28    /// Additionally, if an RSSI value was associated
29    /// with an item, that value will be substituted for internal
30    /// routing considerations.
31    Allow = 1,
32    /// All packets from addresses in the filter list will be
33    /// dropped.
34    Deny = 2,
35}
36
37impl MacAddressFilterMode {
38    #[inline]
39    pub fn from_primitive(prim: i32) -> Option<Self> {
40        match prim {
41            0 => Some(Self::Disabled),
42            1 => Some(Self::Allow),
43            2 => Some(Self::Deny),
44            _ => None,
45        }
46    }
47
48    #[inline]
49    pub const fn into_primitive(self) -> i32 {
50        self as i32
51    }
52}
53
54#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
55#[repr(C)]
56pub struct DeviceTestGetCurrentChannelResponse {
57    pub channel_index: u16,
58}
59
60impl fidl::Persistable for DeviceTestGetCurrentChannelResponse {}
61
62#[derive(Clone, Debug, PartialEq)]
63pub struct DeviceTestGetCurrentMacAddressResponse {
64    pub address: fidl_fuchsia_lowpan__common::MacAddress,
65}
66
67impl fidl::Persistable for DeviceTestGetCurrentMacAddressResponse {}
68
69#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
70#[repr(C)]
71pub struct DeviceTestGetCurrentRssiResponse {
72    pub rssi: i8,
73}
74
75impl fidl::Persistable for DeviceTestGetCurrentRssiResponse {}
76
77#[derive(Clone, Debug, PartialEq)]
78pub struct DeviceTestGetFactoryMacAddressResponse {
79    pub address: fidl_fuchsia_lowpan__common::MacAddress,
80}
81
82impl fidl::Persistable for DeviceTestGetFactoryMacAddressResponse {}
83
84#[derive(Clone, Debug, PartialEq)]
85pub struct DeviceTestGetMacAddressFilterSettingsResponse {
86    pub settings: MacAddressFilterSettings,
87}
88
89impl fidl::Persistable for DeviceTestGetMacAddressFilterSettingsResponse {}
90
91#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
92pub struct DeviceTestGetNcpVersionResponse {
93    pub version: String,
94}
95
96impl fidl::Persistable for DeviceTestGetNcpVersionResponse {}
97
98#[derive(Clone, Debug, PartialEq)]
99pub struct DeviceTestGetNeighborTableResponse {
100    pub neighbor_table: Vec<NeighborInfo>,
101}
102
103impl fidl::Persistable for DeviceTestGetNeighborTableResponse {}
104
105#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
106#[repr(C)]
107pub struct DeviceTestGetPartitionIdResponse {
108    pub pid: u32,
109}
110
111impl fidl::Persistable for DeviceTestGetPartitionIdResponse {}
112
113#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
114#[repr(C)]
115pub struct DeviceTestGetThreadRloc16Response {
116    pub rloc: u16,
117}
118
119impl fidl::Persistable for DeviceTestGetThreadRloc16Response {}
120
121#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
122#[repr(C)]
123pub struct DeviceTestGetThreadRouterIdResponse {
124    pub router_id: u8,
125}
126
127impl fidl::Persistable for DeviceTestGetThreadRouterIdResponse {}
128
129#[derive(Clone, Debug, PartialEq)]
130pub struct DeviceTestReplaceMacAddressFilterSettingsRequest {
131    pub settings: MacAddressFilterSettings,
132}
133
134impl fidl::Persistable for DeviceTestReplaceMacAddressFilterSettingsRequest {}
135
136/// An item in the MAC filter list.
137#[derive(Clone, Debug, Default, PartialEq)]
138pub struct MacAddressFilterItem {
139    /// The MAC address of the item. This field is required.
140    pub mac_address: Option<fidl_fuchsia_lowpan__common::MacAddress>,
141    /// Replacement RSSI value for packets received from this address.
142    ///
143    /// This field is ignored unless the mode is set to `MacAddressFilterMode::ALLOW`.
144    ///
145    /// This value is substituted for all received packets. This can affect
146    /// what the mesh topology ultimately looks like.
147    pub rssi: Option<i8>,
148    #[doc(hidden)]
149    pub __source_breaking: fidl::marker::SourceBreaking,
150}
151
152impl fidl::Persistable for MacAddressFilterItem {}
153
154#[derive(Clone, Debug, Default, PartialEq)]
155pub struct MacAddressFilterSettings {
156    /// Address filter mode.
157    ///
158    /// This field is required. If this field is absent when passed to
159    /// `ReplaceMacAddressFilterSettings`, the channel will be closed with
160    /// the epitaph `ZX_ERR_INVALID_ARGUMENT`.
161    pub mode: Option<MacAddressFilterMode>,
162    /// Addresses to be filtered.
163    ///
164    /// If this field is absent it is assumed to be empty.
165    pub items: Option<Vec<MacAddressFilterItem>>,
166    #[doc(hidden)]
167    pub __source_breaking: fidl::marker::SourceBreaking,
168}
169
170impl fidl::Persistable for MacAddressFilterSettings {}
171
172/// Neighbor Table Entry
173///
174/// All fields are optional except for `mac_address`.
175///
176/// See also:
177///   * https://openthread.io/reference/struct/ot-neighbor-info
178///   * https://openthread.io/reference/struct/ot-child-info
179///   * https://github.com/openthread/wpantund/blob/8db2a71c9597e08949dfc38d8c10f830e3de565c/third_party/openthread/src/ncp/spinel.h#L2356-L2373
180#[derive(Clone, Debug, Default, PartialEq)]
181pub struct NeighborInfo {
182    /// The MAC address of the neighbor.
183    ///
184    /// Note that this is the only field guaranteed to be present.
185    pub mac_address: Option<fidl_fuchsia_lowpan__common::MacAddress>,
186    /// 802.15.4 short address of neighbor.
187    ///
188    /// On Thread networks, this is also the RLOC16.
189    pub short_address: Option<u16>,
190    /// The age of this entry in the neighbor table.
191    ///
192    /// Describes when this neighbor was last seen.
193    /// Resolution is roughly +/- 1sec.
194    pub age: Option<i64>,
195    /// True if this neighbor is considered a child and is thus
196    /// entirely dependent on this device for routing.
197    ///
198    /// If absent, assumed to be false.
199    pub is_child: Option<bool>,
200    /// The number of link (non-management) frames received from this neighbor.
201    pub link_frame_count: Option<u32>,
202    /// The number of management (MLE, etc) frames received from this neighbor.
203    pub mgmt_frame_count: Option<u32>,
204    /// RSSI of the most recent packet received from the neighbor.
205    pub last_rssi_in: Option<i32>,
206    /// Average/typical RSSI of packets received from the neighbor.
207    pub avg_rssi_in: Option<i8>,
208    /// LQI of the most recent packet received from the neighbor.
209    ///
210    /// Value is between 1 and 255, with 1 being the worst possible
211    /// link quality (any worse and it would not have been decoded)
212    /// and 255 being perfect reception. All values in between
213    /// are a roughly linear (but not well defined) extrapolation
214    /// between these two extremes.
215    ///
216    /// Zero values must not be encoded, but if encountered should be
217    /// interpreted as if the LQI field were absent.
218    ///
219    /// In 802.15.4 networks, LQI is typically determined by the number of
220    /// "chip errors" when decoding the packets.
221    pub lqi_in: Option<u8>,
222    /// Thread Mode TLV. Only present on Thread networks.
223    ///
224    /// Defined by section 4.5.2 of the Thread 1.1.1 specification ("Mode TLV").
225    pub thread_mode: Option<u8>,
226    /// Frame error rate.
227    ///
228    /// `0xffff` indicates 100%, `0x0000` indicates 0%.
229    pub frame_error_rate: Option<u16>,
230    /// IPv6 message error rate.
231    ///
232    /// `0xffff` indicates 100%, `0x0000` indicates 0%.
233    pub ipv6_error_rate: Option<u16>,
234    /// True if the child is CSL synced.
235    ///
236    /// CSL is Coordinated Sampled Listening, a mechanism for sleepy devices
237    /// to perform indirect TX.
238    pub child_is_csl_synced: Option<bool>,
239    /// True if the child is restoring state.
240    pub child_is_state_restoring: Option<bool>,
241    /// Version of NetData that the neighbor has.
242    pub net_data_version: Option<u8>,
243    /// Number of messages queued for the neighbor.
244    pub queued_messages: Option<u16>,
245    /// MLE version for the neighbor.
246    pub thread_mle_version: Option<u8>,
247    #[doc(hidden)]
248    pub __source_breaking: fidl::marker::SourceBreaking,
249}
250
251impl fidl::Persistable for NeighborInfo {}
252
253pub mod device_test_ordinals {
254    pub const RESET: u64 = 0x772795fd82e287e;
255    pub const GET_NCP_VERSION: u64 = 0x5006d66ecaa992f2;
256    pub const GET_CURRENT_RSSI: u64 = 0x6ac289cf16a976ab;
257    pub const GET_FACTORY_MAC_ADDRESS: u64 = 0x2a32094f1da3372;
258    pub const GET_CURRENT_MAC_ADDRESS: u64 = 0x39fc2f974a484b62;
259    pub const GET_CURRENT_CHANNEL: u64 = 0x2bd32ba980668d13;
260    pub const GET_PARTITION_ID: u64 = 0x32be448a6dc88b33;
261    pub const GET_THREAD_RLOC16: u64 = 0x4e554e42c1953d31;
262    pub const GET_THREAD_ROUTER_ID: u64 = 0x753df71fce9f3563;
263    pub const REPLACE_MAC_ADDRESS_FILTER_SETTINGS: u64 = 0x66eb4780f869de19;
264    pub const GET_MAC_ADDRESS_FILTER_SETTINGS: u64 = 0x2d727bf2dd3e231c;
265    pub const GET_NEIGHBOR_TABLE: u64 = 0x6f2db4573c413cde;
266}
267
268pub mod device_test_connector_ordinals {
269    pub const CONNECT: u64 = 0x366c1167cee8caa3;
270}
271
272mod internal {
273    use super::*;
274    unsafe impl fidl::encoding::TypeMarker for MacAddressFilterMode {
275        type Owned = Self;
276
277        #[inline(always)]
278        fn inline_align(_context: fidl::encoding::Context) -> usize {
279            std::mem::align_of::<i32>()
280        }
281
282        #[inline(always)]
283        fn inline_size(_context: fidl::encoding::Context) -> usize {
284            std::mem::size_of::<i32>()
285        }
286
287        #[inline(always)]
288        fn encode_is_copy() -> bool {
289            true
290        }
291
292        #[inline(always)]
293        fn decode_is_copy() -> bool {
294            false
295        }
296    }
297
298    impl fidl::encoding::ValueTypeMarker for MacAddressFilterMode {
299        type Borrowed<'a> = Self;
300        #[inline(always)]
301        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
302            *value
303        }
304    }
305
306    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
307        for MacAddressFilterMode
308    {
309        #[inline]
310        unsafe fn encode(
311            self,
312            encoder: &mut fidl::encoding::Encoder<'_, D>,
313            offset: usize,
314            _depth: fidl::encoding::Depth,
315        ) -> fidl::Result<()> {
316            encoder.debug_check_bounds::<Self>(offset);
317            encoder.write_num(self.into_primitive(), offset);
318            Ok(())
319        }
320    }
321
322    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MacAddressFilterMode {
323        #[inline(always)]
324        fn new_empty() -> Self {
325            Self::Disabled
326        }
327
328        #[inline]
329        unsafe fn decode(
330            &mut self,
331            decoder: &mut fidl::encoding::Decoder<'_, D>,
332            offset: usize,
333            _depth: fidl::encoding::Depth,
334        ) -> fidl::Result<()> {
335            decoder.debug_check_bounds::<Self>(offset);
336            let prim = decoder.read_num::<i32>(offset);
337
338            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
339            Ok(())
340        }
341    }
342
343    impl fidl::encoding::ValueTypeMarker for DeviceTestGetCurrentChannelResponse {
344        type Borrowed<'a> = &'a Self;
345        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
346            value
347        }
348    }
349
350    unsafe impl fidl::encoding::TypeMarker for DeviceTestGetCurrentChannelResponse {
351        type Owned = Self;
352
353        #[inline(always)]
354        fn inline_align(_context: fidl::encoding::Context) -> usize {
355            2
356        }
357
358        #[inline(always)]
359        fn inline_size(_context: fidl::encoding::Context) -> usize {
360            2
361        }
362        #[inline(always)]
363        fn encode_is_copy() -> bool {
364            true
365        }
366
367        #[inline(always)]
368        fn decode_is_copy() -> bool {
369            true
370        }
371    }
372
373    unsafe impl<D: fidl::encoding::ResourceDialect>
374        fidl::encoding::Encode<DeviceTestGetCurrentChannelResponse, D>
375        for &DeviceTestGetCurrentChannelResponse
376    {
377        #[inline]
378        unsafe fn encode(
379            self,
380            encoder: &mut fidl::encoding::Encoder<'_, D>,
381            offset: usize,
382            _depth: fidl::encoding::Depth,
383        ) -> fidl::Result<()> {
384            encoder.debug_check_bounds::<DeviceTestGetCurrentChannelResponse>(offset);
385            unsafe {
386                // Copy the object into the buffer.
387                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
388                (buf_ptr as *mut DeviceTestGetCurrentChannelResponse)
389                    .write_unaligned((self as *const DeviceTestGetCurrentChannelResponse).read());
390                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
391                // done second because the memcpy will write garbage to these bytes.
392            }
393            Ok(())
394        }
395    }
396    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
397        fidl::encoding::Encode<DeviceTestGetCurrentChannelResponse, D> for (T0,)
398    {
399        #[inline]
400        unsafe fn encode(
401            self,
402            encoder: &mut fidl::encoding::Encoder<'_, D>,
403            offset: usize,
404            depth: fidl::encoding::Depth,
405        ) -> fidl::Result<()> {
406            encoder.debug_check_bounds::<DeviceTestGetCurrentChannelResponse>(offset);
407            // Zero out padding regions. There's no need to apply masks
408            // because the unmasked parts will be overwritten by fields.
409            // Write the fields.
410            self.0.encode(encoder, offset + 0, depth)?;
411            Ok(())
412        }
413    }
414
415    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
416        for DeviceTestGetCurrentChannelResponse
417    {
418        #[inline(always)]
419        fn new_empty() -> Self {
420            Self { channel_index: fidl::new_empty!(u16, D) }
421        }
422
423        #[inline]
424        unsafe fn decode(
425            &mut self,
426            decoder: &mut fidl::encoding::Decoder<'_, D>,
427            offset: usize,
428            _depth: fidl::encoding::Depth,
429        ) -> fidl::Result<()> {
430            decoder.debug_check_bounds::<Self>(offset);
431            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
432            // Verify that padding bytes are zero.
433            // Copy from the buffer into the object.
434            unsafe {
435                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
436            }
437            Ok(())
438        }
439    }
440
441    impl fidl::encoding::ValueTypeMarker for DeviceTestGetCurrentMacAddressResponse {
442        type Borrowed<'a> = &'a Self;
443        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
444            value
445        }
446    }
447
448    unsafe impl fidl::encoding::TypeMarker for DeviceTestGetCurrentMacAddressResponse {
449        type Owned = Self;
450
451        #[inline(always)]
452        fn inline_align(_context: fidl::encoding::Context) -> usize {
453            1
454        }
455
456        #[inline(always)]
457        fn inline_size(_context: fidl::encoding::Context) -> usize {
458            8
459        }
460    }
461
462    unsafe impl<D: fidl::encoding::ResourceDialect>
463        fidl::encoding::Encode<DeviceTestGetCurrentMacAddressResponse, D>
464        for &DeviceTestGetCurrentMacAddressResponse
465    {
466        #[inline]
467        unsafe fn encode(
468            self,
469            encoder: &mut fidl::encoding::Encoder<'_, D>,
470            offset: usize,
471            _depth: fidl::encoding::Depth,
472        ) -> fidl::Result<()> {
473            encoder.debug_check_bounds::<DeviceTestGetCurrentMacAddressResponse>(offset);
474            // Delegate to tuple encoding.
475            fidl::encoding::Encode::<DeviceTestGetCurrentMacAddressResponse, D>::encode(
476                (
477                    <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
478                ),
479                encoder, offset, _depth
480            )
481        }
482    }
483    unsafe impl<
484            D: fidl::encoding::ResourceDialect,
485            T0: fidl::encoding::Encode<fidl_fuchsia_lowpan__common::MacAddress, D>,
486        > fidl::encoding::Encode<DeviceTestGetCurrentMacAddressResponse, D> for (T0,)
487    {
488        #[inline]
489        unsafe fn encode(
490            self,
491            encoder: &mut fidl::encoding::Encoder<'_, D>,
492            offset: usize,
493            depth: fidl::encoding::Depth,
494        ) -> fidl::Result<()> {
495            encoder.debug_check_bounds::<DeviceTestGetCurrentMacAddressResponse>(offset);
496            // Zero out padding regions. There's no need to apply masks
497            // because the unmasked parts will be overwritten by fields.
498            // Write the fields.
499            self.0.encode(encoder, offset + 0, depth)?;
500            Ok(())
501        }
502    }
503
504    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
505        for DeviceTestGetCurrentMacAddressResponse
506    {
507        #[inline(always)]
508        fn new_empty() -> Self {
509            Self { address: fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D) }
510        }
511
512        #[inline]
513        unsafe fn decode(
514            &mut self,
515            decoder: &mut fidl::encoding::Decoder<'_, D>,
516            offset: usize,
517            _depth: fidl::encoding::Depth,
518        ) -> fidl::Result<()> {
519            decoder.debug_check_bounds::<Self>(offset);
520            // Verify that padding bytes are zero.
521            fidl::decode!(
522                fidl_fuchsia_lowpan__common::MacAddress,
523                D,
524                &mut self.address,
525                decoder,
526                offset + 0,
527                _depth
528            )?;
529            Ok(())
530        }
531    }
532
533    impl fidl::encoding::ValueTypeMarker for DeviceTestGetCurrentRssiResponse {
534        type Borrowed<'a> = &'a Self;
535        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
536            value
537        }
538    }
539
540    unsafe impl fidl::encoding::TypeMarker for DeviceTestGetCurrentRssiResponse {
541        type Owned = Self;
542
543        #[inline(always)]
544        fn inline_align(_context: fidl::encoding::Context) -> usize {
545            1
546        }
547
548        #[inline(always)]
549        fn inline_size(_context: fidl::encoding::Context) -> usize {
550            1
551        }
552        #[inline(always)]
553        fn encode_is_copy() -> bool {
554            true
555        }
556
557        #[inline(always)]
558        fn decode_is_copy() -> bool {
559            true
560        }
561    }
562
563    unsafe impl<D: fidl::encoding::ResourceDialect>
564        fidl::encoding::Encode<DeviceTestGetCurrentRssiResponse, D>
565        for &DeviceTestGetCurrentRssiResponse
566    {
567        #[inline]
568        unsafe fn encode(
569            self,
570            encoder: &mut fidl::encoding::Encoder<'_, D>,
571            offset: usize,
572            _depth: fidl::encoding::Depth,
573        ) -> fidl::Result<()> {
574            encoder.debug_check_bounds::<DeviceTestGetCurrentRssiResponse>(offset);
575            unsafe {
576                // Copy the object into the buffer.
577                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
578                (buf_ptr as *mut DeviceTestGetCurrentRssiResponse)
579                    .write_unaligned((self as *const DeviceTestGetCurrentRssiResponse).read());
580                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
581                // done second because the memcpy will write garbage to these bytes.
582            }
583            Ok(())
584        }
585    }
586    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i8, D>>
587        fidl::encoding::Encode<DeviceTestGetCurrentRssiResponse, D> for (T0,)
588    {
589        #[inline]
590        unsafe fn encode(
591            self,
592            encoder: &mut fidl::encoding::Encoder<'_, D>,
593            offset: usize,
594            depth: fidl::encoding::Depth,
595        ) -> fidl::Result<()> {
596            encoder.debug_check_bounds::<DeviceTestGetCurrentRssiResponse>(offset);
597            // Zero out padding regions. There's no need to apply masks
598            // because the unmasked parts will be overwritten by fields.
599            // Write the fields.
600            self.0.encode(encoder, offset + 0, depth)?;
601            Ok(())
602        }
603    }
604
605    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
606        for DeviceTestGetCurrentRssiResponse
607    {
608        #[inline(always)]
609        fn new_empty() -> Self {
610            Self { rssi: fidl::new_empty!(i8, D) }
611        }
612
613        #[inline]
614        unsafe fn decode(
615            &mut self,
616            decoder: &mut fidl::encoding::Decoder<'_, D>,
617            offset: usize,
618            _depth: fidl::encoding::Depth,
619        ) -> fidl::Result<()> {
620            decoder.debug_check_bounds::<Self>(offset);
621            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
622            // Verify that padding bytes are zero.
623            // Copy from the buffer into the object.
624            unsafe {
625                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
626            }
627            Ok(())
628        }
629    }
630
631    impl fidl::encoding::ValueTypeMarker for DeviceTestGetFactoryMacAddressResponse {
632        type Borrowed<'a> = &'a Self;
633        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
634            value
635        }
636    }
637
638    unsafe impl fidl::encoding::TypeMarker for DeviceTestGetFactoryMacAddressResponse {
639        type Owned = Self;
640
641        #[inline(always)]
642        fn inline_align(_context: fidl::encoding::Context) -> usize {
643            1
644        }
645
646        #[inline(always)]
647        fn inline_size(_context: fidl::encoding::Context) -> usize {
648            8
649        }
650    }
651
652    unsafe impl<D: fidl::encoding::ResourceDialect>
653        fidl::encoding::Encode<DeviceTestGetFactoryMacAddressResponse, D>
654        for &DeviceTestGetFactoryMacAddressResponse
655    {
656        #[inline]
657        unsafe fn encode(
658            self,
659            encoder: &mut fidl::encoding::Encoder<'_, D>,
660            offset: usize,
661            _depth: fidl::encoding::Depth,
662        ) -> fidl::Result<()> {
663            encoder.debug_check_bounds::<DeviceTestGetFactoryMacAddressResponse>(offset);
664            // Delegate to tuple encoding.
665            fidl::encoding::Encode::<DeviceTestGetFactoryMacAddressResponse, D>::encode(
666                (
667                    <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
668                ),
669                encoder, offset, _depth
670            )
671        }
672    }
673    unsafe impl<
674            D: fidl::encoding::ResourceDialect,
675            T0: fidl::encoding::Encode<fidl_fuchsia_lowpan__common::MacAddress, D>,
676        > fidl::encoding::Encode<DeviceTestGetFactoryMacAddressResponse, D> for (T0,)
677    {
678        #[inline]
679        unsafe fn encode(
680            self,
681            encoder: &mut fidl::encoding::Encoder<'_, D>,
682            offset: usize,
683            depth: fidl::encoding::Depth,
684        ) -> fidl::Result<()> {
685            encoder.debug_check_bounds::<DeviceTestGetFactoryMacAddressResponse>(offset);
686            // Zero out padding regions. There's no need to apply masks
687            // because the unmasked parts will be overwritten by fields.
688            // Write the fields.
689            self.0.encode(encoder, offset + 0, depth)?;
690            Ok(())
691        }
692    }
693
694    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
695        for DeviceTestGetFactoryMacAddressResponse
696    {
697        #[inline(always)]
698        fn new_empty() -> Self {
699            Self { address: fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D) }
700        }
701
702        #[inline]
703        unsafe fn decode(
704            &mut self,
705            decoder: &mut fidl::encoding::Decoder<'_, D>,
706            offset: usize,
707            _depth: fidl::encoding::Depth,
708        ) -> fidl::Result<()> {
709            decoder.debug_check_bounds::<Self>(offset);
710            // Verify that padding bytes are zero.
711            fidl::decode!(
712                fidl_fuchsia_lowpan__common::MacAddress,
713                D,
714                &mut self.address,
715                decoder,
716                offset + 0,
717                _depth
718            )?;
719            Ok(())
720        }
721    }
722
723    impl fidl::encoding::ValueTypeMarker for DeviceTestGetMacAddressFilterSettingsResponse {
724        type Borrowed<'a> = &'a Self;
725        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
726            value
727        }
728    }
729
730    unsafe impl fidl::encoding::TypeMarker for DeviceTestGetMacAddressFilterSettingsResponse {
731        type Owned = Self;
732
733        #[inline(always)]
734        fn inline_align(_context: fidl::encoding::Context) -> usize {
735            8
736        }
737
738        #[inline(always)]
739        fn inline_size(_context: fidl::encoding::Context) -> usize {
740            16
741        }
742    }
743
744    unsafe impl<D: fidl::encoding::ResourceDialect>
745        fidl::encoding::Encode<DeviceTestGetMacAddressFilterSettingsResponse, D>
746        for &DeviceTestGetMacAddressFilterSettingsResponse
747    {
748        #[inline]
749        unsafe fn encode(
750            self,
751            encoder: &mut fidl::encoding::Encoder<'_, D>,
752            offset: usize,
753            _depth: fidl::encoding::Depth,
754        ) -> fidl::Result<()> {
755            encoder.debug_check_bounds::<DeviceTestGetMacAddressFilterSettingsResponse>(offset);
756            // Delegate to tuple encoding.
757            fidl::encoding::Encode::<DeviceTestGetMacAddressFilterSettingsResponse, D>::encode(
758                (<MacAddressFilterSettings as fidl::encoding::ValueTypeMarker>::borrow(
759                    &self.settings,
760                ),),
761                encoder,
762                offset,
763                _depth,
764            )
765        }
766    }
767    unsafe impl<
768            D: fidl::encoding::ResourceDialect,
769            T0: fidl::encoding::Encode<MacAddressFilterSettings, D>,
770        > fidl::encoding::Encode<DeviceTestGetMacAddressFilterSettingsResponse, D> for (T0,)
771    {
772        #[inline]
773        unsafe fn encode(
774            self,
775            encoder: &mut fidl::encoding::Encoder<'_, D>,
776            offset: usize,
777            depth: fidl::encoding::Depth,
778        ) -> fidl::Result<()> {
779            encoder.debug_check_bounds::<DeviceTestGetMacAddressFilterSettingsResponse>(offset);
780            // Zero out padding regions. There's no need to apply masks
781            // because the unmasked parts will be overwritten by fields.
782            // Write the fields.
783            self.0.encode(encoder, offset + 0, depth)?;
784            Ok(())
785        }
786    }
787
788    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
789        for DeviceTestGetMacAddressFilterSettingsResponse
790    {
791        #[inline(always)]
792        fn new_empty() -> Self {
793            Self { settings: fidl::new_empty!(MacAddressFilterSettings, D) }
794        }
795
796        #[inline]
797        unsafe fn decode(
798            &mut self,
799            decoder: &mut fidl::encoding::Decoder<'_, D>,
800            offset: usize,
801            _depth: fidl::encoding::Depth,
802        ) -> fidl::Result<()> {
803            decoder.debug_check_bounds::<Self>(offset);
804            // Verify that padding bytes are zero.
805            fidl::decode!(
806                MacAddressFilterSettings,
807                D,
808                &mut self.settings,
809                decoder,
810                offset + 0,
811                _depth
812            )?;
813            Ok(())
814        }
815    }
816
817    impl fidl::encoding::ValueTypeMarker for DeviceTestGetNcpVersionResponse {
818        type Borrowed<'a> = &'a Self;
819        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
820            value
821        }
822    }
823
824    unsafe impl fidl::encoding::TypeMarker for DeviceTestGetNcpVersionResponse {
825        type Owned = Self;
826
827        #[inline(always)]
828        fn inline_align(_context: fidl::encoding::Context) -> usize {
829            8
830        }
831
832        #[inline(always)]
833        fn inline_size(_context: fidl::encoding::Context) -> usize {
834            16
835        }
836    }
837
838    unsafe impl<D: fidl::encoding::ResourceDialect>
839        fidl::encoding::Encode<DeviceTestGetNcpVersionResponse, D>
840        for &DeviceTestGetNcpVersionResponse
841    {
842        #[inline]
843        unsafe fn encode(
844            self,
845            encoder: &mut fidl::encoding::Encoder<'_, D>,
846            offset: usize,
847            _depth: fidl::encoding::Depth,
848        ) -> fidl::Result<()> {
849            encoder.debug_check_bounds::<DeviceTestGetNcpVersionResponse>(offset);
850            // Delegate to tuple encoding.
851            fidl::encoding::Encode::<DeviceTestGetNcpVersionResponse, D>::encode(
852                (<fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
853                    &self.version,
854                ),),
855                encoder,
856                offset,
857                _depth,
858            )
859        }
860    }
861    unsafe impl<
862            D: fidl::encoding::ResourceDialect,
863            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
864        > fidl::encoding::Encode<DeviceTestGetNcpVersionResponse, D> for (T0,)
865    {
866        #[inline]
867        unsafe fn encode(
868            self,
869            encoder: &mut fidl::encoding::Encoder<'_, D>,
870            offset: usize,
871            depth: fidl::encoding::Depth,
872        ) -> fidl::Result<()> {
873            encoder.debug_check_bounds::<DeviceTestGetNcpVersionResponse>(offset);
874            // Zero out padding regions. There's no need to apply masks
875            // because the unmasked parts will be overwritten by fields.
876            // Write the fields.
877            self.0.encode(encoder, offset + 0, depth)?;
878            Ok(())
879        }
880    }
881
882    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
883        for DeviceTestGetNcpVersionResponse
884    {
885        #[inline(always)]
886        fn new_empty() -> Self {
887            Self { version: fidl::new_empty!(fidl::encoding::BoundedString<256>, D) }
888        }
889
890        #[inline]
891        unsafe fn decode(
892            &mut self,
893            decoder: &mut fidl::encoding::Decoder<'_, D>,
894            offset: usize,
895            _depth: fidl::encoding::Depth,
896        ) -> fidl::Result<()> {
897            decoder.debug_check_bounds::<Self>(offset);
898            // Verify that padding bytes are zero.
899            fidl::decode!(
900                fidl::encoding::BoundedString<256>,
901                D,
902                &mut self.version,
903                decoder,
904                offset + 0,
905                _depth
906            )?;
907            Ok(())
908        }
909    }
910
911    impl fidl::encoding::ValueTypeMarker for DeviceTestGetNeighborTableResponse {
912        type Borrowed<'a> = &'a Self;
913        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
914            value
915        }
916    }
917
918    unsafe impl fidl::encoding::TypeMarker for DeviceTestGetNeighborTableResponse {
919        type Owned = Self;
920
921        #[inline(always)]
922        fn inline_align(_context: fidl::encoding::Context) -> usize {
923            8
924        }
925
926        #[inline(always)]
927        fn inline_size(_context: fidl::encoding::Context) -> usize {
928            16
929        }
930    }
931
932    unsafe impl<D: fidl::encoding::ResourceDialect>
933        fidl::encoding::Encode<DeviceTestGetNeighborTableResponse, D>
934        for &DeviceTestGetNeighborTableResponse
935    {
936        #[inline]
937        unsafe fn encode(
938            self,
939            encoder: &mut fidl::encoding::Encoder<'_, D>,
940            offset: usize,
941            _depth: fidl::encoding::Depth,
942        ) -> fidl::Result<()> {
943            encoder.debug_check_bounds::<DeviceTestGetNeighborTableResponse>(offset);
944            // Delegate to tuple encoding.
945            fidl::encoding::Encode::<DeviceTestGetNeighborTableResponse, D>::encode(
946                (
947                    <fidl::encoding::Vector<NeighborInfo, 1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.neighbor_table),
948                ),
949                encoder, offset, _depth
950            )
951        }
952    }
953    unsafe impl<
954            D: fidl::encoding::ResourceDialect,
955            T0: fidl::encoding::Encode<fidl::encoding::Vector<NeighborInfo, 1024>, D>,
956        > fidl::encoding::Encode<DeviceTestGetNeighborTableResponse, D> for (T0,)
957    {
958        #[inline]
959        unsafe fn encode(
960            self,
961            encoder: &mut fidl::encoding::Encoder<'_, D>,
962            offset: usize,
963            depth: fidl::encoding::Depth,
964        ) -> fidl::Result<()> {
965            encoder.debug_check_bounds::<DeviceTestGetNeighborTableResponse>(offset);
966            // Zero out padding regions. There's no need to apply masks
967            // because the unmasked parts will be overwritten by fields.
968            // Write the fields.
969            self.0.encode(encoder, offset + 0, depth)?;
970            Ok(())
971        }
972    }
973
974    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
975        for DeviceTestGetNeighborTableResponse
976    {
977        #[inline(always)]
978        fn new_empty() -> Self {
979            Self { neighbor_table: fidl::new_empty!(fidl::encoding::Vector<NeighborInfo, 1024>, D) }
980        }
981
982        #[inline]
983        unsafe fn decode(
984            &mut self,
985            decoder: &mut fidl::encoding::Decoder<'_, D>,
986            offset: usize,
987            _depth: fidl::encoding::Depth,
988        ) -> fidl::Result<()> {
989            decoder.debug_check_bounds::<Self>(offset);
990            // Verify that padding bytes are zero.
991            fidl::decode!(fidl::encoding::Vector<NeighborInfo, 1024>, D, &mut self.neighbor_table, decoder, offset + 0, _depth)?;
992            Ok(())
993        }
994    }
995
996    impl fidl::encoding::ValueTypeMarker for DeviceTestGetPartitionIdResponse {
997        type Borrowed<'a> = &'a Self;
998        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
999            value
1000        }
1001    }
1002
1003    unsafe impl fidl::encoding::TypeMarker for DeviceTestGetPartitionIdResponse {
1004        type Owned = Self;
1005
1006        #[inline(always)]
1007        fn inline_align(_context: fidl::encoding::Context) -> usize {
1008            4
1009        }
1010
1011        #[inline(always)]
1012        fn inline_size(_context: fidl::encoding::Context) -> usize {
1013            4
1014        }
1015        #[inline(always)]
1016        fn encode_is_copy() -> bool {
1017            true
1018        }
1019
1020        #[inline(always)]
1021        fn decode_is_copy() -> bool {
1022            true
1023        }
1024    }
1025
1026    unsafe impl<D: fidl::encoding::ResourceDialect>
1027        fidl::encoding::Encode<DeviceTestGetPartitionIdResponse, D>
1028        for &DeviceTestGetPartitionIdResponse
1029    {
1030        #[inline]
1031        unsafe fn encode(
1032            self,
1033            encoder: &mut fidl::encoding::Encoder<'_, D>,
1034            offset: usize,
1035            _depth: fidl::encoding::Depth,
1036        ) -> fidl::Result<()> {
1037            encoder.debug_check_bounds::<DeviceTestGetPartitionIdResponse>(offset);
1038            unsafe {
1039                // Copy the object into the buffer.
1040                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1041                (buf_ptr as *mut DeviceTestGetPartitionIdResponse)
1042                    .write_unaligned((self as *const DeviceTestGetPartitionIdResponse).read());
1043                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1044                // done second because the memcpy will write garbage to these bytes.
1045            }
1046            Ok(())
1047        }
1048    }
1049    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
1050        fidl::encoding::Encode<DeviceTestGetPartitionIdResponse, D> for (T0,)
1051    {
1052        #[inline]
1053        unsafe fn encode(
1054            self,
1055            encoder: &mut fidl::encoding::Encoder<'_, D>,
1056            offset: usize,
1057            depth: fidl::encoding::Depth,
1058        ) -> fidl::Result<()> {
1059            encoder.debug_check_bounds::<DeviceTestGetPartitionIdResponse>(offset);
1060            // Zero out padding regions. There's no need to apply masks
1061            // because the unmasked parts will be overwritten by fields.
1062            // Write the fields.
1063            self.0.encode(encoder, offset + 0, depth)?;
1064            Ok(())
1065        }
1066    }
1067
1068    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1069        for DeviceTestGetPartitionIdResponse
1070    {
1071        #[inline(always)]
1072        fn new_empty() -> Self {
1073            Self { pid: fidl::new_empty!(u32, D) }
1074        }
1075
1076        #[inline]
1077        unsafe fn decode(
1078            &mut self,
1079            decoder: &mut fidl::encoding::Decoder<'_, D>,
1080            offset: usize,
1081            _depth: fidl::encoding::Depth,
1082        ) -> fidl::Result<()> {
1083            decoder.debug_check_bounds::<Self>(offset);
1084            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1085            // Verify that padding bytes are zero.
1086            // Copy from the buffer into the object.
1087            unsafe {
1088                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1089            }
1090            Ok(())
1091        }
1092    }
1093
1094    impl fidl::encoding::ValueTypeMarker for DeviceTestGetThreadRloc16Response {
1095        type Borrowed<'a> = &'a Self;
1096        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1097            value
1098        }
1099    }
1100
1101    unsafe impl fidl::encoding::TypeMarker for DeviceTestGetThreadRloc16Response {
1102        type Owned = Self;
1103
1104        #[inline(always)]
1105        fn inline_align(_context: fidl::encoding::Context) -> usize {
1106            2
1107        }
1108
1109        #[inline(always)]
1110        fn inline_size(_context: fidl::encoding::Context) -> usize {
1111            2
1112        }
1113        #[inline(always)]
1114        fn encode_is_copy() -> bool {
1115            true
1116        }
1117
1118        #[inline(always)]
1119        fn decode_is_copy() -> bool {
1120            true
1121        }
1122    }
1123
1124    unsafe impl<D: fidl::encoding::ResourceDialect>
1125        fidl::encoding::Encode<DeviceTestGetThreadRloc16Response, D>
1126        for &DeviceTestGetThreadRloc16Response
1127    {
1128        #[inline]
1129        unsafe fn encode(
1130            self,
1131            encoder: &mut fidl::encoding::Encoder<'_, D>,
1132            offset: usize,
1133            _depth: fidl::encoding::Depth,
1134        ) -> fidl::Result<()> {
1135            encoder.debug_check_bounds::<DeviceTestGetThreadRloc16Response>(offset);
1136            unsafe {
1137                // Copy the object into the buffer.
1138                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1139                (buf_ptr as *mut DeviceTestGetThreadRloc16Response)
1140                    .write_unaligned((self as *const DeviceTestGetThreadRloc16Response).read());
1141                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1142                // done second because the memcpy will write garbage to these bytes.
1143            }
1144            Ok(())
1145        }
1146    }
1147    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1148        fidl::encoding::Encode<DeviceTestGetThreadRloc16Response, D> for (T0,)
1149    {
1150        #[inline]
1151        unsafe fn encode(
1152            self,
1153            encoder: &mut fidl::encoding::Encoder<'_, D>,
1154            offset: usize,
1155            depth: fidl::encoding::Depth,
1156        ) -> fidl::Result<()> {
1157            encoder.debug_check_bounds::<DeviceTestGetThreadRloc16Response>(offset);
1158            // Zero out padding regions. There's no need to apply masks
1159            // because the unmasked parts will be overwritten by fields.
1160            // Write the fields.
1161            self.0.encode(encoder, offset + 0, depth)?;
1162            Ok(())
1163        }
1164    }
1165
1166    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1167        for DeviceTestGetThreadRloc16Response
1168    {
1169        #[inline(always)]
1170        fn new_empty() -> Self {
1171            Self { rloc: fidl::new_empty!(u16, D) }
1172        }
1173
1174        #[inline]
1175        unsafe fn decode(
1176            &mut self,
1177            decoder: &mut fidl::encoding::Decoder<'_, D>,
1178            offset: usize,
1179            _depth: fidl::encoding::Depth,
1180        ) -> fidl::Result<()> {
1181            decoder.debug_check_bounds::<Self>(offset);
1182            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1183            // Verify that padding bytes are zero.
1184            // Copy from the buffer into the object.
1185            unsafe {
1186                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1187            }
1188            Ok(())
1189        }
1190    }
1191
1192    impl fidl::encoding::ValueTypeMarker for DeviceTestGetThreadRouterIdResponse {
1193        type Borrowed<'a> = &'a Self;
1194        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1195            value
1196        }
1197    }
1198
1199    unsafe impl fidl::encoding::TypeMarker for DeviceTestGetThreadRouterIdResponse {
1200        type Owned = Self;
1201
1202        #[inline(always)]
1203        fn inline_align(_context: fidl::encoding::Context) -> usize {
1204            1
1205        }
1206
1207        #[inline(always)]
1208        fn inline_size(_context: fidl::encoding::Context) -> usize {
1209            1
1210        }
1211        #[inline(always)]
1212        fn encode_is_copy() -> bool {
1213            true
1214        }
1215
1216        #[inline(always)]
1217        fn decode_is_copy() -> bool {
1218            true
1219        }
1220    }
1221
1222    unsafe impl<D: fidl::encoding::ResourceDialect>
1223        fidl::encoding::Encode<DeviceTestGetThreadRouterIdResponse, D>
1224        for &DeviceTestGetThreadRouterIdResponse
1225    {
1226        #[inline]
1227        unsafe fn encode(
1228            self,
1229            encoder: &mut fidl::encoding::Encoder<'_, D>,
1230            offset: usize,
1231            _depth: fidl::encoding::Depth,
1232        ) -> fidl::Result<()> {
1233            encoder.debug_check_bounds::<DeviceTestGetThreadRouterIdResponse>(offset);
1234            unsafe {
1235                // Copy the object into the buffer.
1236                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1237                (buf_ptr as *mut DeviceTestGetThreadRouterIdResponse)
1238                    .write_unaligned((self as *const DeviceTestGetThreadRouterIdResponse).read());
1239                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1240                // done second because the memcpy will write garbage to these bytes.
1241            }
1242            Ok(())
1243        }
1244    }
1245    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
1246        fidl::encoding::Encode<DeviceTestGetThreadRouterIdResponse, D> for (T0,)
1247    {
1248        #[inline]
1249        unsafe fn encode(
1250            self,
1251            encoder: &mut fidl::encoding::Encoder<'_, D>,
1252            offset: usize,
1253            depth: fidl::encoding::Depth,
1254        ) -> fidl::Result<()> {
1255            encoder.debug_check_bounds::<DeviceTestGetThreadRouterIdResponse>(offset);
1256            // Zero out padding regions. There's no need to apply masks
1257            // because the unmasked parts will be overwritten by fields.
1258            // Write the fields.
1259            self.0.encode(encoder, offset + 0, depth)?;
1260            Ok(())
1261        }
1262    }
1263
1264    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1265        for DeviceTestGetThreadRouterIdResponse
1266    {
1267        #[inline(always)]
1268        fn new_empty() -> Self {
1269            Self { router_id: fidl::new_empty!(u8, D) }
1270        }
1271
1272        #[inline]
1273        unsafe fn decode(
1274            &mut self,
1275            decoder: &mut fidl::encoding::Decoder<'_, D>,
1276            offset: usize,
1277            _depth: fidl::encoding::Depth,
1278        ) -> fidl::Result<()> {
1279            decoder.debug_check_bounds::<Self>(offset);
1280            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1281            // Verify that padding bytes are zero.
1282            // Copy from the buffer into the object.
1283            unsafe {
1284                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
1285            }
1286            Ok(())
1287        }
1288    }
1289
1290    impl fidl::encoding::ValueTypeMarker for DeviceTestReplaceMacAddressFilterSettingsRequest {
1291        type Borrowed<'a> = &'a Self;
1292        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1293            value
1294        }
1295    }
1296
1297    unsafe impl fidl::encoding::TypeMarker for DeviceTestReplaceMacAddressFilterSettingsRequest {
1298        type Owned = Self;
1299
1300        #[inline(always)]
1301        fn inline_align(_context: fidl::encoding::Context) -> usize {
1302            8
1303        }
1304
1305        #[inline(always)]
1306        fn inline_size(_context: fidl::encoding::Context) -> usize {
1307            16
1308        }
1309    }
1310
1311    unsafe impl<D: fidl::encoding::ResourceDialect>
1312        fidl::encoding::Encode<DeviceTestReplaceMacAddressFilterSettingsRequest, D>
1313        for &DeviceTestReplaceMacAddressFilterSettingsRequest
1314    {
1315        #[inline]
1316        unsafe fn encode(
1317            self,
1318            encoder: &mut fidl::encoding::Encoder<'_, D>,
1319            offset: usize,
1320            _depth: fidl::encoding::Depth,
1321        ) -> fidl::Result<()> {
1322            encoder.debug_check_bounds::<DeviceTestReplaceMacAddressFilterSettingsRequest>(offset);
1323            // Delegate to tuple encoding.
1324            fidl::encoding::Encode::<DeviceTestReplaceMacAddressFilterSettingsRequest, D>::encode(
1325                (<MacAddressFilterSettings as fidl::encoding::ValueTypeMarker>::borrow(
1326                    &self.settings,
1327                ),),
1328                encoder,
1329                offset,
1330                _depth,
1331            )
1332        }
1333    }
1334    unsafe impl<
1335            D: fidl::encoding::ResourceDialect,
1336            T0: fidl::encoding::Encode<MacAddressFilterSettings, D>,
1337        > fidl::encoding::Encode<DeviceTestReplaceMacAddressFilterSettingsRequest, D> for (T0,)
1338    {
1339        #[inline]
1340        unsafe fn encode(
1341            self,
1342            encoder: &mut fidl::encoding::Encoder<'_, D>,
1343            offset: usize,
1344            depth: fidl::encoding::Depth,
1345        ) -> fidl::Result<()> {
1346            encoder.debug_check_bounds::<DeviceTestReplaceMacAddressFilterSettingsRequest>(offset);
1347            // Zero out padding regions. There's no need to apply masks
1348            // because the unmasked parts will be overwritten by fields.
1349            // Write the fields.
1350            self.0.encode(encoder, offset + 0, depth)?;
1351            Ok(())
1352        }
1353    }
1354
1355    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1356        for DeviceTestReplaceMacAddressFilterSettingsRequest
1357    {
1358        #[inline(always)]
1359        fn new_empty() -> Self {
1360            Self { settings: fidl::new_empty!(MacAddressFilterSettings, D) }
1361        }
1362
1363        #[inline]
1364        unsafe fn decode(
1365            &mut self,
1366            decoder: &mut fidl::encoding::Decoder<'_, D>,
1367            offset: usize,
1368            _depth: fidl::encoding::Depth,
1369        ) -> fidl::Result<()> {
1370            decoder.debug_check_bounds::<Self>(offset);
1371            // Verify that padding bytes are zero.
1372            fidl::decode!(
1373                MacAddressFilterSettings,
1374                D,
1375                &mut self.settings,
1376                decoder,
1377                offset + 0,
1378                _depth
1379            )?;
1380            Ok(())
1381        }
1382    }
1383
1384    impl MacAddressFilterItem {
1385        #[inline(always)]
1386        fn max_ordinal_present(&self) -> u64 {
1387            if let Some(_) = self.rssi {
1388                return 2;
1389            }
1390            if let Some(_) = self.mac_address {
1391                return 1;
1392            }
1393            0
1394        }
1395    }
1396
1397    impl fidl::encoding::ValueTypeMarker for MacAddressFilterItem {
1398        type Borrowed<'a> = &'a Self;
1399        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1400            value
1401        }
1402    }
1403
1404    unsafe impl fidl::encoding::TypeMarker for MacAddressFilterItem {
1405        type Owned = Self;
1406
1407        #[inline(always)]
1408        fn inline_align(_context: fidl::encoding::Context) -> usize {
1409            8
1410        }
1411
1412        #[inline(always)]
1413        fn inline_size(_context: fidl::encoding::Context) -> usize {
1414            16
1415        }
1416    }
1417
1418    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MacAddressFilterItem, D>
1419        for &MacAddressFilterItem
1420    {
1421        unsafe fn encode(
1422            self,
1423            encoder: &mut fidl::encoding::Encoder<'_, D>,
1424            offset: usize,
1425            mut depth: fidl::encoding::Depth,
1426        ) -> fidl::Result<()> {
1427            encoder.debug_check_bounds::<MacAddressFilterItem>(offset);
1428            // Vector header
1429            let max_ordinal: u64 = self.max_ordinal_present();
1430            encoder.write_num(max_ordinal, offset);
1431            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1432            // Calling encoder.out_of_line_offset(0) is not allowed.
1433            if max_ordinal == 0 {
1434                return Ok(());
1435            }
1436            depth.increment()?;
1437            let envelope_size = 8;
1438            let bytes_len = max_ordinal as usize * envelope_size;
1439            #[allow(unused_variables)]
1440            let offset = encoder.out_of_line_offset(bytes_len);
1441            let mut _prev_end_offset: usize = 0;
1442            if 1 > max_ordinal {
1443                return Ok(());
1444            }
1445
1446            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1447            // are envelope_size bytes.
1448            let cur_offset: usize = (1 - 1) * envelope_size;
1449
1450            // Zero reserved fields.
1451            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1452
1453            // Safety:
1454            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1455            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1456            //   envelope_size bytes, there is always sufficient room.
1457            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_lowpan__common::MacAddress, D>(
1458            self.mac_address.as_ref().map(<fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
1459            encoder, offset + cur_offset, depth
1460        )?;
1461
1462            _prev_end_offset = cur_offset + envelope_size;
1463            if 2 > max_ordinal {
1464                return Ok(());
1465            }
1466
1467            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1468            // are envelope_size bytes.
1469            let cur_offset: usize = (2 - 1) * envelope_size;
1470
1471            // Zero reserved fields.
1472            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1473
1474            // Safety:
1475            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1476            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1477            //   envelope_size bytes, there is always sufficient room.
1478            fidl::encoding::encode_in_envelope_optional::<i8, D>(
1479                self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
1480                encoder,
1481                offset + cur_offset,
1482                depth,
1483            )?;
1484
1485            _prev_end_offset = cur_offset + envelope_size;
1486
1487            Ok(())
1488        }
1489    }
1490
1491    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MacAddressFilterItem {
1492        #[inline(always)]
1493        fn new_empty() -> Self {
1494            Self::default()
1495        }
1496
1497        unsafe fn decode(
1498            &mut self,
1499            decoder: &mut fidl::encoding::Decoder<'_, D>,
1500            offset: usize,
1501            mut depth: fidl::encoding::Depth,
1502        ) -> fidl::Result<()> {
1503            decoder.debug_check_bounds::<Self>(offset);
1504            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1505                None => return Err(fidl::Error::NotNullable),
1506                Some(len) => len,
1507            };
1508            // Calling decoder.out_of_line_offset(0) is not allowed.
1509            if len == 0 {
1510                return Ok(());
1511            };
1512            depth.increment()?;
1513            let envelope_size = 8;
1514            let bytes_len = len * envelope_size;
1515            let offset = decoder.out_of_line_offset(bytes_len)?;
1516            // Decode the envelope for each type.
1517            let mut _next_ordinal_to_read = 0;
1518            let mut next_offset = offset;
1519            let end_offset = offset + bytes_len;
1520            _next_ordinal_to_read += 1;
1521            if next_offset >= end_offset {
1522                return Ok(());
1523            }
1524
1525            // Decode unknown envelopes for gaps in ordinals.
1526            while _next_ordinal_to_read < 1 {
1527                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1528                _next_ordinal_to_read += 1;
1529                next_offset += envelope_size;
1530            }
1531
1532            let next_out_of_line = decoder.next_out_of_line();
1533            let handles_before = decoder.remaining_handles();
1534            if let Some((inlined, num_bytes, num_handles)) =
1535                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1536            {
1537                let member_inline_size = <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1538                if inlined != (member_inline_size <= 4) {
1539                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1540                }
1541                let inner_offset;
1542                let mut inner_depth = depth.clone();
1543                if inlined {
1544                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1545                    inner_offset = next_offset;
1546                } else {
1547                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1548                    inner_depth.increment()?;
1549                }
1550                let val_ref = self.mac_address.get_or_insert_with(|| {
1551                    fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D)
1552                });
1553                fidl::decode!(
1554                    fidl_fuchsia_lowpan__common::MacAddress,
1555                    D,
1556                    val_ref,
1557                    decoder,
1558                    inner_offset,
1559                    inner_depth
1560                )?;
1561                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1562                {
1563                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1564                }
1565                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1566                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1567                }
1568            }
1569
1570            next_offset += envelope_size;
1571            _next_ordinal_to_read += 1;
1572            if next_offset >= end_offset {
1573                return Ok(());
1574            }
1575
1576            // Decode unknown envelopes for gaps in ordinals.
1577            while _next_ordinal_to_read < 2 {
1578                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1579                _next_ordinal_to_read += 1;
1580                next_offset += envelope_size;
1581            }
1582
1583            let next_out_of_line = decoder.next_out_of_line();
1584            let handles_before = decoder.remaining_handles();
1585            if let Some((inlined, num_bytes, num_handles)) =
1586                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1587            {
1588                let member_inline_size =
1589                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1590                if inlined != (member_inline_size <= 4) {
1591                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1592                }
1593                let inner_offset;
1594                let mut inner_depth = depth.clone();
1595                if inlined {
1596                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1597                    inner_offset = next_offset;
1598                } else {
1599                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1600                    inner_depth.increment()?;
1601                }
1602                let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
1603                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
1604                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1605                {
1606                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1607                }
1608                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1609                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1610                }
1611            }
1612
1613            next_offset += envelope_size;
1614
1615            // Decode the remaining unknown envelopes.
1616            while next_offset < end_offset {
1617                _next_ordinal_to_read += 1;
1618                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1619                next_offset += envelope_size;
1620            }
1621
1622            Ok(())
1623        }
1624    }
1625
1626    impl MacAddressFilterSettings {
1627        #[inline(always)]
1628        fn max_ordinal_present(&self) -> u64 {
1629            if let Some(_) = self.items {
1630                return 2;
1631            }
1632            if let Some(_) = self.mode {
1633                return 1;
1634            }
1635            0
1636        }
1637    }
1638
1639    impl fidl::encoding::ValueTypeMarker for MacAddressFilterSettings {
1640        type Borrowed<'a> = &'a Self;
1641        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1642            value
1643        }
1644    }
1645
1646    unsafe impl fidl::encoding::TypeMarker for MacAddressFilterSettings {
1647        type Owned = Self;
1648
1649        #[inline(always)]
1650        fn inline_align(_context: fidl::encoding::Context) -> usize {
1651            8
1652        }
1653
1654        #[inline(always)]
1655        fn inline_size(_context: fidl::encoding::Context) -> usize {
1656            16
1657        }
1658    }
1659
1660    unsafe impl<D: fidl::encoding::ResourceDialect>
1661        fidl::encoding::Encode<MacAddressFilterSettings, D> for &MacAddressFilterSettings
1662    {
1663        unsafe fn encode(
1664            self,
1665            encoder: &mut fidl::encoding::Encoder<'_, D>,
1666            offset: usize,
1667            mut depth: fidl::encoding::Depth,
1668        ) -> fidl::Result<()> {
1669            encoder.debug_check_bounds::<MacAddressFilterSettings>(offset);
1670            // Vector header
1671            let max_ordinal: u64 = self.max_ordinal_present();
1672            encoder.write_num(max_ordinal, offset);
1673            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1674            // Calling encoder.out_of_line_offset(0) is not allowed.
1675            if max_ordinal == 0 {
1676                return Ok(());
1677            }
1678            depth.increment()?;
1679            let envelope_size = 8;
1680            let bytes_len = max_ordinal as usize * envelope_size;
1681            #[allow(unused_variables)]
1682            let offset = encoder.out_of_line_offset(bytes_len);
1683            let mut _prev_end_offset: usize = 0;
1684            if 1 > max_ordinal {
1685                return Ok(());
1686            }
1687
1688            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1689            // are envelope_size bytes.
1690            let cur_offset: usize = (1 - 1) * envelope_size;
1691
1692            // Zero reserved fields.
1693            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1694
1695            // Safety:
1696            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1697            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1698            //   envelope_size bytes, there is always sufficient room.
1699            fidl::encoding::encode_in_envelope_optional::<MacAddressFilterMode, D>(
1700                self.mode
1701                    .as_ref()
1702                    .map(<MacAddressFilterMode as fidl::encoding::ValueTypeMarker>::borrow),
1703                encoder,
1704                offset + cur_offset,
1705                depth,
1706            )?;
1707
1708            _prev_end_offset = cur_offset + envelope_size;
1709            if 2 > max_ordinal {
1710                return Ok(());
1711            }
1712
1713            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1714            // are envelope_size bytes.
1715            let cur_offset: usize = (2 - 1) * envelope_size;
1716
1717            // Zero reserved fields.
1718            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1719
1720            // Safety:
1721            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1722            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1723            //   envelope_size bytes, there is always sufficient room.
1724            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<MacAddressFilterItem, 100>, D>(
1725            self.items.as_ref().map(<fidl::encoding::Vector<MacAddressFilterItem, 100> as fidl::encoding::ValueTypeMarker>::borrow),
1726            encoder, offset + cur_offset, depth
1727        )?;
1728
1729            _prev_end_offset = cur_offset + envelope_size;
1730
1731            Ok(())
1732        }
1733    }
1734
1735    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1736        for MacAddressFilterSettings
1737    {
1738        #[inline(always)]
1739        fn new_empty() -> Self {
1740            Self::default()
1741        }
1742
1743        unsafe fn decode(
1744            &mut self,
1745            decoder: &mut fidl::encoding::Decoder<'_, D>,
1746            offset: usize,
1747            mut depth: fidl::encoding::Depth,
1748        ) -> fidl::Result<()> {
1749            decoder.debug_check_bounds::<Self>(offset);
1750            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1751                None => return Err(fidl::Error::NotNullable),
1752                Some(len) => len,
1753            };
1754            // Calling decoder.out_of_line_offset(0) is not allowed.
1755            if len == 0 {
1756                return Ok(());
1757            };
1758            depth.increment()?;
1759            let envelope_size = 8;
1760            let bytes_len = len * envelope_size;
1761            let offset = decoder.out_of_line_offset(bytes_len)?;
1762            // Decode the envelope for each type.
1763            let mut _next_ordinal_to_read = 0;
1764            let mut next_offset = offset;
1765            let end_offset = offset + bytes_len;
1766            _next_ordinal_to_read += 1;
1767            if next_offset >= end_offset {
1768                return Ok(());
1769            }
1770
1771            // Decode unknown envelopes for gaps in ordinals.
1772            while _next_ordinal_to_read < 1 {
1773                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1774                _next_ordinal_to_read += 1;
1775                next_offset += envelope_size;
1776            }
1777
1778            let next_out_of_line = decoder.next_out_of_line();
1779            let handles_before = decoder.remaining_handles();
1780            if let Some((inlined, num_bytes, num_handles)) =
1781                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1782            {
1783                let member_inline_size =
1784                    <MacAddressFilterMode as fidl::encoding::TypeMarker>::inline_size(
1785                        decoder.context,
1786                    );
1787                if inlined != (member_inline_size <= 4) {
1788                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1789                }
1790                let inner_offset;
1791                let mut inner_depth = depth.clone();
1792                if inlined {
1793                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1794                    inner_offset = next_offset;
1795                } else {
1796                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1797                    inner_depth.increment()?;
1798                }
1799                let val_ref =
1800                    self.mode.get_or_insert_with(|| fidl::new_empty!(MacAddressFilterMode, D));
1801                fidl::decode!(
1802                    MacAddressFilterMode,
1803                    D,
1804                    val_ref,
1805                    decoder,
1806                    inner_offset,
1807                    inner_depth
1808                )?;
1809                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1810                {
1811                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1812                }
1813                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1814                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1815                }
1816            }
1817
1818            next_offset += envelope_size;
1819            _next_ordinal_to_read += 1;
1820            if next_offset >= end_offset {
1821                return Ok(());
1822            }
1823
1824            // Decode unknown envelopes for gaps in ordinals.
1825            while _next_ordinal_to_read < 2 {
1826                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1827                _next_ordinal_to_read += 1;
1828                next_offset += envelope_size;
1829            }
1830
1831            let next_out_of_line = decoder.next_out_of_line();
1832            let handles_before = decoder.remaining_handles();
1833            if let Some((inlined, num_bytes, num_handles)) =
1834                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1835            {
1836                let member_inline_size = <fidl::encoding::Vector<MacAddressFilterItem, 100> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1837                if inlined != (member_inline_size <= 4) {
1838                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1839                }
1840                let inner_offset;
1841                let mut inner_depth = depth.clone();
1842                if inlined {
1843                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1844                    inner_offset = next_offset;
1845                } else {
1846                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1847                    inner_depth.increment()?;
1848                }
1849                let val_ref = self.items.get_or_insert_with(
1850                    || fidl::new_empty!(fidl::encoding::Vector<MacAddressFilterItem, 100>, D),
1851                );
1852                fidl::decode!(fidl::encoding::Vector<MacAddressFilterItem, 100>, D, val_ref, decoder, inner_offset, inner_depth)?;
1853                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1854                {
1855                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1856                }
1857                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1858                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1859                }
1860            }
1861
1862            next_offset += envelope_size;
1863
1864            // Decode the remaining unknown envelopes.
1865            while next_offset < end_offset {
1866                _next_ordinal_to_read += 1;
1867                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1868                next_offset += envelope_size;
1869            }
1870
1871            Ok(())
1872        }
1873    }
1874
1875    impl NeighborInfo {
1876        #[inline(always)]
1877        fn max_ordinal_present(&self) -> u64 {
1878            if let Some(_) = self.thread_mle_version {
1879                return 17;
1880            }
1881            if let Some(_) = self.queued_messages {
1882                return 16;
1883            }
1884            if let Some(_) = self.net_data_version {
1885                return 15;
1886            }
1887            if let Some(_) = self.child_is_state_restoring {
1888                return 14;
1889            }
1890            if let Some(_) = self.child_is_csl_synced {
1891                return 13;
1892            }
1893            if let Some(_) = self.ipv6_error_rate {
1894                return 12;
1895            }
1896            if let Some(_) = self.frame_error_rate {
1897                return 11;
1898            }
1899            if let Some(_) = self.thread_mode {
1900                return 10;
1901            }
1902            if let Some(_) = self.lqi_in {
1903                return 9;
1904            }
1905            if let Some(_) = self.avg_rssi_in {
1906                return 8;
1907            }
1908            if let Some(_) = self.last_rssi_in {
1909                return 7;
1910            }
1911            if let Some(_) = self.mgmt_frame_count {
1912                return 6;
1913            }
1914            if let Some(_) = self.link_frame_count {
1915                return 5;
1916            }
1917            if let Some(_) = self.is_child {
1918                return 4;
1919            }
1920            if let Some(_) = self.age {
1921                return 3;
1922            }
1923            if let Some(_) = self.short_address {
1924                return 2;
1925            }
1926            if let Some(_) = self.mac_address {
1927                return 1;
1928            }
1929            0
1930        }
1931    }
1932
1933    impl fidl::encoding::ValueTypeMarker for NeighborInfo {
1934        type Borrowed<'a> = &'a Self;
1935        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1936            value
1937        }
1938    }
1939
1940    unsafe impl fidl::encoding::TypeMarker for NeighborInfo {
1941        type Owned = Self;
1942
1943        #[inline(always)]
1944        fn inline_align(_context: fidl::encoding::Context) -> usize {
1945            8
1946        }
1947
1948        #[inline(always)]
1949        fn inline_size(_context: fidl::encoding::Context) -> usize {
1950            16
1951        }
1952    }
1953
1954    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NeighborInfo, D>
1955        for &NeighborInfo
1956    {
1957        unsafe fn encode(
1958            self,
1959            encoder: &mut fidl::encoding::Encoder<'_, D>,
1960            offset: usize,
1961            mut depth: fidl::encoding::Depth,
1962        ) -> fidl::Result<()> {
1963            encoder.debug_check_bounds::<NeighborInfo>(offset);
1964            // Vector header
1965            let max_ordinal: u64 = self.max_ordinal_present();
1966            encoder.write_num(max_ordinal, offset);
1967            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1968            // Calling encoder.out_of_line_offset(0) is not allowed.
1969            if max_ordinal == 0 {
1970                return Ok(());
1971            }
1972            depth.increment()?;
1973            let envelope_size = 8;
1974            let bytes_len = max_ordinal as usize * envelope_size;
1975            #[allow(unused_variables)]
1976            let offset = encoder.out_of_line_offset(bytes_len);
1977            let mut _prev_end_offset: usize = 0;
1978            if 1 > max_ordinal {
1979                return Ok(());
1980            }
1981
1982            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1983            // are envelope_size bytes.
1984            let cur_offset: usize = (1 - 1) * envelope_size;
1985
1986            // Zero reserved fields.
1987            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1988
1989            // Safety:
1990            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1991            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1992            //   envelope_size bytes, there is always sufficient room.
1993            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_lowpan__common::MacAddress, D>(
1994            self.mac_address.as_ref().map(<fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
1995            encoder, offset + cur_offset, depth
1996        )?;
1997
1998            _prev_end_offset = cur_offset + envelope_size;
1999            if 2 > max_ordinal {
2000                return Ok(());
2001            }
2002
2003            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2004            // are envelope_size bytes.
2005            let cur_offset: usize = (2 - 1) * envelope_size;
2006
2007            // Zero reserved fields.
2008            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2009
2010            // Safety:
2011            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2012            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2013            //   envelope_size bytes, there is always sufficient room.
2014            fidl::encoding::encode_in_envelope_optional::<u16, D>(
2015                self.short_address.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2016                encoder,
2017                offset + cur_offset,
2018                depth,
2019            )?;
2020
2021            _prev_end_offset = cur_offset + envelope_size;
2022            if 3 > max_ordinal {
2023                return Ok(());
2024            }
2025
2026            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2027            // are envelope_size bytes.
2028            let cur_offset: usize = (3 - 1) * envelope_size;
2029
2030            // Zero reserved fields.
2031            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2032
2033            // Safety:
2034            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2035            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2036            //   envelope_size bytes, there is always sufficient room.
2037            fidl::encoding::encode_in_envelope_optional::<i64, D>(
2038                self.age.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2039                encoder,
2040                offset + cur_offset,
2041                depth,
2042            )?;
2043
2044            _prev_end_offset = cur_offset + envelope_size;
2045            if 4 > max_ordinal {
2046                return Ok(());
2047            }
2048
2049            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2050            // are envelope_size bytes.
2051            let cur_offset: usize = (4 - 1) * envelope_size;
2052
2053            // Zero reserved fields.
2054            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2055
2056            // Safety:
2057            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2058            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2059            //   envelope_size bytes, there is always sufficient room.
2060            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2061                self.is_child.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2062                encoder,
2063                offset + cur_offset,
2064                depth,
2065            )?;
2066
2067            _prev_end_offset = cur_offset + envelope_size;
2068            if 5 > max_ordinal {
2069                return Ok(());
2070            }
2071
2072            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2073            // are envelope_size bytes.
2074            let cur_offset: usize = (5 - 1) * envelope_size;
2075
2076            // Zero reserved fields.
2077            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2078
2079            // Safety:
2080            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2081            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2082            //   envelope_size bytes, there is always sufficient room.
2083            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2084                self.link_frame_count
2085                    .as_ref()
2086                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2087                encoder,
2088                offset + cur_offset,
2089                depth,
2090            )?;
2091
2092            _prev_end_offset = cur_offset + envelope_size;
2093            if 6 > max_ordinal {
2094                return Ok(());
2095            }
2096
2097            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2098            // are envelope_size bytes.
2099            let cur_offset: usize = (6 - 1) * envelope_size;
2100
2101            // Zero reserved fields.
2102            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2103
2104            // Safety:
2105            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2106            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2107            //   envelope_size bytes, there is always sufficient room.
2108            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2109                self.mgmt_frame_count
2110                    .as_ref()
2111                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2112                encoder,
2113                offset + cur_offset,
2114                depth,
2115            )?;
2116
2117            _prev_end_offset = cur_offset + envelope_size;
2118            if 7 > max_ordinal {
2119                return Ok(());
2120            }
2121
2122            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2123            // are envelope_size bytes.
2124            let cur_offset: usize = (7 - 1) * envelope_size;
2125
2126            // Zero reserved fields.
2127            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2128
2129            // Safety:
2130            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2131            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2132            //   envelope_size bytes, there is always sufficient room.
2133            fidl::encoding::encode_in_envelope_optional::<i32, D>(
2134                self.last_rssi_in.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
2135                encoder,
2136                offset + cur_offset,
2137                depth,
2138            )?;
2139
2140            _prev_end_offset = cur_offset + envelope_size;
2141            if 8 > max_ordinal {
2142                return Ok(());
2143            }
2144
2145            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2146            // are envelope_size bytes.
2147            let cur_offset: usize = (8 - 1) * envelope_size;
2148
2149            // Zero reserved fields.
2150            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2151
2152            // Safety:
2153            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2154            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2155            //   envelope_size bytes, there is always sufficient room.
2156            fidl::encoding::encode_in_envelope_optional::<i8, D>(
2157                self.avg_rssi_in.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
2158                encoder,
2159                offset + cur_offset,
2160                depth,
2161            )?;
2162
2163            _prev_end_offset = cur_offset + envelope_size;
2164            if 9 > max_ordinal {
2165                return Ok(());
2166            }
2167
2168            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2169            // are envelope_size bytes.
2170            let cur_offset: usize = (9 - 1) * envelope_size;
2171
2172            // Zero reserved fields.
2173            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2174
2175            // Safety:
2176            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2177            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2178            //   envelope_size bytes, there is always sufficient room.
2179            fidl::encoding::encode_in_envelope_optional::<u8, D>(
2180                self.lqi_in.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
2181                encoder,
2182                offset + cur_offset,
2183                depth,
2184            )?;
2185
2186            _prev_end_offset = cur_offset + envelope_size;
2187            if 10 > max_ordinal {
2188                return Ok(());
2189            }
2190
2191            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2192            // are envelope_size bytes.
2193            let cur_offset: usize = (10 - 1) * envelope_size;
2194
2195            // Zero reserved fields.
2196            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2197
2198            // Safety:
2199            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2200            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2201            //   envelope_size bytes, there is always sufficient room.
2202            fidl::encoding::encode_in_envelope_optional::<u8, D>(
2203                self.thread_mode.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
2204                encoder,
2205                offset + cur_offset,
2206                depth,
2207            )?;
2208
2209            _prev_end_offset = cur_offset + envelope_size;
2210            if 11 > max_ordinal {
2211                return Ok(());
2212            }
2213
2214            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2215            // are envelope_size bytes.
2216            let cur_offset: usize = (11 - 1) * envelope_size;
2217
2218            // Zero reserved fields.
2219            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2220
2221            // Safety:
2222            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2223            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2224            //   envelope_size bytes, there is always sufficient room.
2225            fidl::encoding::encode_in_envelope_optional::<u16, D>(
2226                self.frame_error_rate
2227                    .as_ref()
2228                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2229                encoder,
2230                offset + cur_offset,
2231                depth,
2232            )?;
2233
2234            _prev_end_offset = cur_offset + envelope_size;
2235            if 12 > max_ordinal {
2236                return Ok(());
2237            }
2238
2239            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2240            // are envelope_size bytes.
2241            let cur_offset: usize = (12 - 1) * envelope_size;
2242
2243            // Zero reserved fields.
2244            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2245
2246            // Safety:
2247            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2248            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2249            //   envelope_size bytes, there is always sufficient room.
2250            fidl::encoding::encode_in_envelope_optional::<u16, D>(
2251                self.ipv6_error_rate.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2252                encoder,
2253                offset + cur_offset,
2254                depth,
2255            )?;
2256
2257            _prev_end_offset = cur_offset + envelope_size;
2258            if 13 > max_ordinal {
2259                return Ok(());
2260            }
2261
2262            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2263            // are envelope_size bytes.
2264            let cur_offset: usize = (13 - 1) * envelope_size;
2265
2266            // Zero reserved fields.
2267            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2268
2269            // Safety:
2270            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2271            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2272            //   envelope_size bytes, there is always sufficient room.
2273            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2274                self.child_is_csl_synced
2275                    .as_ref()
2276                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2277                encoder,
2278                offset + cur_offset,
2279                depth,
2280            )?;
2281
2282            _prev_end_offset = cur_offset + envelope_size;
2283            if 14 > max_ordinal {
2284                return Ok(());
2285            }
2286
2287            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2288            // are envelope_size bytes.
2289            let cur_offset: usize = (14 - 1) * envelope_size;
2290
2291            // Zero reserved fields.
2292            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2293
2294            // Safety:
2295            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2296            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2297            //   envelope_size bytes, there is always sufficient room.
2298            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2299                self.child_is_state_restoring
2300                    .as_ref()
2301                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2302                encoder,
2303                offset + cur_offset,
2304                depth,
2305            )?;
2306
2307            _prev_end_offset = cur_offset + envelope_size;
2308            if 15 > max_ordinal {
2309                return Ok(());
2310            }
2311
2312            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2313            // are envelope_size bytes.
2314            let cur_offset: usize = (15 - 1) * envelope_size;
2315
2316            // Zero reserved fields.
2317            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2318
2319            // Safety:
2320            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2321            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2322            //   envelope_size bytes, there is always sufficient room.
2323            fidl::encoding::encode_in_envelope_optional::<u8, D>(
2324                self.net_data_version.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
2325                encoder,
2326                offset + cur_offset,
2327                depth,
2328            )?;
2329
2330            _prev_end_offset = cur_offset + envelope_size;
2331            if 16 > max_ordinal {
2332                return Ok(());
2333            }
2334
2335            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2336            // are envelope_size bytes.
2337            let cur_offset: usize = (16 - 1) * envelope_size;
2338
2339            // Zero reserved fields.
2340            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2341
2342            // Safety:
2343            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2344            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2345            //   envelope_size bytes, there is always sufficient room.
2346            fidl::encoding::encode_in_envelope_optional::<u16, D>(
2347                self.queued_messages.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
2348                encoder,
2349                offset + cur_offset,
2350                depth,
2351            )?;
2352
2353            _prev_end_offset = cur_offset + envelope_size;
2354            if 17 > max_ordinal {
2355                return Ok(());
2356            }
2357
2358            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2359            // are envelope_size bytes.
2360            let cur_offset: usize = (17 - 1) * envelope_size;
2361
2362            // Zero reserved fields.
2363            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2364
2365            // Safety:
2366            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2367            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2368            //   envelope_size bytes, there is always sufficient room.
2369            fidl::encoding::encode_in_envelope_optional::<u8, D>(
2370                self.thread_mle_version
2371                    .as_ref()
2372                    .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
2373                encoder,
2374                offset + cur_offset,
2375                depth,
2376            )?;
2377
2378            _prev_end_offset = cur_offset + envelope_size;
2379
2380            Ok(())
2381        }
2382    }
2383
2384    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NeighborInfo {
2385        #[inline(always)]
2386        fn new_empty() -> Self {
2387            Self::default()
2388        }
2389
2390        unsafe fn decode(
2391            &mut self,
2392            decoder: &mut fidl::encoding::Decoder<'_, D>,
2393            offset: usize,
2394            mut depth: fidl::encoding::Depth,
2395        ) -> fidl::Result<()> {
2396            decoder.debug_check_bounds::<Self>(offset);
2397            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2398                None => return Err(fidl::Error::NotNullable),
2399                Some(len) => len,
2400            };
2401            // Calling decoder.out_of_line_offset(0) is not allowed.
2402            if len == 0 {
2403                return Ok(());
2404            };
2405            depth.increment()?;
2406            let envelope_size = 8;
2407            let bytes_len = len * envelope_size;
2408            let offset = decoder.out_of_line_offset(bytes_len)?;
2409            // Decode the envelope for each type.
2410            let mut _next_ordinal_to_read = 0;
2411            let mut next_offset = offset;
2412            let end_offset = offset + bytes_len;
2413            _next_ordinal_to_read += 1;
2414            if next_offset >= end_offset {
2415                return Ok(());
2416            }
2417
2418            // Decode unknown envelopes for gaps in ordinals.
2419            while _next_ordinal_to_read < 1 {
2420                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2421                _next_ordinal_to_read += 1;
2422                next_offset += envelope_size;
2423            }
2424
2425            let next_out_of_line = decoder.next_out_of_line();
2426            let handles_before = decoder.remaining_handles();
2427            if let Some((inlined, num_bytes, num_handles)) =
2428                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2429            {
2430                let member_inline_size = <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2431                if inlined != (member_inline_size <= 4) {
2432                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2433                }
2434                let inner_offset;
2435                let mut inner_depth = depth.clone();
2436                if inlined {
2437                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2438                    inner_offset = next_offset;
2439                } else {
2440                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2441                    inner_depth.increment()?;
2442                }
2443                let val_ref = self.mac_address.get_or_insert_with(|| {
2444                    fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D)
2445                });
2446                fidl::decode!(
2447                    fidl_fuchsia_lowpan__common::MacAddress,
2448                    D,
2449                    val_ref,
2450                    decoder,
2451                    inner_offset,
2452                    inner_depth
2453                )?;
2454                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2455                {
2456                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2457                }
2458                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2459                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2460                }
2461            }
2462
2463            next_offset += envelope_size;
2464            _next_ordinal_to_read += 1;
2465            if next_offset >= end_offset {
2466                return Ok(());
2467            }
2468
2469            // Decode unknown envelopes for gaps in ordinals.
2470            while _next_ordinal_to_read < 2 {
2471                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2472                _next_ordinal_to_read += 1;
2473                next_offset += envelope_size;
2474            }
2475
2476            let next_out_of_line = decoder.next_out_of_line();
2477            let handles_before = decoder.remaining_handles();
2478            if let Some((inlined, num_bytes, num_handles)) =
2479                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2480            {
2481                let member_inline_size =
2482                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2483                if inlined != (member_inline_size <= 4) {
2484                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2485                }
2486                let inner_offset;
2487                let mut inner_depth = depth.clone();
2488                if inlined {
2489                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2490                    inner_offset = next_offset;
2491                } else {
2492                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2493                    inner_depth.increment()?;
2494                }
2495                let val_ref = self.short_address.get_or_insert_with(|| fidl::new_empty!(u16, D));
2496                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
2497                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2498                {
2499                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2500                }
2501                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2502                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2503                }
2504            }
2505
2506            next_offset += envelope_size;
2507            _next_ordinal_to_read += 1;
2508            if next_offset >= end_offset {
2509                return Ok(());
2510            }
2511
2512            // Decode unknown envelopes for gaps in ordinals.
2513            while _next_ordinal_to_read < 3 {
2514                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2515                _next_ordinal_to_read += 1;
2516                next_offset += envelope_size;
2517            }
2518
2519            let next_out_of_line = decoder.next_out_of_line();
2520            let handles_before = decoder.remaining_handles();
2521            if let Some((inlined, num_bytes, num_handles)) =
2522                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2523            {
2524                let member_inline_size =
2525                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2526                if inlined != (member_inline_size <= 4) {
2527                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2528                }
2529                let inner_offset;
2530                let mut inner_depth = depth.clone();
2531                if inlined {
2532                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2533                    inner_offset = next_offset;
2534                } else {
2535                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2536                    inner_depth.increment()?;
2537                }
2538                let val_ref = self.age.get_or_insert_with(|| fidl::new_empty!(i64, D));
2539                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
2540                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2541                {
2542                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2543                }
2544                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2545                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2546                }
2547            }
2548
2549            next_offset += envelope_size;
2550            _next_ordinal_to_read += 1;
2551            if next_offset >= end_offset {
2552                return Ok(());
2553            }
2554
2555            // Decode unknown envelopes for gaps in ordinals.
2556            while _next_ordinal_to_read < 4 {
2557                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2558                _next_ordinal_to_read += 1;
2559                next_offset += envelope_size;
2560            }
2561
2562            let next_out_of_line = decoder.next_out_of_line();
2563            let handles_before = decoder.remaining_handles();
2564            if let Some((inlined, num_bytes, num_handles)) =
2565                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2566            {
2567                let member_inline_size =
2568                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2569                if inlined != (member_inline_size <= 4) {
2570                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2571                }
2572                let inner_offset;
2573                let mut inner_depth = depth.clone();
2574                if inlined {
2575                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2576                    inner_offset = next_offset;
2577                } else {
2578                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2579                    inner_depth.increment()?;
2580                }
2581                let val_ref = self.is_child.get_or_insert_with(|| fidl::new_empty!(bool, D));
2582                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2583                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2584                {
2585                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2586                }
2587                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2588                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2589                }
2590            }
2591
2592            next_offset += envelope_size;
2593            _next_ordinal_to_read += 1;
2594            if next_offset >= end_offset {
2595                return Ok(());
2596            }
2597
2598            // Decode unknown envelopes for gaps in ordinals.
2599            while _next_ordinal_to_read < 5 {
2600                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2601                _next_ordinal_to_read += 1;
2602                next_offset += envelope_size;
2603            }
2604
2605            let next_out_of_line = decoder.next_out_of_line();
2606            let handles_before = decoder.remaining_handles();
2607            if let Some((inlined, num_bytes, num_handles)) =
2608                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2609            {
2610                let member_inline_size =
2611                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2612                if inlined != (member_inline_size <= 4) {
2613                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2614                }
2615                let inner_offset;
2616                let mut inner_depth = depth.clone();
2617                if inlined {
2618                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2619                    inner_offset = next_offset;
2620                } else {
2621                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2622                    inner_depth.increment()?;
2623                }
2624                let val_ref = self.link_frame_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
2625                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2626                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2627                {
2628                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2629                }
2630                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2631                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2632                }
2633            }
2634
2635            next_offset += envelope_size;
2636            _next_ordinal_to_read += 1;
2637            if next_offset >= end_offset {
2638                return Ok(());
2639            }
2640
2641            // Decode unknown envelopes for gaps in ordinals.
2642            while _next_ordinal_to_read < 6 {
2643                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2644                _next_ordinal_to_read += 1;
2645                next_offset += envelope_size;
2646            }
2647
2648            let next_out_of_line = decoder.next_out_of_line();
2649            let handles_before = decoder.remaining_handles();
2650            if let Some((inlined, num_bytes, num_handles)) =
2651                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2652            {
2653                let member_inline_size =
2654                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2655                if inlined != (member_inline_size <= 4) {
2656                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2657                }
2658                let inner_offset;
2659                let mut inner_depth = depth.clone();
2660                if inlined {
2661                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2662                    inner_offset = next_offset;
2663                } else {
2664                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2665                    inner_depth.increment()?;
2666                }
2667                let val_ref = self.mgmt_frame_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
2668                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2669                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2670                {
2671                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2672                }
2673                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2674                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2675                }
2676            }
2677
2678            next_offset += envelope_size;
2679            _next_ordinal_to_read += 1;
2680            if next_offset >= end_offset {
2681                return Ok(());
2682            }
2683
2684            // Decode unknown envelopes for gaps in ordinals.
2685            while _next_ordinal_to_read < 7 {
2686                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2687                _next_ordinal_to_read += 1;
2688                next_offset += envelope_size;
2689            }
2690
2691            let next_out_of_line = decoder.next_out_of_line();
2692            let handles_before = decoder.remaining_handles();
2693            if let Some((inlined, num_bytes, num_handles)) =
2694                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2695            {
2696                let member_inline_size =
2697                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2698                if inlined != (member_inline_size <= 4) {
2699                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2700                }
2701                let inner_offset;
2702                let mut inner_depth = depth.clone();
2703                if inlined {
2704                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2705                    inner_offset = next_offset;
2706                } else {
2707                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2708                    inner_depth.increment()?;
2709                }
2710                let val_ref = self.last_rssi_in.get_or_insert_with(|| fidl::new_empty!(i32, D));
2711                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
2712                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2713                {
2714                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2715                }
2716                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2717                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2718                }
2719            }
2720
2721            next_offset += envelope_size;
2722            _next_ordinal_to_read += 1;
2723            if next_offset >= end_offset {
2724                return Ok(());
2725            }
2726
2727            // Decode unknown envelopes for gaps in ordinals.
2728            while _next_ordinal_to_read < 8 {
2729                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2730                _next_ordinal_to_read += 1;
2731                next_offset += envelope_size;
2732            }
2733
2734            let next_out_of_line = decoder.next_out_of_line();
2735            let handles_before = decoder.remaining_handles();
2736            if let Some((inlined, num_bytes, num_handles)) =
2737                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2738            {
2739                let member_inline_size =
2740                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2741                if inlined != (member_inline_size <= 4) {
2742                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2743                }
2744                let inner_offset;
2745                let mut inner_depth = depth.clone();
2746                if inlined {
2747                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2748                    inner_offset = next_offset;
2749                } else {
2750                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2751                    inner_depth.increment()?;
2752                }
2753                let val_ref = self.avg_rssi_in.get_or_insert_with(|| fidl::new_empty!(i8, D));
2754                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
2755                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2756                {
2757                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2758                }
2759                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2760                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2761                }
2762            }
2763
2764            next_offset += envelope_size;
2765            _next_ordinal_to_read += 1;
2766            if next_offset >= end_offset {
2767                return Ok(());
2768            }
2769
2770            // Decode unknown envelopes for gaps in ordinals.
2771            while _next_ordinal_to_read < 9 {
2772                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2773                _next_ordinal_to_read += 1;
2774                next_offset += envelope_size;
2775            }
2776
2777            let next_out_of_line = decoder.next_out_of_line();
2778            let handles_before = decoder.remaining_handles();
2779            if let Some((inlined, num_bytes, num_handles)) =
2780                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2781            {
2782                let member_inline_size =
2783                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2784                if inlined != (member_inline_size <= 4) {
2785                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2786                }
2787                let inner_offset;
2788                let mut inner_depth = depth.clone();
2789                if inlined {
2790                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2791                    inner_offset = next_offset;
2792                } else {
2793                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2794                    inner_depth.increment()?;
2795                }
2796                let val_ref = self.lqi_in.get_or_insert_with(|| fidl::new_empty!(u8, D));
2797                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
2798                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2799                {
2800                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2801                }
2802                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2803                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2804                }
2805            }
2806
2807            next_offset += envelope_size;
2808            _next_ordinal_to_read += 1;
2809            if next_offset >= end_offset {
2810                return Ok(());
2811            }
2812
2813            // Decode unknown envelopes for gaps in ordinals.
2814            while _next_ordinal_to_read < 10 {
2815                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2816                _next_ordinal_to_read += 1;
2817                next_offset += envelope_size;
2818            }
2819
2820            let next_out_of_line = decoder.next_out_of_line();
2821            let handles_before = decoder.remaining_handles();
2822            if let Some((inlined, num_bytes, num_handles)) =
2823                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2824            {
2825                let member_inline_size =
2826                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2827                if inlined != (member_inline_size <= 4) {
2828                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2829                }
2830                let inner_offset;
2831                let mut inner_depth = depth.clone();
2832                if inlined {
2833                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2834                    inner_offset = next_offset;
2835                } else {
2836                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2837                    inner_depth.increment()?;
2838                }
2839                let val_ref = self.thread_mode.get_or_insert_with(|| fidl::new_empty!(u8, D));
2840                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
2841                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2842                {
2843                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2844                }
2845                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2846                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2847                }
2848            }
2849
2850            next_offset += envelope_size;
2851            _next_ordinal_to_read += 1;
2852            if next_offset >= end_offset {
2853                return Ok(());
2854            }
2855
2856            // Decode unknown envelopes for gaps in ordinals.
2857            while _next_ordinal_to_read < 11 {
2858                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2859                _next_ordinal_to_read += 1;
2860                next_offset += envelope_size;
2861            }
2862
2863            let next_out_of_line = decoder.next_out_of_line();
2864            let handles_before = decoder.remaining_handles();
2865            if let Some((inlined, num_bytes, num_handles)) =
2866                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2867            {
2868                let member_inline_size =
2869                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2870                if inlined != (member_inline_size <= 4) {
2871                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2872                }
2873                let inner_offset;
2874                let mut inner_depth = depth.clone();
2875                if inlined {
2876                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2877                    inner_offset = next_offset;
2878                } else {
2879                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2880                    inner_depth.increment()?;
2881                }
2882                let val_ref = self.frame_error_rate.get_or_insert_with(|| fidl::new_empty!(u16, D));
2883                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
2884                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2885                {
2886                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2887                }
2888                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2889                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2890                }
2891            }
2892
2893            next_offset += envelope_size;
2894            _next_ordinal_to_read += 1;
2895            if next_offset >= end_offset {
2896                return Ok(());
2897            }
2898
2899            // Decode unknown envelopes for gaps in ordinals.
2900            while _next_ordinal_to_read < 12 {
2901                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2902                _next_ordinal_to_read += 1;
2903                next_offset += envelope_size;
2904            }
2905
2906            let next_out_of_line = decoder.next_out_of_line();
2907            let handles_before = decoder.remaining_handles();
2908            if let Some((inlined, num_bytes, num_handles)) =
2909                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2910            {
2911                let member_inline_size =
2912                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2913                if inlined != (member_inline_size <= 4) {
2914                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2915                }
2916                let inner_offset;
2917                let mut inner_depth = depth.clone();
2918                if inlined {
2919                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2920                    inner_offset = next_offset;
2921                } else {
2922                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2923                    inner_depth.increment()?;
2924                }
2925                let val_ref = self.ipv6_error_rate.get_or_insert_with(|| fidl::new_empty!(u16, D));
2926                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
2927                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2928                {
2929                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2930                }
2931                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2932                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2933                }
2934            }
2935
2936            next_offset += envelope_size;
2937            _next_ordinal_to_read += 1;
2938            if next_offset >= end_offset {
2939                return Ok(());
2940            }
2941
2942            // Decode unknown envelopes for gaps in ordinals.
2943            while _next_ordinal_to_read < 13 {
2944                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2945                _next_ordinal_to_read += 1;
2946                next_offset += envelope_size;
2947            }
2948
2949            let next_out_of_line = decoder.next_out_of_line();
2950            let handles_before = decoder.remaining_handles();
2951            if let Some((inlined, num_bytes, num_handles)) =
2952                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2953            {
2954                let member_inline_size =
2955                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2956                if inlined != (member_inline_size <= 4) {
2957                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2958                }
2959                let inner_offset;
2960                let mut inner_depth = depth.clone();
2961                if inlined {
2962                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2963                    inner_offset = next_offset;
2964                } else {
2965                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2966                    inner_depth.increment()?;
2967                }
2968                let val_ref =
2969                    self.child_is_csl_synced.get_or_insert_with(|| fidl::new_empty!(bool, D));
2970                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2971                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2972                {
2973                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2974                }
2975                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2976                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2977                }
2978            }
2979
2980            next_offset += envelope_size;
2981            _next_ordinal_to_read += 1;
2982            if next_offset >= end_offset {
2983                return Ok(());
2984            }
2985
2986            // Decode unknown envelopes for gaps in ordinals.
2987            while _next_ordinal_to_read < 14 {
2988                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2989                _next_ordinal_to_read += 1;
2990                next_offset += envelope_size;
2991            }
2992
2993            let next_out_of_line = decoder.next_out_of_line();
2994            let handles_before = decoder.remaining_handles();
2995            if let Some((inlined, num_bytes, num_handles)) =
2996                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2997            {
2998                let member_inline_size =
2999                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3000                if inlined != (member_inline_size <= 4) {
3001                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3002                }
3003                let inner_offset;
3004                let mut inner_depth = depth.clone();
3005                if inlined {
3006                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3007                    inner_offset = next_offset;
3008                } else {
3009                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3010                    inner_depth.increment()?;
3011                }
3012                let val_ref =
3013                    self.child_is_state_restoring.get_or_insert_with(|| fidl::new_empty!(bool, D));
3014                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3015                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3016                {
3017                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3018                }
3019                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3020                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3021                }
3022            }
3023
3024            next_offset += envelope_size;
3025            _next_ordinal_to_read += 1;
3026            if next_offset >= end_offset {
3027                return Ok(());
3028            }
3029
3030            // Decode unknown envelopes for gaps in ordinals.
3031            while _next_ordinal_to_read < 15 {
3032                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3033                _next_ordinal_to_read += 1;
3034                next_offset += envelope_size;
3035            }
3036
3037            let next_out_of_line = decoder.next_out_of_line();
3038            let handles_before = decoder.remaining_handles();
3039            if let Some((inlined, num_bytes, num_handles)) =
3040                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3041            {
3042                let member_inline_size =
3043                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3044                if inlined != (member_inline_size <= 4) {
3045                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3046                }
3047                let inner_offset;
3048                let mut inner_depth = depth.clone();
3049                if inlined {
3050                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3051                    inner_offset = next_offset;
3052                } else {
3053                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3054                    inner_depth.increment()?;
3055                }
3056                let val_ref = self.net_data_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
3057                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
3058                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3059                {
3060                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3061                }
3062                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3063                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3064                }
3065            }
3066
3067            next_offset += envelope_size;
3068            _next_ordinal_to_read += 1;
3069            if next_offset >= end_offset {
3070                return Ok(());
3071            }
3072
3073            // Decode unknown envelopes for gaps in ordinals.
3074            while _next_ordinal_to_read < 16 {
3075                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3076                _next_ordinal_to_read += 1;
3077                next_offset += envelope_size;
3078            }
3079
3080            let next_out_of_line = decoder.next_out_of_line();
3081            let handles_before = decoder.remaining_handles();
3082            if let Some((inlined, num_bytes, num_handles)) =
3083                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3084            {
3085                let member_inline_size =
3086                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3087                if inlined != (member_inline_size <= 4) {
3088                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3089                }
3090                let inner_offset;
3091                let mut inner_depth = depth.clone();
3092                if inlined {
3093                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3094                    inner_offset = next_offset;
3095                } else {
3096                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3097                    inner_depth.increment()?;
3098                }
3099                let val_ref = self.queued_messages.get_or_insert_with(|| fidl::new_empty!(u16, D));
3100                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3101                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3102                {
3103                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3104                }
3105                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3106                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3107                }
3108            }
3109
3110            next_offset += envelope_size;
3111            _next_ordinal_to_read += 1;
3112            if next_offset >= end_offset {
3113                return Ok(());
3114            }
3115
3116            // Decode unknown envelopes for gaps in ordinals.
3117            while _next_ordinal_to_read < 17 {
3118                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3119                _next_ordinal_to_read += 1;
3120                next_offset += envelope_size;
3121            }
3122
3123            let next_out_of_line = decoder.next_out_of_line();
3124            let handles_before = decoder.remaining_handles();
3125            if let Some((inlined, num_bytes, num_handles)) =
3126                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3127            {
3128                let member_inline_size =
3129                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3130                if inlined != (member_inline_size <= 4) {
3131                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3132                }
3133                let inner_offset;
3134                let mut inner_depth = depth.clone();
3135                if inlined {
3136                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3137                    inner_offset = next_offset;
3138                } else {
3139                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3140                    inner_depth.increment()?;
3141                }
3142                let val_ref =
3143                    self.thread_mle_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
3144                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
3145                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3146                {
3147                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3148                }
3149                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3150                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3151                }
3152            }
3153
3154            next_offset += envelope_size;
3155
3156            // Decode the remaining unknown envelopes.
3157            while next_offset < end_offset {
3158                _next_ordinal_to_read += 1;
3159                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3160                next_offset += envelope_size;
3161            }
3162
3163            Ok(())
3164        }
3165    }
3166}