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