fidl_fuchsia_wlan_wlanix__common/
fidl_fuchsia_wlan_wlanix__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#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
12pub enum IfaceConcurrencyType {
13    Sta,
14    Ap,
15    ApBridged,
16    P2P,
17    NanIface,
18    #[doc(hidden)]
19    __SourceBreaking {
20        unknown_ordinal: u32,
21    },
22}
23
24/// Pattern that matches an unknown `IfaceConcurrencyType` member.
25#[macro_export]
26macro_rules! IfaceConcurrencyTypeUnknown {
27    () => {
28        _
29    };
30}
31
32impl IfaceConcurrencyType {
33    #[inline]
34    pub fn from_primitive(prim: u32) -> Option<Self> {
35        match prim {
36            1 => Some(Self::Sta),
37            2 => Some(Self::Ap),
38            3 => Some(Self::ApBridged),
39            4 => Some(Self::P2P),
40            5 => Some(Self::NanIface),
41            _ => None,
42        }
43    }
44
45    #[inline]
46    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
47        match prim {
48            1 => Self::Sta,
49            2 => Self::Ap,
50            3 => Self::ApBridged,
51            4 => Self::P2P,
52            5 => Self::NanIface,
53            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
54        }
55    }
56
57    #[inline]
58    pub fn unknown() -> Self {
59        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
60    }
61
62    #[inline]
63    pub const fn into_primitive(self) -> u32 {
64        match self {
65            Self::Sta => 1,
66            Self::Ap => 2,
67            Self::ApBridged => 3,
68            Self::P2P => 4,
69            Self::NanIface => 5,
70            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
71        }
72    }
73
74    #[inline]
75    pub fn is_unknown(&self) -> bool {
76        match self {
77            Self::__SourceBreaking { unknown_ordinal: _ } => true,
78            _ => false,
79        }
80    }
81}
82
83#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
84pub enum Nl80211MessageType {
85    Done,
86    Error,
87    Ack,
88    NoOp,
89    Overrun,
90    Message,
91    #[doc(hidden)]
92    __SourceBreaking {
93        unknown_ordinal: u32,
94    },
95}
96
97/// Pattern that matches an unknown `Nl80211MessageType` member.
98#[macro_export]
99macro_rules! Nl80211MessageTypeUnknown {
100    () => {
101        _
102    };
103}
104
105impl Nl80211MessageType {
106    #[inline]
107    pub fn from_primitive(prim: u32) -> Option<Self> {
108        match prim {
109            1 => Some(Self::Done),
110            2 => Some(Self::Error),
111            3 => Some(Self::Ack),
112            4 => Some(Self::NoOp),
113            5 => Some(Self::Overrun),
114            6 => Some(Self::Message),
115            _ => None,
116        }
117    }
118
119    #[inline]
120    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
121        match prim {
122            1 => Self::Done,
123            2 => Self::Error,
124            3 => Self::Ack,
125            4 => Self::NoOp,
126            5 => Self::Overrun,
127            6 => Self::Message,
128            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
129        }
130    }
131
132    #[inline]
133    pub fn unknown() -> Self {
134        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
135    }
136
137    #[inline]
138    pub const fn into_primitive(self) -> u32 {
139        match self {
140            Self::Done => 1,
141            Self::Error => 2,
142            Self::Ack => 3,
143            Self::NoOp => 4,
144            Self::Overrun => 5,
145            Self::Message => 6,
146            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
147        }
148    }
149
150    #[inline]
151    pub fn is_unknown(&self) -> bool {
152        match self {
153            Self::__SourceBreaking { unknown_ordinal: _ } => true,
154            _ => false,
155        }
156    }
157}
158
159#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
160pub enum StaIfaceCallbackState {
161    Disconnected,
162    IfaceDisabled,
163    Inactive,
164    Scanning,
165    Authenticating,
166    Associating,
167    Associated,
168    FourwayHandshake,
169    GroupHandshake,
170    Completed,
171    #[doc(hidden)]
172    __SourceBreaking {
173        unknown_ordinal: u32,
174    },
175}
176
177/// Pattern that matches an unknown `StaIfaceCallbackState` member.
178#[macro_export]
179macro_rules! StaIfaceCallbackStateUnknown {
180    () => {
181        _
182    };
183}
184
185impl StaIfaceCallbackState {
186    #[inline]
187    pub fn from_primitive(prim: u32) -> Option<Self> {
188        match prim {
189            0 => Some(Self::Disconnected),
190            1 => Some(Self::IfaceDisabled),
191            2 => Some(Self::Inactive),
192            3 => Some(Self::Scanning),
193            4 => Some(Self::Authenticating),
194            5 => Some(Self::Associating),
195            6 => Some(Self::Associated),
196            7 => Some(Self::FourwayHandshake),
197            8 => Some(Self::GroupHandshake),
198            9 => Some(Self::Completed),
199            _ => None,
200        }
201    }
202
203    #[inline]
204    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
205        match prim {
206            0 => Self::Disconnected,
207            1 => Self::IfaceDisabled,
208            2 => Self::Inactive,
209            3 => Self::Scanning,
210            4 => Self::Authenticating,
211            5 => Self::Associating,
212            6 => Self::Associated,
213            7 => Self::FourwayHandshake,
214            8 => Self::GroupHandshake,
215            9 => Self::Completed,
216            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
217        }
218    }
219
220    #[inline]
221    pub fn unknown() -> Self {
222        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
223    }
224
225    #[inline]
226    pub const fn into_primitive(self) -> u32 {
227        match self {
228            Self::Disconnected => 0,
229            Self::IfaceDisabled => 1,
230            Self::Inactive => 2,
231            Self::Scanning => 3,
232            Self::Authenticating => 4,
233            Self::Associating => 5,
234            Self::Associated => 6,
235            Self::FourwayHandshake => 7,
236            Self::GroupHandshake => 8,
237            Self::Completed => 9,
238            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
239        }
240    }
241
242    #[inline]
243    pub fn is_unknown(&self) -> bool {
244        match self {
245            Self::__SourceBreaking { unknown_ordinal: _ } => true,
246            _ => false,
247        }
248    }
249}
250
251#[derive(Clone, Debug, Default, PartialEq)]
252pub struct ChipConcurrencyCombination {
253    pub limits: Option<Vec<ChipConcurrencyCombinationLimit>>,
254    #[doc(hidden)]
255    pub __source_breaking: fidl::marker::SourceBreaking,
256}
257
258impl fidl::Persistable for ChipConcurrencyCombination {}
259
260#[derive(Clone, Debug, Default, PartialEq)]
261pub struct ChipConcurrencyCombinationLimit {
262    pub types: Option<Vec<IfaceConcurrencyType>>,
263    pub max_ifaces: Option<u32>,
264    #[doc(hidden)]
265    pub __source_breaking: fidl::marker::SourceBreaking,
266}
267
268impl fidl::Persistable for ChipConcurrencyCombinationLimit {}
269
270#[derive(Clone, Debug, Default, PartialEq)]
271pub struct ChipMode {
272    pub id: Option<u32>,
273    pub available_combinations: Option<Vec<ChipConcurrencyCombination>>,
274    #[doc(hidden)]
275    pub __source_breaking: fidl::marker::SourceBreaking,
276}
277
278impl fidl::Persistable for ChipMode {}
279
280#[derive(Clone, Debug, Default, PartialEq)]
281pub struct Nl80211Message {
282    pub message_type: Option<Nl80211MessageType>,
283    pub payload: Option<Vec<u8>>,
284    #[doc(hidden)]
285    pub __source_breaking: fidl::marker::SourceBreaking,
286}
287
288impl fidl::Persistable for Nl80211Message {}
289
290#[derive(Clone, Debug, Default, PartialEq)]
291pub struct SupplicantStaIfaceCallbackOnAssociationRejectedRequest {
292    pub ssid: Option<Vec<u8>>,
293    pub bssid: Option<[u8; 6]>,
294    pub status_code: Option<fidl_fuchsia_wlan_ieee80211__common::StatusCode>,
295    pub timed_out: Option<bool>,
296    #[doc(hidden)]
297    pub __source_breaking: fidl::marker::SourceBreaking,
298}
299
300impl fidl::Persistable for SupplicantStaIfaceCallbackOnAssociationRejectedRequest {}
301
302#[derive(Clone, Debug, Default, PartialEq)]
303pub struct SupplicantStaIfaceCallbackOnDisconnectedRequest {
304    pub bssid: Option<[u8; 6]>,
305    pub locally_generated: Option<bool>,
306    pub reason_code: Option<fidl_fuchsia_wlan_ieee80211__common::ReasonCode>,
307    #[doc(hidden)]
308    pub __source_breaking: fidl::marker::SourceBreaking,
309}
310
311impl fidl::Persistable for SupplicantStaIfaceCallbackOnDisconnectedRequest {}
312
313#[derive(Clone, Debug, Default, PartialEq)]
314pub struct SupplicantStaIfaceCallbackOnStateChangedRequest {
315    pub new_state: Option<StaIfaceCallbackState>,
316    pub bssid: Option<[u8; 6]>,
317    pub id: Option<u32>,
318    pub ssid: Option<Vec<u8>>,
319    #[doc(hidden)]
320    pub __source_breaking: fidl::marker::SourceBreaking,
321}
322
323impl fidl::Persistable for SupplicantStaIfaceCallbackOnStateChangedRequest {}
324
325#[derive(Clone, Debug, Default, PartialEq)]
326pub struct SupplicantStaIfaceGetMacAddressResponse {
327    pub mac_addr: Option<[u8; 6]>,
328    #[doc(hidden)]
329    pub __source_breaking: fidl::marker::SourceBreaking,
330}
331
332impl fidl::Persistable for SupplicantStaIfaceGetMacAddressResponse {}
333
334#[derive(Clone, Debug, Default, PartialEq)]
335pub struct SupplicantStaNetworkSetBssidRequest {
336    pub bssid: Option<[u8; 6]>,
337    #[doc(hidden)]
338    pub __source_breaking: fidl::marker::SourceBreaking,
339}
340
341impl fidl::Persistable for SupplicantStaNetworkSetBssidRequest {}
342
343#[derive(Clone, Debug, Default, PartialEq)]
344pub struct SupplicantStaNetworkSetPskPassphraseRequest {
345    pub passphrase: Option<Vec<u8>>,
346    #[doc(hidden)]
347    pub __source_breaking: fidl::marker::SourceBreaking,
348}
349
350impl fidl::Persistable for SupplicantStaNetworkSetPskPassphraseRequest {}
351
352#[derive(Clone, Debug, Default, PartialEq)]
353pub struct SupplicantStaNetworkSetSsidRequest {
354    pub ssid: Option<Vec<u8>>,
355    #[doc(hidden)]
356    pub __source_breaking: fidl::marker::SourceBreaking,
357}
358
359impl fidl::Persistable for SupplicantStaNetworkSetSsidRequest {}
360
361#[derive(Clone, Debug, Default, PartialEq)]
362pub struct WifiChipGetAvailableModesResponse {
363    pub chip_modes: Option<Vec<ChipMode>>,
364    #[doc(hidden)]
365    pub __source_breaking: fidl::marker::SourceBreaking,
366}
367
368impl fidl::Persistable for WifiChipGetAvailableModesResponse {}
369
370#[derive(Clone, Debug, Default, PartialEq)]
371pub struct WifiChipGetCapabilitiesResponse {
372    pub capabilities_mask: Option<u32>,
373    #[doc(hidden)]
374    pub __source_breaking: fidl::marker::SourceBreaking,
375}
376
377impl fidl::Persistable for WifiChipGetCapabilitiesResponse {}
378
379#[derive(Clone, Debug, Default, PartialEq)]
380pub struct WifiChipGetIdResponse {
381    pub id: Option<u32>,
382    #[doc(hidden)]
383    pub __source_breaking: fidl::marker::SourceBreaking,
384}
385
386impl fidl::Persistable for WifiChipGetIdResponse {}
387
388#[derive(Clone, Debug, Default, PartialEq)]
389pub struct WifiChipGetModeResponse {
390    pub mode: Option<u32>,
391    #[doc(hidden)]
392    pub __source_breaking: fidl::marker::SourceBreaking,
393}
394
395impl fidl::Persistable for WifiChipGetModeResponse {}
396
397#[derive(Clone, Debug, Default, PartialEq)]
398pub struct WifiChipGetStaIfaceNamesResponse {
399    pub iface_names: Option<Vec<String>>,
400    #[doc(hidden)]
401    pub __source_breaking: fidl::marker::SourceBreaking,
402}
403
404impl fidl::Persistable for WifiChipGetStaIfaceNamesResponse {}
405
406#[derive(Clone, Debug, Default, PartialEq)]
407pub struct WifiStaIfaceGetNameResponse {
408    pub iface_name: Option<String>,
409    #[doc(hidden)]
410    pub __source_breaking: fidl::marker::SourceBreaking,
411}
412
413impl fidl::Persistable for WifiStaIfaceGetNameResponse {}
414
415#[derive(Clone, Debug, Default, PartialEq)]
416pub struct WifiGetChipIdsResponse {
417    pub chip_ids: Option<Vec<u32>>,
418    #[doc(hidden)]
419    pub __source_breaking: fidl::marker::SourceBreaking,
420}
421
422impl fidl::Persistable for WifiGetChipIdsResponse {}
423
424#[derive(Clone, Debug, Default, PartialEq)]
425pub struct WifiGetStateResponse {
426    pub is_started: Option<bool>,
427    #[doc(hidden)]
428    pub __source_breaking: fidl::marker::SourceBreaking,
429}
430
431impl fidl::Persistable for WifiGetStateResponse {}
432
433mod internal {
434    use super::*;
435    unsafe impl fidl::encoding::TypeMarker for IfaceConcurrencyType {
436        type Owned = Self;
437
438        #[inline(always)]
439        fn inline_align(_context: fidl::encoding::Context) -> usize {
440            std::mem::align_of::<u32>()
441        }
442
443        #[inline(always)]
444        fn inline_size(_context: fidl::encoding::Context) -> usize {
445            std::mem::size_of::<u32>()
446        }
447
448        #[inline(always)]
449        fn encode_is_copy() -> bool {
450            false
451        }
452
453        #[inline(always)]
454        fn decode_is_copy() -> bool {
455            false
456        }
457    }
458
459    impl fidl::encoding::ValueTypeMarker for IfaceConcurrencyType {
460        type Borrowed<'a> = Self;
461        #[inline(always)]
462        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
463            *value
464        }
465    }
466
467    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
468        for IfaceConcurrencyType
469    {
470        #[inline]
471        unsafe fn encode(
472            self,
473            encoder: &mut fidl::encoding::Encoder<'_, D>,
474            offset: usize,
475            _depth: fidl::encoding::Depth,
476        ) -> fidl::Result<()> {
477            encoder.debug_check_bounds::<Self>(offset);
478            encoder.write_num(self.into_primitive(), offset);
479            Ok(())
480        }
481    }
482
483    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IfaceConcurrencyType {
484        #[inline(always)]
485        fn new_empty() -> Self {
486            Self::unknown()
487        }
488
489        #[inline]
490        unsafe fn decode(
491            &mut self,
492            decoder: &mut fidl::encoding::Decoder<'_, D>,
493            offset: usize,
494            _depth: fidl::encoding::Depth,
495        ) -> fidl::Result<()> {
496            decoder.debug_check_bounds::<Self>(offset);
497            let prim = decoder.read_num::<u32>(offset);
498
499            *self = Self::from_primitive_allow_unknown(prim);
500            Ok(())
501        }
502    }
503    unsafe impl fidl::encoding::TypeMarker for Nl80211MessageType {
504        type Owned = Self;
505
506        #[inline(always)]
507        fn inline_align(_context: fidl::encoding::Context) -> usize {
508            std::mem::align_of::<u32>()
509        }
510
511        #[inline(always)]
512        fn inline_size(_context: fidl::encoding::Context) -> usize {
513            std::mem::size_of::<u32>()
514        }
515
516        #[inline(always)]
517        fn encode_is_copy() -> bool {
518            false
519        }
520
521        #[inline(always)]
522        fn decode_is_copy() -> bool {
523            false
524        }
525    }
526
527    impl fidl::encoding::ValueTypeMarker for Nl80211MessageType {
528        type Borrowed<'a> = Self;
529        #[inline(always)]
530        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
531            *value
532        }
533    }
534
535    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
536        for Nl80211MessageType
537    {
538        #[inline]
539        unsafe fn encode(
540            self,
541            encoder: &mut fidl::encoding::Encoder<'_, D>,
542            offset: usize,
543            _depth: fidl::encoding::Depth,
544        ) -> fidl::Result<()> {
545            encoder.debug_check_bounds::<Self>(offset);
546            encoder.write_num(self.into_primitive(), offset);
547            Ok(())
548        }
549    }
550
551    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nl80211MessageType {
552        #[inline(always)]
553        fn new_empty() -> Self {
554            Self::unknown()
555        }
556
557        #[inline]
558        unsafe fn decode(
559            &mut self,
560            decoder: &mut fidl::encoding::Decoder<'_, D>,
561            offset: usize,
562            _depth: fidl::encoding::Depth,
563        ) -> fidl::Result<()> {
564            decoder.debug_check_bounds::<Self>(offset);
565            let prim = decoder.read_num::<u32>(offset);
566
567            *self = Self::from_primitive_allow_unknown(prim);
568            Ok(())
569        }
570    }
571    unsafe impl fidl::encoding::TypeMarker for StaIfaceCallbackState {
572        type Owned = Self;
573
574        #[inline(always)]
575        fn inline_align(_context: fidl::encoding::Context) -> usize {
576            std::mem::align_of::<u32>()
577        }
578
579        #[inline(always)]
580        fn inline_size(_context: fidl::encoding::Context) -> usize {
581            std::mem::size_of::<u32>()
582        }
583
584        #[inline(always)]
585        fn encode_is_copy() -> bool {
586            false
587        }
588
589        #[inline(always)]
590        fn decode_is_copy() -> bool {
591            false
592        }
593    }
594
595    impl fidl::encoding::ValueTypeMarker for StaIfaceCallbackState {
596        type Borrowed<'a> = Self;
597        #[inline(always)]
598        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
599            *value
600        }
601    }
602
603    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
604        for StaIfaceCallbackState
605    {
606        #[inline]
607        unsafe fn encode(
608            self,
609            encoder: &mut fidl::encoding::Encoder<'_, D>,
610            offset: usize,
611            _depth: fidl::encoding::Depth,
612        ) -> fidl::Result<()> {
613            encoder.debug_check_bounds::<Self>(offset);
614            encoder.write_num(self.into_primitive(), offset);
615            Ok(())
616        }
617    }
618
619    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StaIfaceCallbackState {
620        #[inline(always)]
621        fn new_empty() -> Self {
622            Self::unknown()
623        }
624
625        #[inline]
626        unsafe fn decode(
627            &mut self,
628            decoder: &mut fidl::encoding::Decoder<'_, D>,
629            offset: usize,
630            _depth: fidl::encoding::Depth,
631        ) -> fidl::Result<()> {
632            decoder.debug_check_bounds::<Self>(offset);
633            let prim = decoder.read_num::<u32>(offset);
634
635            *self = Self::from_primitive_allow_unknown(prim);
636            Ok(())
637        }
638    }
639
640    impl ChipConcurrencyCombination {
641        #[inline(always)]
642        fn max_ordinal_present(&self) -> u64 {
643            if let Some(_) = self.limits {
644                return 1;
645            }
646            0
647        }
648    }
649
650    impl fidl::encoding::ValueTypeMarker for ChipConcurrencyCombination {
651        type Borrowed<'a> = &'a Self;
652        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
653            value
654        }
655    }
656
657    unsafe impl fidl::encoding::TypeMarker for ChipConcurrencyCombination {
658        type Owned = Self;
659
660        #[inline(always)]
661        fn inline_align(_context: fidl::encoding::Context) -> usize {
662            8
663        }
664
665        #[inline(always)]
666        fn inline_size(_context: fidl::encoding::Context) -> usize {
667            16
668        }
669    }
670
671    unsafe impl<D: fidl::encoding::ResourceDialect>
672        fidl::encoding::Encode<ChipConcurrencyCombination, D> for &ChipConcurrencyCombination
673    {
674        unsafe fn encode(
675            self,
676            encoder: &mut fidl::encoding::Encoder<'_, D>,
677            offset: usize,
678            mut depth: fidl::encoding::Depth,
679        ) -> fidl::Result<()> {
680            encoder.debug_check_bounds::<ChipConcurrencyCombination>(offset);
681            // Vector header
682            let max_ordinal: u64 = self.max_ordinal_present();
683            encoder.write_num(max_ordinal, offset);
684            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
685            // Calling encoder.out_of_line_offset(0) is not allowed.
686            if max_ordinal == 0 {
687                return Ok(());
688            }
689            depth.increment()?;
690            let envelope_size = 8;
691            let bytes_len = max_ordinal as usize * envelope_size;
692            #[allow(unused_variables)]
693            let offset = encoder.out_of_line_offset(bytes_len);
694            let mut _prev_end_offset: usize = 0;
695            if 1 > max_ordinal {
696                return Ok(());
697            }
698
699            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
700            // are envelope_size bytes.
701            let cur_offset: usize = (1 - 1) * envelope_size;
702
703            // Zero reserved fields.
704            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
705
706            // Safety:
707            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
708            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
709            //   envelope_size bytes, there is always sufficient room.
710            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ChipConcurrencyCombinationLimit>, D>(
711            self.limits.as_ref().map(<fidl::encoding::UnboundedVector<ChipConcurrencyCombinationLimit> as fidl::encoding::ValueTypeMarker>::borrow),
712            encoder, offset + cur_offset, depth
713        )?;
714
715            _prev_end_offset = cur_offset + envelope_size;
716
717            Ok(())
718        }
719    }
720
721    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
722        for ChipConcurrencyCombination
723    {
724        #[inline(always)]
725        fn new_empty() -> Self {
726            Self::default()
727        }
728
729        unsafe fn decode(
730            &mut self,
731            decoder: &mut fidl::encoding::Decoder<'_, D>,
732            offset: usize,
733            mut depth: fidl::encoding::Depth,
734        ) -> fidl::Result<()> {
735            decoder.debug_check_bounds::<Self>(offset);
736            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
737                None => return Err(fidl::Error::NotNullable),
738                Some(len) => len,
739            };
740            // Calling decoder.out_of_line_offset(0) is not allowed.
741            if len == 0 {
742                return Ok(());
743            };
744            depth.increment()?;
745            let envelope_size = 8;
746            let bytes_len = len * envelope_size;
747            let offset = decoder.out_of_line_offset(bytes_len)?;
748            // Decode the envelope for each type.
749            let mut _next_ordinal_to_read = 0;
750            let mut next_offset = offset;
751            let end_offset = offset + bytes_len;
752            _next_ordinal_to_read += 1;
753            if next_offset >= end_offset {
754                return Ok(());
755            }
756
757            // Decode unknown envelopes for gaps in ordinals.
758            while _next_ordinal_to_read < 1 {
759                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
760                _next_ordinal_to_read += 1;
761                next_offset += envelope_size;
762            }
763
764            let next_out_of_line = decoder.next_out_of_line();
765            let handles_before = decoder.remaining_handles();
766            if let Some((inlined, num_bytes, num_handles)) =
767                fidl::encoding::decode_envelope_header(decoder, next_offset)?
768            {
769                let member_inline_size = <fidl::encoding::UnboundedVector<
770                    ChipConcurrencyCombinationLimit,
771                > as fidl::encoding::TypeMarker>::inline_size(
772                    decoder.context
773                );
774                if inlined != (member_inline_size <= 4) {
775                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
776                }
777                let inner_offset;
778                let mut inner_depth = depth.clone();
779                if inlined {
780                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
781                    inner_offset = next_offset;
782                } else {
783                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
784                    inner_depth.increment()?;
785                }
786                let val_ref = self.limits.get_or_insert_with(|| {
787                    fidl::new_empty!(
788                        fidl::encoding::UnboundedVector<ChipConcurrencyCombinationLimit>,
789                        D
790                    )
791                });
792                fidl::decode!(
793                    fidl::encoding::UnboundedVector<ChipConcurrencyCombinationLimit>,
794                    D,
795                    val_ref,
796                    decoder,
797                    inner_offset,
798                    inner_depth
799                )?;
800                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
801                {
802                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
803                }
804                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
805                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
806                }
807            }
808
809            next_offset += envelope_size;
810
811            // Decode the remaining unknown envelopes.
812            while next_offset < end_offset {
813                _next_ordinal_to_read += 1;
814                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
815                next_offset += envelope_size;
816            }
817
818            Ok(())
819        }
820    }
821
822    impl ChipConcurrencyCombinationLimit {
823        #[inline(always)]
824        fn max_ordinal_present(&self) -> u64 {
825            if let Some(_) = self.max_ifaces {
826                return 2;
827            }
828            if let Some(_) = self.types {
829                return 1;
830            }
831            0
832        }
833    }
834
835    impl fidl::encoding::ValueTypeMarker for ChipConcurrencyCombinationLimit {
836        type Borrowed<'a> = &'a Self;
837        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
838            value
839        }
840    }
841
842    unsafe impl fidl::encoding::TypeMarker for ChipConcurrencyCombinationLimit {
843        type Owned = Self;
844
845        #[inline(always)]
846        fn inline_align(_context: fidl::encoding::Context) -> usize {
847            8
848        }
849
850        #[inline(always)]
851        fn inline_size(_context: fidl::encoding::Context) -> usize {
852            16
853        }
854    }
855
856    unsafe impl<D: fidl::encoding::ResourceDialect>
857        fidl::encoding::Encode<ChipConcurrencyCombinationLimit, D>
858        for &ChipConcurrencyCombinationLimit
859    {
860        unsafe fn encode(
861            self,
862            encoder: &mut fidl::encoding::Encoder<'_, D>,
863            offset: usize,
864            mut depth: fidl::encoding::Depth,
865        ) -> fidl::Result<()> {
866            encoder.debug_check_bounds::<ChipConcurrencyCombinationLimit>(offset);
867            // Vector header
868            let max_ordinal: u64 = self.max_ordinal_present();
869            encoder.write_num(max_ordinal, offset);
870            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
871            // Calling encoder.out_of_line_offset(0) is not allowed.
872            if max_ordinal == 0 {
873                return Ok(());
874            }
875            depth.increment()?;
876            let envelope_size = 8;
877            let bytes_len = max_ordinal as usize * envelope_size;
878            #[allow(unused_variables)]
879            let offset = encoder.out_of_line_offset(bytes_len);
880            let mut _prev_end_offset: usize = 0;
881            if 1 > max_ordinal {
882                return Ok(());
883            }
884
885            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
886            // are envelope_size bytes.
887            let cur_offset: usize = (1 - 1) * envelope_size;
888
889            // Zero reserved fields.
890            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
891
892            // Safety:
893            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
894            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
895            //   envelope_size bytes, there is always sufficient room.
896            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<IfaceConcurrencyType>, D>(
897            self.types.as_ref().map(<fidl::encoding::UnboundedVector<IfaceConcurrencyType> as fidl::encoding::ValueTypeMarker>::borrow),
898            encoder, offset + cur_offset, depth
899        )?;
900
901            _prev_end_offset = cur_offset + envelope_size;
902            if 2 > max_ordinal {
903                return Ok(());
904            }
905
906            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
907            // are envelope_size bytes.
908            let cur_offset: usize = (2 - 1) * envelope_size;
909
910            // Zero reserved fields.
911            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
912
913            // Safety:
914            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
915            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
916            //   envelope_size bytes, there is always sufficient room.
917            fidl::encoding::encode_in_envelope_optional::<u32, D>(
918                self.max_ifaces.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
919                encoder,
920                offset + cur_offset,
921                depth,
922            )?;
923
924            _prev_end_offset = cur_offset + envelope_size;
925
926            Ok(())
927        }
928    }
929
930    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
931        for ChipConcurrencyCombinationLimit
932    {
933        #[inline(always)]
934        fn new_empty() -> Self {
935            Self::default()
936        }
937
938        unsafe fn decode(
939            &mut self,
940            decoder: &mut fidl::encoding::Decoder<'_, D>,
941            offset: usize,
942            mut depth: fidl::encoding::Depth,
943        ) -> fidl::Result<()> {
944            decoder.debug_check_bounds::<Self>(offset);
945            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
946                None => return Err(fidl::Error::NotNullable),
947                Some(len) => len,
948            };
949            // Calling decoder.out_of_line_offset(0) is not allowed.
950            if len == 0 {
951                return Ok(());
952            };
953            depth.increment()?;
954            let envelope_size = 8;
955            let bytes_len = len * envelope_size;
956            let offset = decoder.out_of_line_offset(bytes_len)?;
957            // Decode the envelope for each type.
958            let mut _next_ordinal_to_read = 0;
959            let mut next_offset = offset;
960            let end_offset = offset + bytes_len;
961            _next_ordinal_to_read += 1;
962            if next_offset >= end_offset {
963                return Ok(());
964            }
965
966            // Decode unknown envelopes for gaps in ordinals.
967            while _next_ordinal_to_read < 1 {
968                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
969                _next_ordinal_to_read += 1;
970                next_offset += envelope_size;
971            }
972
973            let next_out_of_line = decoder.next_out_of_line();
974            let handles_before = decoder.remaining_handles();
975            if let Some((inlined, num_bytes, num_handles)) =
976                fidl::encoding::decode_envelope_header(decoder, next_offset)?
977            {
978                let member_inline_size = <fidl::encoding::UnboundedVector<IfaceConcurrencyType> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
979                if inlined != (member_inline_size <= 4) {
980                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
981                }
982                let inner_offset;
983                let mut inner_depth = depth.clone();
984                if inlined {
985                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
986                    inner_offset = next_offset;
987                } else {
988                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
989                    inner_depth.increment()?;
990                }
991                let val_ref = self.types.get_or_insert_with(|| {
992                    fidl::new_empty!(fidl::encoding::UnboundedVector<IfaceConcurrencyType>, D)
993                });
994                fidl::decode!(
995                    fidl::encoding::UnboundedVector<IfaceConcurrencyType>,
996                    D,
997                    val_ref,
998                    decoder,
999                    inner_offset,
1000                    inner_depth
1001                )?;
1002                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1003                {
1004                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1005                }
1006                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1007                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1008                }
1009            }
1010
1011            next_offset += envelope_size;
1012            _next_ordinal_to_read += 1;
1013            if next_offset >= end_offset {
1014                return Ok(());
1015            }
1016
1017            // Decode unknown envelopes for gaps in ordinals.
1018            while _next_ordinal_to_read < 2 {
1019                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1020                _next_ordinal_to_read += 1;
1021                next_offset += envelope_size;
1022            }
1023
1024            let next_out_of_line = decoder.next_out_of_line();
1025            let handles_before = decoder.remaining_handles();
1026            if let Some((inlined, num_bytes, num_handles)) =
1027                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1028            {
1029                let member_inline_size =
1030                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1031                if inlined != (member_inline_size <= 4) {
1032                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1033                }
1034                let inner_offset;
1035                let mut inner_depth = depth.clone();
1036                if inlined {
1037                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1038                    inner_offset = next_offset;
1039                } else {
1040                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1041                    inner_depth.increment()?;
1042                }
1043                let val_ref = self.max_ifaces.get_or_insert_with(|| fidl::new_empty!(u32, D));
1044                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1045                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1046                {
1047                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1048                }
1049                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1050                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1051                }
1052            }
1053
1054            next_offset += envelope_size;
1055
1056            // Decode the remaining unknown envelopes.
1057            while next_offset < end_offset {
1058                _next_ordinal_to_read += 1;
1059                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1060                next_offset += envelope_size;
1061            }
1062
1063            Ok(())
1064        }
1065    }
1066
1067    impl ChipMode {
1068        #[inline(always)]
1069        fn max_ordinal_present(&self) -> u64 {
1070            if let Some(_) = self.available_combinations {
1071                return 2;
1072            }
1073            if let Some(_) = self.id {
1074                return 1;
1075            }
1076            0
1077        }
1078    }
1079
1080    impl fidl::encoding::ValueTypeMarker for ChipMode {
1081        type Borrowed<'a> = &'a Self;
1082        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1083            value
1084        }
1085    }
1086
1087    unsafe impl fidl::encoding::TypeMarker for ChipMode {
1088        type Owned = Self;
1089
1090        #[inline(always)]
1091        fn inline_align(_context: fidl::encoding::Context) -> usize {
1092            8
1093        }
1094
1095        #[inline(always)]
1096        fn inline_size(_context: fidl::encoding::Context) -> usize {
1097            16
1098        }
1099    }
1100
1101    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChipMode, D> for &ChipMode {
1102        unsafe fn encode(
1103            self,
1104            encoder: &mut fidl::encoding::Encoder<'_, D>,
1105            offset: usize,
1106            mut depth: fidl::encoding::Depth,
1107        ) -> fidl::Result<()> {
1108            encoder.debug_check_bounds::<ChipMode>(offset);
1109            // Vector header
1110            let max_ordinal: u64 = self.max_ordinal_present();
1111            encoder.write_num(max_ordinal, offset);
1112            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1113            // Calling encoder.out_of_line_offset(0) is not allowed.
1114            if max_ordinal == 0 {
1115                return Ok(());
1116            }
1117            depth.increment()?;
1118            let envelope_size = 8;
1119            let bytes_len = max_ordinal as usize * envelope_size;
1120            #[allow(unused_variables)]
1121            let offset = encoder.out_of_line_offset(bytes_len);
1122            let mut _prev_end_offset: usize = 0;
1123            if 1 > max_ordinal {
1124                return Ok(());
1125            }
1126
1127            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1128            // are envelope_size bytes.
1129            let cur_offset: usize = (1 - 1) * envelope_size;
1130
1131            // Zero reserved fields.
1132            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1133
1134            // Safety:
1135            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1136            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1137            //   envelope_size bytes, there is always sufficient room.
1138            fidl::encoding::encode_in_envelope_optional::<u32, D>(
1139                self.id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1140                encoder,
1141                offset + cur_offset,
1142                depth,
1143            )?;
1144
1145            _prev_end_offset = cur_offset + envelope_size;
1146            if 2 > max_ordinal {
1147                return Ok(());
1148            }
1149
1150            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1151            // are envelope_size bytes.
1152            let cur_offset: usize = (2 - 1) * envelope_size;
1153
1154            // Zero reserved fields.
1155            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1156
1157            // Safety:
1158            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1159            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1160            //   envelope_size bytes, there is always sufficient room.
1161            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ChipConcurrencyCombination>, D>(
1162            self.available_combinations.as_ref().map(<fidl::encoding::UnboundedVector<ChipConcurrencyCombination> as fidl::encoding::ValueTypeMarker>::borrow),
1163            encoder, offset + cur_offset, depth
1164        )?;
1165
1166            _prev_end_offset = cur_offset + envelope_size;
1167
1168            Ok(())
1169        }
1170    }
1171
1172    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChipMode {
1173        #[inline(always)]
1174        fn new_empty() -> Self {
1175            Self::default()
1176        }
1177
1178        unsafe fn decode(
1179            &mut self,
1180            decoder: &mut fidl::encoding::Decoder<'_, D>,
1181            offset: usize,
1182            mut depth: fidl::encoding::Depth,
1183        ) -> fidl::Result<()> {
1184            decoder.debug_check_bounds::<Self>(offset);
1185            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1186                None => return Err(fidl::Error::NotNullable),
1187                Some(len) => len,
1188            };
1189            // Calling decoder.out_of_line_offset(0) is not allowed.
1190            if len == 0 {
1191                return Ok(());
1192            };
1193            depth.increment()?;
1194            let envelope_size = 8;
1195            let bytes_len = len * envelope_size;
1196            let offset = decoder.out_of_line_offset(bytes_len)?;
1197            // Decode the envelope for each type.
1198            let mut _next_ordinal_to_read = 0;
1199            let mut next_offset = offset;
1200            let end_offset = offset + bytes_len;
1201            _next_ordinal_to_read += 1;
1202            if next_offset >= end_offset {
1203                return Ok(());
1204            }
1205
1206            // Decode unknown envelopes for gaps in ordinals.
1207            while _next_ordinal_to_read < 1 {
1208                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1209                _next_ordinal_to_read += 1;
1210                next_offset += envelope_size;
1211            }
1212
1213            let next_out_of_line = decoder.next_out_of_line();
1214            let handles_before = decoder.remaining_handles();
1215            if let Some((inlined, num_bytes, num_handles)) =
1216                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1217            {
1218                let member_inline_size =
1219                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1220                if inlined != (member_inline_size <= 4) {
1221                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1222                }
1223                let inner_offset;
1224                let mut inner_depth = depth.clone();
1225                if inlined {
1226                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1227                    inner_offset = next_offset;
1228                } else {
1229                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1230                    inner_depth.increment()?;
1231                }
1232                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u32, D));
1233                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1234                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1235                {
1236                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1237                }
1238                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1239                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1240                }
1241            }
1242
1243            next_offset += envelope_size;
1244            _next_ordinal_to_read += 1;
1245            if next_offset >= end_offset {
1246                return Ok(());
1247            }
1248
1249            // Decode unknown envelopes for gaps in ordinals.
1250            while _next_ordinal_to_read < 2 {
1251                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1252                _next_ordinal_to_read += 1;
1253                next_offset += envelope_size;
1254            }
1255
1256            let next_out_of_line = decoder.next_out_of_line();
1257            let handles_before = decoder.remaining_handles();
1258            if let Some((inlined, num_bytes, num_handles)) =
1259                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1260            {
1261                let member_inline_size = <fidl::encoding::UnboundedVector<
1262                    ChipConcurrencyCombination,
1263                > as fidl::encoding::TypeMarker>::inline_size(
1264                    decoder.context
1265                );
1266                if inlined != (member_inline_size <= 4) {
1267                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1268                }
1269                let inner_offset;
1270                let mut inner_depth = depth.clone();
1271                if inlined {
1272                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1273                    inner_offset = next_offset;
1274                } else {
1275                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1276                    inner_depth.increment()?;
1277                }
1278                let val_ref = self.available_combinations.get_or_insert_with(|| {
1279                    fidl::new_empty!(fidl::encoding::UnboundedVector<ChipConcurrencyCombination>, D)
1280                });
1281                fidl::decode!(
1282                    fidl::encoding::UnboundedVector<ChipConcurrencyCombination>,
1283                    D,
1284                    val_ref,
1285                    decoder,
1286                    inner_offset,
1287                    inner_depth
1288                )?;
1289                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1290                {
1291                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1292                }
1293                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1294                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1295                }
1296            }
1297
1298            next_offset += envelope_size;
1299
1300            // Decode the remaining unknown envelopes.
1301            while next_offset < end_offset {
1302                _next_ordinal_to_read += 1;
1303                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1304                next_offset += envelope_size;
1305            }
1306
1307            Ok(())
1308        }
1309    }
1310
1311    impl Nl80211Message {
1312        #[inline(always)]
1313        fn max_ordinal_present(&self) -> u64 {
1314            if let Some(_) = self.payload {
1315                return 2;
1316            }
1317            if let Some(_) = self.message_type {
1318                return 1;
1319            }
1320            0
1321        }
1322    }
1323
1324    impl fidl::encoding::ValueTypeMarker for Nl80211Message {
1325        type Borrowed<'a> = &'a Self;
1326        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1327            value
1328        }
1329    }
1330
1331    unsafe impl fidl::encoding::TypeMarker for Nl80211Message {
1332        type Owned = Self;
1333
1334        #[inline(always)]
1335        fn inline_align(_context: fidl::encoding::Context) -> usize {
1336            8
1337        }
1338
1339        #[inline(always)]
1340        fn inline_size(_context: fidl::encoding::Context) -> usize {
1341            16
1342        }
1343    }
1344
1345    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nl80211Message, D>
1346        for &Nl80211Message
1347    {
1348        unsafe fn encode(
1349            self,
1350            encoder: &mut fidl::encoding::Encoder<'_, D>,
1351            offset: usize,
1352            mut depth: fidl::encoding::Depth,
1353        ) -> fidl::Result<()> {
1354            encoder.debug_check_bounds::<Nl80211Message>(offset);
1355            // Vector header
1356            let max_ordinal: u64 = self.max_ordinal_present();
1357            encoder.write_num(max_ordinal, offset);
1358            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1359            // Calling encoder.out_of_line_offset(0) is not allowed.
1360            if max_ordinal == 0 {
1361                return Ok(());
1362            }
1363            depth.increment()?;
1364            let envelope_size = 8;
1365            let bytes_len = max_ordinal as usize * envelope_size;
1366            #[allow(unused_variables)]
1367            let offset = encoder.out_of_line_offset(bytes_len);
1368            let mut _prev_end_offset: usize = 0;
1369            if 1 > max_ordinal {
1370                return Ok(());
1371            }
1372
1373            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1374            // are envelope_size bytes.
1375            let cur_offset: usize = (1 - 1) * envelope_size;
1376
1377            // Zero reserved fields.
1378            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1379
1380            // Safety:
1381            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1382            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1383            //   envelope_size bytes, there is always sufficient room.
1384            fidl::encoding::encode_in_envelope_optional::<Nl80211MessageType, D>(
1385                self.message_type
1386                    .as_ref()
1387                    .map(<Nl80211MessageType as fidl::encoding::ValueTypeMarker>::borrow),
1388                encoder,
1389                offset + cur_offset,
1390                depth,
1391            )?;
1392
1393            _prev_end_offset = cur_offset + envelope_size;
1394            if 2 > max_ordinal {
1395                return Ok(());
1396            }
1397
1398            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1399            // are envelope_size bytes.
1400            let cur_offset: usize = (2 - 1) * envelope_size;
1401
1402            // Zero reserved fields.
1403            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1404
1405            // Safety:
1406            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1407            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1408            //   envelope_size bytes, there is always sufficient room.
1409            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
1410            self.payload.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
1411            encoder, offset + cur_offset, depth
1412        )?;
1413
1414            _prev_end_offset = cur_offset + envelope_size;
1415
1416            Ok(())
1417        }
1418    }
1419
1420    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nl80211Message {
1421        #[inline(always)]
1422        fn new_empty() -> Self {
1423            Self::default()
1424        }
1425
1426        unsafe fn decode(
1427            &mut self,
1428            decoder: &mut fidl::encoding::Decoder<'_, D>,
1429            offset: usize,
1430            mut depth: fidl::encoding::Depth,
1431        ) -> fidl::Result<()> {
1432            decoder.debug_check_bounds::<Self>(offset);
1433            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1434                None => return Err(fidl::Error::NotNullable),
1435                Some(len) => len,
1436            };
1437            // Calling decoder.out_of_line_offset(0) is not allowed.
1438            if len == 0 {
1439                return Ok(());
1440            };
1441            depth.increment()?;
1442            let envelope_size = 8;
1443            let bytes_len = len * envelope_size;
1444            let offset = decoder.out_of_line_offset(bytes_len)?;
1445            // Decode the envelope for each type.
1446            let mut _next_ordinal_to_read = 0;
1447            let mut next_offset = offset;
1448            let end_offset = offset + bytes_len;
1449            _next_ordinal_to_read += 1;
1450            if next_offset >= end_offset {
1451                return Ok(());
1452            }
1453
1454            // Decode unknown envelopes for gaps in ordinals.
1455            while _next_ordinal_to_read < 1 {
1456                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1457                _next_ordinal_to_read += 1;
1458                next_offset += envelope_size;
1459            }
1460
1461            let next_out_of_line = decoder.next_out_of_line();
1462            let handles_before = decoder.remaining_handles();
1463            if let Some((inlined, num_bytes, num_handles)) =
1464                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1465            {
1466                let member_inline_size =
1467                    <Nl80211MessageType as fidl::encoding::TypeMarker>::inline_size(
1468                        decoder.context,
1469                    );
1470                if inlined != (member_inline_size <= 4) {
1471                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1472                }
1473                let inner_offset;
1474                let mut inner_depth = depth.clone();
1475                if inlined {
1476                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1477                    inner_offset = next_offset;
1478                } else {
1479                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1480                    inner_depth.increment()?;
1481                }
1482                let val_ref = self
1483                    .message_type
1484                    .get_or_insert_with(|| fidl::new_empty!(Nl80211MessageType, D));
1485                fidl::decode!(Nl80211MessageType, D, val_ref, decoder, inner_offset, inner_depth)?;
1486                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1487                {
1488                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1489                }
1490                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1491                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1492                }
1493            }
1494
1495            next_offset += envelope_size;
1496            _next_ordinal_to_read += 1;
1497            if next_offset >= end_offset {
1498                return Ok(());
1499            }
1500
1501            // Decode unknown envelopes for gaps in ordinals.
1502            while _next_ordinal_to_read < 2 {
1503                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1504                _next_ordinal_to_read += 1;
1505                next_offset += envelope_size;
1506            }
1507
1508            let next_out_of_line = decoder.next_out_of_line();
1509            let handles_before = decoder.remaining_handles();
1510            if let Some((inlined, num_bytes, num_handles)) =
1511                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1512            {
1513                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1514                if inlined != (member_inline_size <= 4) {
1515                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1516                }
1517                let inner_offset;
1518                let mut inner_depth = depth.clone();
1519                if inlined {
1520                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1521                    inner_offset = next_offset;
1522                } else {
1523                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1524                    inner_depth.increment()?;
1525                }
1526                let val_ref = self.payload.get_or_insert_with(|| {
1527                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
1528                });
1529                fidl::decode!(
1530                    fidl::encoding::UnboundedVector<u8>,
1531                    D,
1532                    val_ref,
1533                    decoder,
1534                    inner_offset,
1535                    inner_depth
1536                )?;
1537                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1538                {
1539                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1540                }
1541                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1542                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1543                }
1544            }
1545
1546            next_offset += envelope_size;
1547
1548            // Decode the remaining unknown envelopes.
1549            while next_offset < end_offset {
1550                _next_ordinal_to_read += 1;
1551                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1552                next_offset += envelope_size;
1553            }
1554
1555            Ok(())
1556        }
1557    }
1558
1559    impl SupplicantStaIfaceCallbackOnAssociationRejectedRequest {
1560        #[inline(always)]
1561        fn max_ordinal_present(&self) -> u64 {
1562            if let Some(_) = self.timed_out {
1563                return 4;
1564            }
1565            if let Some(_) = self.status_code {
1566                return 3;
1567            }
1568            if let Some(_) = self.bssid {
1569                return 2;
1570            }
1571            if let Some(_) = self.ssid {
1572                return 1;
1573            }
1574            0
1575        }
1576    }
1577
1578    impl fidl::encoding::ValueTypeMarker for SupplicantStaIfaceCallbackOnAssociationRejectedRequest {
1579        type Borrowed<'a> = &'a Self;
1580        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1581            value
1582        }
1583    }
1584
1585    unsafe impl fidl::encoding::TypeMarker for SupplicantStaIfaceCallbackOnAssociationRejectedRequest {
1586        type Owned = Self;
1587
1588        #[inline(always)]
1589        fn inline_align(_context: fidl::encoding::Context) -> usize {
1590            8
1591        }
1592
1593        #[inline(always)]
1594        fn inline_size(_context: fidl::encoding::Context) -> usize {
1595            16
1596        }
1597    }
1598
1599    unsafe impl<D: fidl::encoding::ResourceDialect>
1600        fidl::encoding::Encode<SupplicantStaIfaceCallbackOnAssociationRejectedRequest, D>
1601        for &SupplicantStaIfaceCallbackOnAssociationRejectedRequest
1602    {
1603        unsafe fn encode(
1604            self,
1605            encoder: &mut fidl::encoding::Encoder<'_, D>,
1606            offset: usize,
1607            mut depth: fidl::encoding::Depth,
1608        ) -> fidl::Result<()> {
1609            encoder.debug_check_bounds::<SupplicantStaIfaceCallbackOnAssociationRejectedRequest>(
1610                offset,
1611            );
1612            // Vector header
1613            let max_ordinal: u64 = self.max_ordinal_present();
1614            encoder.write_num(max_ordinal, offset);
1615            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1616            // Calling encoder.out_of_line_offset(0) is not allowed.
1617            if max_ordinal == 0 {
1618                return Ok(());
1619            }
1620            depth.increment()?;
1621            let envelope_size = 8;
1622            let bytes_len = max_ordinal as usize * envelope_size;
1623            #[allow(unused_variables)]
1624            let offset = encoder.out_of_line_offset(bytes_len);
1625            let mut _prev_end_offset: usize = 0;
1626            if 1 > max_ordinal {
1627                return Ok(());
1628            }
1629
1630            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1631            // are envelope_size bytes.
1632            let cur_offset: usize = (1 - 1) * envelope_size;
1633
1634            // Zero reserved fields.
1635            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1636
1637            // Safety:
1638            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1639            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1640            //   envelope_size bytes, there is always sufficient room.
1641            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
1642                self.ssid.as_ref().map(
1643                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
1644                ),
1645                encoder,
1646                offset + cur_offset,
1647                depth,
1648            )?;
1649
1650            _prev_end_offset = cur_offset + envelope_size;
1651            if 2 > max_ordinal {
1652                return Ok(());
1653            }
1654
1655            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1656            // are envelope_size bytes.
1657            let cur_offset: usize = (2 - 1) * envelope_size;
1658
1659            // Zero reserved fields.
1660            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1661
1662            // Safety:
1663            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1664            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1665            //   envelope_size bytes, there is always sufficient room.
1666            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
1667                self.bssid
1668                    .as_ref()
1669                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
1670                encoder,
1671                offset + cur_offset,
1672                depth,
1673            )?;
1674
1675            _prev_end_offset = cur_offset + envelope_size;
1676            if 3 > max_ordinal {
1677                return Ok(());
1678            }
1679
1680            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1681            // are envelope_size bytes.
1682            let cur_offset: usize = (3 - 1) * envelope_size;
1683
1684            // Zero reserved fields.
1685            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1686
1687            // Safety:
1688            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1689            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1690            //   envelope_size bytes, there is always sufficient room.
1691            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
1692            self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
1693            encoder, offset + cur_offset, depth
1694        )?;
1695
1696            _prev_end_offset = cur_offset + envelope_size;
1697            if 4 > max_ordinal {
1698                return Ok(());
1699            }
1700
1701            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1702            // are envelope_size bytes.
1703            let cur_offset: usize = (4 - 1) * envelope_size;
1704
1705            // Zero reserved fields.
1706            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1707
1708            // Safety:
1709            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1710            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1711            //   envelope_size bytes, there is always sufficient room.
1712            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1713                self.timed_out.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1714                encoder,
1715                offset + cur_offset,
1716                depth,
1717            )?;
1718
1719            _prev_end_offset = cur_offset + envelope_size;
1720
1721            Ok(())
1722        }
1723    }
1724
1725    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1726        for SupplicantStaIfaceCallbackOnAssociationRejectedRequest
1727    {
1728        #[inline(always)]
1729        fn new_empty() -> Self {
1730            Self::default()
1731        }
1732
1733        unsafe fn decode(
1734            &mut self,
1735            decoder: &mut fidl::encoding::Decoder<'_, D>,
1736            offset: usize,
1737            mut depth: fidl::encoding::Depth,
1738        ) -> fidl::Result<()> {
1739            decoder.debug_check_bounds::<Self>(offset);
1740            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1741                None => return Err(fidl::Error::NotNullable),
1742                Some(len) => len,
1743            };
1744            // Calling decoder.out_of_line_offset(0) is not allowed.
1745            if len == 0 {
1746                return Ok(());
1747            };
1748            depth.increment()?;
1749            let envelope_size = 8;
1750            let bytes_len = len * envelope_size;
1751            let offset = decoder.out_of_line_offset(bytes_len)?;
1752            // Decode the envelope for each type.
1753            let mut _next_ordinal_to_read = 0;
1754            let mut next_offset = offset;
1755            let end_offset = offset + bytes_len;
1756            _next_ordinal_to_read += 1;
1757            if next_offset >= end_offset {
1758                return Ok(());
1759            }
1760
1761            // Decode unknown envelopes for gaps in ordinals.
1762            while _next_ordinal_to_read < 1 {
1763                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1764                _next_ordinal_to_read += 1;
1765                next_offset += envelope_size;
1766            }
1767
1768            let next_out_of_line = decoder.next_out_of_line();
1769            let handles_before = decoder.remaining_handles();
1770            if let Some((inlined, num_bytes, num_handles)) =
1771                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1772            {
1773                let member_inline_size =
1774                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
1775                        decoder.context,
1776                    );
1777                if inlined != (member_inline_size <= 4) {
1778                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1779                }
1780                let inner_offset;
1781                let mut inner_depth = depth.clone();
1782                if inlined {
1783                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1784                    inner_offset = next_offset;
1785                } else {
1786                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1787                    inner_depth.increment()?;
1788                }
1789                let val_ref = self
1790                    .ssid
1791                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
1792                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
1793                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1794                {
1795                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1796                }
1797                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1798                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1799                }
1800            }
1801
1802            next_offset += envelope_size;
1803            _next_ordinal_to_read += 1;
1804            if next_offset >= end_offset {
1805                return Ok(());
1806            }
1807
1808            // Decode unknown envelopes for gaps in ordinals.
1809            while _next_ordinal_to_read < 2 {
1810                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1811                _next_ordinal_to_read += 1;
1812                next_offset += envelope_size;
1813            }
1814
1815            let next_out_of_line = decoder.next_out_of_line();
1816            let handles_before = decoder.remaining_handles();
1817            if let Some((inlined, num_bytes, num_handles)) =
1818                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1819            {
1820                let member_inline_size =
1821                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
1822                        decoder.context,
1823                    );
1824                if inlined != (member_inline_size <= 4) {
1825                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1826                }
1827                let inner_offset;
1828                let mut inner_depth = depth.clone();
1829                if inlined {
1830                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1831                    inner_offset = next_offset;
1832                } else {
1833                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1834                    inner_depth.increment()?;
1835                }
1836                let val_ref = self
1837                    .bssid
1838                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
1839                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
1840                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1841                {
1842                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1843                }
1844                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1845                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1846                }
1847            }
1848
1849            next_offset += envelope_size;
1850            _next_ordinal_to_read += 1;
1851            if next_offset >= end_offset {
1852                return Ok(());
1853            }
1854
1855            // Decode unknown envelopes for gaps in ordinals.
1856            while _next_ordinal_to_read < 3 {
1857                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1858                _next_ordinal_to_read += 1;
1859                next_offset += envelope_size;
1860            }
1861
1862            let next_out_of_line = decoder.next_out_of_line();
1863            let handles_before = decoder.remaining_handles();
1864            if let Some((inlined, num_bytes, num_handles)) =
1865                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1866            {
1867                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1868                if inlined != (member_inline_size <= 4) {
1869                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1870                }
1871                let inner_offset;
1872                let mut inner_depth = depth.clone();
1873                if inlined {
1874                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1875                    inner_offset = next_offset;
1876                } else {
1877                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1878                    inner_depth.increment()?;
1879                }
1880                let val_ref = self.status_code.get_or_insert_with(|| {
1881                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
1882                });
1883                fidl::decode!(
1884                    fidl_fuchsia_wlan_ieee80211__common::StatusCode,
1885                    D,
1886                    val_ref,
1887                    decoder,
1888                    inner_offset,
1889                    inner_depth
1890                )?;
1891                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1892                {
1893                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1894                }
1895                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1896                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1897                }
1898            }
1899
1900            next_offset += envelope_size;
1901            _next_ordinal_to_read += 1;
1902            if next_offset >= end_offset {
1903                return Ok(());
1904            }
1905
1906            // Decode unknown envelopes for gaps in ordinals.
1907            while _next_ordinal_to_read < 4 {
1908                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1909                _next_ordinal_to_read += 1;
1910                next_offset += envelope_size;
1911            }
1912
1913            let next_out_of_line = decoder.next_out_of_line();
1914            let handles_before = decoder.remaining_handles();
1915            if let Some((inlined, num_bytes, num_handles)) =
1916                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1917            {
1918                let member_inline_size =
1919                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1920                if inlined != (member_inline_size <= 4) {
1921                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1922                }
1923                let inner_offset;
1924                let mut inner_depth = depth.clone();
1925                if inlined {
1926                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1927                    inner_offset = next_offset;
1928                } else {
1929                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1930                    inner_depth.increment()?;
1931                }
1932                let val_ref = self.timed_out.get_or_insert_with(|| fidl::new_empty!(bool, D));
1933                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1934                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1935                {
1936                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1937                }
1938                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1939                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1940                }
1941            }
1942
1943            next_offset += envelope_size;
1944
1945            // Decode the remaining unknown envelopes.
1946            while next_offset < end_offset {
1947                _next_ordinal_to_read += 1;
1948                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1949                next_offset += envelope_size;
1950            }
1951
1952            Ok(())
1953        }
1954    }
1955
1956    impl SupplicantStaIfaceCallbackOnDisconnectedRequest {
1957        #[inline(always)]
1958        fn max_ordinal_present(&self) -> u64 {
1959            if let Some(_) = self.reason_code {
1960                return 3;
1961            }
1962            if let Some(_) = self.locally_generated {
1963                return 2;
1964            }
1965            if let Some(_) = self.bssid {
1966                return 1;
1967            }
1968            0
1969        }
1970    }
1971
1972    impl fidl::encoding::ValueTypeMarker for SupplicantStaIfaceCallbackOnDisconnectedRequest {
1973        type Borrowed<'a> = &'a Self;
1974        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1975            value
1976        }
1977    }
1978
1979    unsafe impl fidl::encoding::TypeMarker for SupplicantStaIfaceCallbackOnDisconnectedRequest {
1980        type Owned = Self;
1981
1982        #[inline(always)]
1983        fn inline_align(_context: fidl::encoding::Context) -> usize {
1984            8
1985        }
1986
1987        #[inline(always)]
1988        fn inline_size(_context: fidl::encoding::Context) -> usize {
1989            16
1990        }
1991    }
1992
1993    unsafe impl<D: fidl::encoding::ResourceDialect>
1994        fidl::encoding::Encode<SupplicantStaIfaceCallbackOnDisconnectedRequest, D>
1995        for &SupplicantStaIfaceCallbackOnDisconnectedRequest
1996    {
1997        unsafe fn encode(
1998            self,
1999            encoder: &mut fidl::encoding::Encoder<'_, D>,
2000            offset: usize,
2001            mut depth: fidl::encoding::Depth,
2002        ) -> fidl::Result<()> {
2003            encoder.debug_check_bounds::<SupplicantStaIfaceCallbackOnDisconnectedRequest>(offset);
2004            // Vector header
2005            let max_ordinal: u64 = self.max_ordinal_present();
2006            encoder.write_num(max_ordinal, offset);
2007            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2008            // Calling encoder.out_of_line_offset(0) is not allowed.
2009            if max_ordinal == 0 {
2010                return Ok(());
2011            }
2012            depth.increment()?;
2013            let envelope_size = 8;
2014            let bytes_len = max_ordinal as usize * envelope_size;
2015            #[allow(unused_variables)]
2016            let offset = encoder.out_of_line_offset(bytes_len);
2017            let mut _prev_end_offset: usize = 0;
2018            if 1 > max_ordinal {
2019                return Ok(());
2020            }
2021
2022            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2023            // are envelope_size bytes.
2024            let cur_offset: usize = (1 - 1) * envelope_size;
2025
2026            // Zero reserved fields.
2027            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2028
2029            // Safety:
2030            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2031            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2032            //   envelope_size bytes, there is always sufficient room.
2033            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
2034                self.bssid
2035                    .as_ref()
2036                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
2037                encoder,
2038                offset + cur_offset,
2039                depth,
2040            )?;
2041
2042            _prev_end_offset = cur_offset + envelope_size;
2043            if 2 > max_ordinal {
2044                return Ok(());
2045            }
2046
2047            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2048            // are envelope_size bytes.
2049            let cur_offset: usize = (2 - 1) * envelope_size;
2050
2051            // Zero reserved fields.
2052            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2053
2054            // Safety:
2055            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2056            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2057            //   envelope_size bytes, there is always sufficient room.
2058            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2059                self.locally_generated
2060                    .as_ref()
2061                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2062                encoder,
2063                offset + cur_offset,
2064                depth,
2065            )?;
2066
2067            _prev_end_offset = cur_offset + envelope_size;
2068            if 3 > max_ordinal {
2069                return Ok(());
2070            }
2071
2072            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2073            // are envelope_size bytes.
2074            let cur_offset: usize = (3 - 1) * envelope_size;
2075
2076            // Zero reserved fields.
2077            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2078
2079            // Safety:
2080            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2081            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2082            //   envelope_size bytes, there is always sufficient room.
2083            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
2084            self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
2085            encoder, offset + cur_offset, depth
2086        )?;
2087
2088            _prev_end_offset = cur_offset + envelope_size;
2089
2090            Ok(())
2091        }
2092    }
2093
2094    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2095        for SupplicantStaIfaceCallbackOnDisconnectedRequest
2096    {
2097        #[inline(always)]
2098        fn new_empty() -> Self {
2099            Self::default()
2100        }
2101
2102        unsafe fn decode(
2103            &mut self,
2104            decoder: &mut fidl::encoding::Decoder<'_, D>,
2105            offset: usize,
2106            mut depth: fidl::encoding::Depth,
2107        ) -> fidl::Result<()> {
2108            decoder.debug_check_bounds::<Self>(offset);
2109            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2110                None => return Err(fidl::Error::NotNullable),
2111                Some(len) => len,
2112            };
2113            // Calling decoder.out_of_line_offset(0) is not allowed.
2114            if len == 0 {
2115                return Ok(());
2116            };
2117            depth.increment()?;
2118            let envelope_size = 8;
2119            let bytes_len = len * envelope_size;
2120            let offset = decoder.out_of_line_offset(bytes_len)?;
2121            // Decode the envelope for each type.
2122            let mut _next_ordinal_to_read = 0;
2123            let mut next_offset = offset;
2124            let end_offset = offset + bytes_len;
2125            _next_ordinal_to_read += 1;
2126            if next_offset >= end_offset {
2127                return Ok(());
2128            }
2129
2130            // Decode unknown envelopes for gaps in ordinals.
2131            while _next_ordinal_to_read < 1 {
2132                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2133                _next_ordinal_to_read += 1;
2134                next_offset += envelope_size;
2135            }
2136
2137            let next_out_of_line = decoder.next_out_of_line();
2138            let handles_before = decoder.remaining_handles();
2139            if let Some((inlined, num_bytes, num_handles)) =
2140                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2141            {
2142                let member_inline_size =
2143                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
2144                        decoder.context,
2145                    );
2146                if inlined != (member_inline_size <= 4) {
2147                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2148                }
2149                let inner_offset;
2150                let mut inner_depth = depth.clone();
2151                if inlined {
2152                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2153                    inner_offset = next_offset;
2154                } else {
2155                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2156                    inner_depth.increment()?;
2157                }
2158                let val_ref = self
2159                    .bssid
2160                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
2161                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
2162                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2163                {
2164                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2165                }
2166                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2167                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2168                }
2169            }
2170
2171            next_offset += envelope_size;
2172            _next_ordinal_to_read += 1;
2173            if next_offset >= end_offset {
2174                return Ok(());
2175            }
2176
2177            // Decode unknown envelopes for gaps in ordinals.
2178            while _next_ordinal_to_read < 2 {
2179                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2180                _next_ordinal_to_read += 1;
2181                next_offset += envelope_size;
2182            }
2183
2184            let next_out_of_line = decoder.next_out_of_line();
2185            let handles_before = decoder.remaining_handles();
2186            if let Some((inlined, num_bytes, num_handles)) =
2187                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2188            {
2189                let member_inline_size =
2190                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2191                if inlined != (member_inline_size <= 4) {
2192                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2193                }
2194                let inner_offset;
2195                let mut inner_depth = depth.clone();
2196                if inlined {
2197                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2198                    inner_offset = next_offset;
2199                } else {
2200                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2201                    inner_depth.increment()?;
2202                }
2203                let val_ref =
2204                    self.locally_generated.get_or_insert_with(|| fidl::new_empty!(bool, D));
2205                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2206                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2207                {
2208                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2209                }
2210                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2211                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2212                }
2213            }
2214
2215            next_offset += envelope_size;
2216            _next_ordinal_to_read += 1;
2217            if next_offset >= end_offset {
2218                return Ok(());
2219            }
2220
2221            // Decode unknown envelopes for gaps in ordinals.
2222            while _next_ordinal_to_read < 3 {
2223                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2224                _next_ordinal_to_read += 1;
2225                next_offset += envelope_size;
2226            }
2227
2228            let next_out_of_line = decoder.next_out_of_line();
2229            let handles_before = decoder.remaining_handles();
2230            if let Some((inlined, num_bytes, num_handles)) =
2231                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2232            {
2233                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2234                if inlined != (member_inline_size <= 4) {
2235                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2236                }
2237                let inner_offset;
2238                let mut inner_depth = depth.clone();
2239                if inlined {
2240                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2241                    inner_offset = next_offset;
2242                } else {
2243                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2244                    inner_depth.increment()?;
2245                }
2246                let val_ref = self.reason_code.get_or_insert_with(|| {
2247                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
2248                });
2249                fidl::decode!(
2250                    fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
2251                    D,
2252                    val_ref,
2253                    decoder,
2254                    inner_offset,
2255                    inner_depth
2256                )?;
2257                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2258                {
2259                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2260                }
2261                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2262                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2263                }
2264            }
2265
2266            next_offset += envelope_size;
2267
2268            // Decode the remaining unknown envelopes.
2269            while next_offset < end_offset {
2270                _next_ordinal_to_read += 1;
2271                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2272                next_offset += envelope_size;
2273            }
2274
2275            Ok(())
2276        }
2277    }
2278
2279    impl SupplicantStaIfaceCallbackOnStateChangedRequest {
2280        #[inline(always)]
2281        fn max_ordinal_present(&self) -> u64 {
2282            if let Some(_) = self.ssid {
2283                return 4;
2284            }
2285            if let Some(_) = self.id {
2286                return 3;
2287            }
2288            if let Some(_) = self.bssid {
2289                return 2;
2290            }
2291            if let Some(_) = self.new_state {
2292                return 1;
2293            }
2294            0
2295        }
2296    }
2297
2298    impl fidl::encoding::ValueTypeMarker for SupplicantStaIfaceCallbackOnStateChangedRequest {
2299        type Borrowed<'a> = &'a Self;
2300        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2301            value
2302        }
2303    }
2304
2305    unsafe impl fidl::encoding::TypeMarker for SupplicantStaIfaceCallbackOnStateChangedRequest {
2306        type Owned = Self;
2307
2308        #[inline(always)]
2309        fn inline_align(_context: fidl::encoding::Context) -> usize {
2310            8
2311        }
2312
2313        #[inline(always)]
2314        fn inline_size(_context: fidl::encoding::Context) -> usize {
2315            16
2316        }
2317    }
2318
2319    unsafe impl<D: fidl::encoding::ResourceDialect>
2320        fidl::encoding::Encode<SupplicantStaIfaceCallbackOnStateChangedRequest, D>
2321        for &SupplicantStaIfaceCallbackOnStateChangedRequest
2322    {
2323        unsafe fn encode(
2324            self,
2325            encoder: &mut fidl::encoding::Encoder<'_, D>,
2326            offset: usize,
2327            mut depth: fidl::encoding::Depth,
2328        ) -> fidl::Result<()> {
2329            encoder.debug_check_bounds::<SupplicantStaIfaceCallbackOnStateChangedRequest>(offset);
2330            // Vector header
2331            let max_ordinal: u64 = self.max_ordinal_present();
2332            encoder.write_num(max_ordinal, offset);
2333            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2334            // Calling encoder.out_of_line_offset(0) is not allowed.
2335            if max_ordinal == 0 {
2336                return Ok(());
2337            }
2338            depth.increment()?;
2339            let envelope_size = 8;
2340            let bytes_len = max_ordinal as usize * envelope_size;
2341            #[allow(unused_variables)]
2342            let offset = encoder.out_of_line_offset(bytes_len);
2343            let mut _prev_end_offset: usize = 0;
2344            if 1 > max_ordinal {
2345                return Ok(());
2346            }
2347
2348            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2349            // are envelope_size bytes.
2350            let cur_offset: usize = (1 - 1) * envelope_size;
2351
2352            // Zero reserved fields.
2353            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2354
2355            // Safety:
2356            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2357            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2358            //   envelope_size bytes, there is always sufficient room.
2359            fidl::encoding::encode_in_envelope_optional::<StaIfaceCallbackState, D>(
2360                self.new_state
2361                    .as_ref()
2362                    .map(<StaIfaceCallbackState as fidl::encoding::ValueTypeMarker>::borrow),
2363                encoder,
2364                offset + cur_offset,
2365                depth,
2366            )?;
2367
2368            _prev_end_offset = cur_offset + envelope_size;
2369            if 2 > max_ordinal {
2370                return Ok(());
2371            }
2372
2373            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2374            // are envelope_size bytes.
2375            let cur_offset: usize = (2 - 1) * envelope_size;
2376
2377            // Zero reserved fields.
2378            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2379
2380            // Safety:
2381            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2382            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2383            //   envelope_size bytes, there is always sufficient room.
2384            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
2385                self.bssid
2386                    .as_ref()
2387                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
2388                encoder,
2389                offset + cur_offset,
2390                depth,
2391            )?;
2392
2393            _prev_end_offset = cur_offset + envelope_size;
2394            if 3 > max_ordinal {
2395                return Ok(());
2396            }
2397
2398            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2399            // are envelope_size bytes.
2400            let cur_offset: usize = (3 - 1) * envelope_size;
2401
2402            // Zero reserved fields.
2403            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2404
2405            // Safety:
2406            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2407            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2408            //   envelope_size bytes, there is always sufficient room.
2409            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2410                self.id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2411                encoder,
2412                offset + cur_offset,
2413                depth,
2414            )?;
2415
2416            _prev_end_offset = cur_offset + envelope_size;
2417            if 4 > max_ordinal {
2418                return Ok(());
2419            }
2420
2421            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2422            // are envelope_size bytes.
2423            let cur_offset: usize = (4 - 1) * envelope_size;
2424
2425            // Zero reserved fields.
2426            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2427
2428            // Safety:
2429            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2430            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2431            //   envelope_size bytes, there is always sufficient room.
2432            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
2433                self.ssid.as_ref().map(
2434                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
2435                ),
2436                encoder,
2437                offset + cur_offset,
2438                depth,
2439            )?;
2440
2441            _prev_end_offset = cur_offset + envelope_size;
2442
2443            Ok(())
2444        }
2445    }
2446
2447    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2448        for SupplicantStaIfaceCallbackOnStateChangedRequest
2449    {
2450        #[inline(always)]
2451        fn new_empty() -> Self {
2452            Self::default()
2453        }
2454
2455        unsafe fn decode(
2456            &mut self,
2457            decoder: &mut fidl::encoding::Decoder<'_, D>,
2458            offset: usize,
2459            mut depth: fidl::encoding::Depth,
2460        ) -> fidl::Result<()> {
2461            decoder.debug_check_bounds::<Self>(offset);
2462            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2463                None => return Err(fidl::Error::NotNullable),
2464                Some(len) => len,
2465            };
2466            // Calling decoder.out_of_line_offset(0) is not allowed.
2467            if len == 0 {
2468                return Ok(());
2469            };
2470            depth.increment()?;
2471            let envelope_size = 8;
2472            let bytes_len = len * envelope_size;
2473            let offset = decoder.out_of_line_offset(bytes_len)?;
2474            // Decode the envelope for each type.
2475            let mut _next_ordinal_to_read = 0;
2476            let mut next_offset = offset;
2477            let end_offset = offset + bytes_len;
2478            _next_ordinal_to_read += 1;
2479            if next_offset >= end_offset {
2480                return Ok(());
2481            }
2482
2483            // Decode unknown envelopes for gaps in ordinals.
2484            while _next_ordinal_to_read < 1 {
2485                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2486                _next_ordinal_to_read += 1;
2487                next_offset += envelope_size;
2488            }
2489
2490            let next_out_of_line = decoder.next_out_of_line();
2491            let handles_before = decoder.remaining_handles();
2492            if let Some((inlined, num_bytes, num_handles)) =
2493                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2494            {
2495                let member_inline_size =
2496                    <StaIfaceCallbackState as fidl::encoding::TypeMarker>::inline_size(
2497                        decoder.context,
2498                    );
2499                if inlined != (member_inline_size <= 4) {
2500                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2501                }
2502                let inner_offset;
2503                let mut inner_depth = depth.clone();
2504                if inlined {
2505                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2506                    inner_offset = next_offset;
2507                } else {
2508                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2509                    inner_depth.increment()?;
2510                }
2511                let val_ref = self
2512                    .new_state
2513                    .get_or_insert_with(|| fidl::new_empty!(StaIfaceCallbackState, D));
2514                fidl::decode!(
2515                    StaIfaceCallbackState,
2516                    D,
2517                    val_ref,
2518                    decoder,
2519                    inner_offset,
2520                    inner_depth
2521                )?;
2522                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2523                {
2524                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2525                }
2526                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2527                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2528                }
2529            }
2530
2531            next_offset += envelope_size;
2532            _next_ordinal_to_read += 1;
2533            if next_offset >= end_offset {
2534                return Ok(());
2535            }
2536
2537            // Decode unknown envelopes for gaps in ordinals.
2538            while _next_ordinal_to_read < 2 {
2539                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2540                _next_ordinal_to_read += 1;
2541                next_offset += envelope_size;
2542            }
2543
2544            let next_out_of_line = decoder.next_out_of_line();
2545            let handles_before = decoder.remaining_handles();
2546            if let Some((inlined, num_bytes, num_handles)) =
2547                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2548            {
2549                let member_inline_size =
2550                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
2551                        decoder.context,
2552                    );
2553                if inlined != (member_inline_size <= 4) {
2554                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2555                }
2556                let inner_offset;
2557                let mut inner_depth = depth.clone();
2558                if inlined {
2559                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2560                    inner_offset = next_offset;
2561                } else {
2562                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2563                    inner_depth.increment()?;
2564                }
2565                let val_ref = self
2566                    .bssid
2567                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
2568                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
2569                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2570                {
2571                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2572                }
2573                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2574                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2575                }
2576            }
2577
2578            next_offset += envelope_size;
2579            _next_ordinal_to_read += 1;
2580            if next_offset >= end_offset {
2581                return Ok(());
2582            }
2583
2584            // Decode unknown envelopes for gaps in ordinals.
2585            while _next_ordinal_to_read < 3 {
2586                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2587                _next_ordinal_to_read += 1;
2588                next_offset += envelope_size;
2589            }
2590
2591            let next_out_of_line = decoder.next_out_of_line();
2592            let handles_before = decoder.remaining_handles();
2593            if let Some((inlined, num_bytes, num_handles)) =
2594                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2595            {
2596                let member_inline_size =
2597                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2598                if inlined != (member_inline_size <= 4) {
2599                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2600                }
2601                let inner_offset;
2602                let mut inner_depth = depth.clone();
2603                if inlined {
2604                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2605                    inner_offset = next_offset;
2606                } else {
2607                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2608                    inner_depth.increment()?;
2609                }
2610                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u32, D));
2611                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2612                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2613                {
2614                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2615                }
2616                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2617                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2618                }
2619            }
2620
2621            next_offset += envelope_size;
2622            _next_ordinal_to_read += 1;
2623            if next_offset >= end_offset {
2624                return Ok(());
2625            }
2626
2627            // Decode unknown envelopes for gaps in ordinals.
2628            while _next_ordinal_to_read < 4 {
2629                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2630                _next_ordinal_to_read += 1;
2631                next_offset += envelope_size;
2632            }
2633
2634            let next_out_of_line = decoder.next_out_of_line();
2635            let handles_before = decoder.remaining_handles();
2636            if let Some((inlined, num_bytes, num_handles)) =
2637                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2638            {
2639                let member_inline_size =
2640                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
2641                        decoder.context,
2642                    );
2643                if inlined != (member_inline_size <= 4) {
2644                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2645                }
2646                let inner_offset;
2647                let mut inner_depth = depth.clone();
2648                if inlined {
2649                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2650                    inner_offset = next_offset;
2651                } else {
2652                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2653                    inner_depth.increment()?;
2654                }
2655                let val_ref = self
2656                    .ssid
2657                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
2658                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
2659                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2660                {
2661                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2662                }
2663                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2664                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2665                }
2666            }
2667
2668            next_offset += envelope_size;
2669
2670            // Decode the remaining unknown envelopes.
2671            while next_offset < end_offset {
2672                _next_ordinal_to_read += 1;
2673                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2674                next_offset += envelope_size;
2675            }
2676
2677            Ok(())
2678        }
2679    }
2680
2681    impl SupplicantStaIfaceGetMacAddressResponse {
2682        #[inline(always)]
2683        fn max_ordinal_present(&self) -> u64 {
2684            if let Some(_) = self.mac_addr {
2685                return 1;
2686            }
2687            0
2688        }
2689    }
2690
2691    impl fidl::encoding::ValueTypeMarker for SupplicantStaIfaceGetMacAddressResponse {
2692        type Borrowed<'a> = &'a Self;
2693        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2694            value
2695        }
2696    }
2697
2698    unsafe impl fidl::encoding::TypeMarker for SupplicantStaIfaceGetMacAddressResponse {
2699        type Owned = Self;
2700
2701        #[inline(always)]
2702        fn inline_align(_context: fidl::encoding::Context) -> usize {
2703            8
2704        }
2705
2706        #[inline(always)]
2707        fn inline_size(_context: fidl::encoding::Context) -> usize {
2708            16
2709        }
2710    }
2711
2712    unsafe impl<D: fidl::encoding::ResourceDialect>
2713        fidl::encoding::Encode<SupplicantStaIfaceGetMacAddressResponse, D>
2714        for &SupplicantStaIfaceGetMacAddressResponse
2715    {
2716        unsafe fn encode(
2717            self,
2718            encoder: &mut fidl::encoding::Encoder<'_, D>,
2719            offset: usize,
2720            mut depth: fidl::encoding::Depth,
2721        ) -> fidl::Result<()> {
2722            encoder.debug_check_bounds::<SupplicantStaIfaceGetMacAddressResponse>(offset);
2723            // Vector header
2724            let max_ordinal: u64 = self.max_ordinal_present();
2725            encoder.write_num(max_ordinal, offset);
2726            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2727            // Calling encoder.out_of_line_offset(0) is not allowed.
2728            if max_ordinal == 0 {
2729                return Ok(());
2730            }
2731            depth.increment()?;
2732            let envelope_size = 8;
2733            let bytes_len = max_ordinal as usize * envelope_size;
2734            #[allow(unused_variables)]
2735            let offset = encoder.out_of_line_offset(bytes_len);
2736            let mut _prev_end_offset: usize = 0;
2737            if 1 > max_ordinal {
2738                return Ok(());
2739            }
2740
2741            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2742            // are envelope_size bytes.
2743            let cur_offset: usize = (1 - 1) * envelope_size;
2744
2745            // Zero reserved fields.
2746            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2747
2748            // Safety:
2749            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2750            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2751            //   envelope_size bytes, there is always sufficient room.
2752            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
2753                self.mac_addr
2754                    .as_ref()
2755                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
2756                encoder,
2757                offset + cur_offset,
2758                depth,
2759            )?;
2760
2761            _prev_end_offset = cur_offset + envelope_size;
2762
2763            Ok(())
2764        }
2765    }
2766
2767    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2768        for SupplicantStaIfaceGetMacAddressResponse
2769    {
2770        #[inline(always)]
2771        fn new_empty() -> Self {
2772            Self::default()
2773        }
2774
2775        unsafe fn decode(
2776            &mut self,
2777            decoder: &mut fidl::encoding::Decoder<'_, D>,
2778            offset: usize,
2779            mut depth: fidl::encoding::Depth,
2780        ) -> fidl::Result<()> {
2781            decoder.debug_check_bounds::<Self>(offset);
2782            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2783                None => return Err(fidl::Error::NotNullable),
2784                Some(len) => len,
2785            };
2786            // Calling decoder.out_of_line_offset(0) is not allowed.
2787            if len == 0 {
2788                return Ok(());
2789            };
2790            depth.increment()?;
2791            let envelope_size = 8;
2792            let bytes_len = len * envelope_size;
2793            let offset = decoder.out_of_line_offset(bytes_len)?;
2794            // Decode the envelope for each type.
2795            let mut _next_ordinal_to_read = 0;
2796            let mut next_offset = offset;
2797            let end_offset = offset + bytes_len;
2798            _next_ordinal_to_read += 1;
2799            if next_offset >= end_offset {
2800                return Ok(());
2801            }
2802
2803            // Decode unknown envelopes for gaps in ordinals.
2804            while _next_ordinal_to_read < 1 {
2805                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2806                _next_ordinal_to_read += 1;
2807                next_offset += envelope_size;
2808            }
2809
2810            let next_out_of_line = decoder.next_out_of_line();
2811            let handles_before = decoder.remaining_handles();
2812            if let Some((inlined, num_bytes, num_handles)) =
2813                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2814            {
2815                let member_inline_size =
2816                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
2817                        decoder.context,
2818                    );
2819                if inlined != (member_inline_size <= 4) {
2820                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2821                }
2822                let inner_offset;
2823                let mut inner_depth = depth.clone();
2824                if inlined {
2825                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2826                    inner_offset = next_offset;
2827                } else {
2828                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2829                    inner_depth.increment()?;
2830                }
2831                let val_ref = self
2832                    .mac_addr
2833                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
2834                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
2835                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2836                {
2837                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2838                }
2839                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2840                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2841                }
2842            }
2843
2844            next_offset += envelope_size;
2845
2846            // Decode the remaining unknown envelopes.
2847            while next_offset < end_offset {
2848                _next_ordinal_to_read += 1;
2849                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2850                next_offset += envelope_size;
2851            }
2852
2853            Ok(())
2854        }
2855    }
2856
2857    impl SupplicantStaNetworkSetBssidRequest {
2858        #[inline(always)]
2859        fn max_ordinal_present(&self) -> u64 {
2860            if let Some(_) = self.bssid {
2861                return 1;
2862            }
2863            0
2864        }
2865    }
2866
2867    impl fidl::encoding::ValueTypeMarker for SupplicantStaNetworkSetBssidRequest {
2868        type Borrowed<'a> = &'a Self;
2869        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2870            value
2871        }
2872    }
2873
2874    unsafe impl fidl::encoding::TypeMarker for SupplicantStaNetworkSetBssidRequest {
2875        type Owned = Self;
2876
2877        #[inline(always)]
2878        fn inline_align(_context: fidl::encoding::Context) -> usize {
2879            8
2880        }
2881
2882        #[inline(always)]
2883        fn inline_size(_context: fidl::encoding::Context) -> usize {
2884            16
2885        }
2886    }
2887
2888    unsafe impl<D: fidl::encoding::ResourceDialect>
2889        fidl::encoding::Encode<SupplicantStaNetworkSetBssidRequest, D>
2890        for &SupplicantStaNetworkSetBssidRequest
2891    {
2892        unsafe fn encode(
2893            self,
2894            encoder: &mut fidl::encoding::Encoder<'_, D>,
2895            offset: usize,
2896            mut depth: fidl::encoding::Depth,
2897        ) -> fidl::Result<()> {
2898            encoder.debug_check_bounds::<SupplicantStaNetworkSetBssidRequest>(offset);
2899            // Vector header
2900            let max_ordinal: u64 = self.max_ordinal_present();
2901            encoder.write_num(max_ordinal, offset);
2902            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2903            // Calling encoder.out_of_line_offset(0) is not allowed.
2904            if max_ordinal == 0 {
2905                return Ok(());
2906            }
2907            depth.increment()?;
2908            let envelope_size = 8;
2909            let bytes_len = max_ordinal as usize * envelope_size;
2910            #[allow(unused_variables)]
2911            let offset = encoder.out_of_line_offset(bytes_len);
2912            let mut _prev_end_offset: usize = 0;
2913            if 1 > max_ordinal {
2914                return Ok(());
2915            }
2916
2917            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2918            // are envelope_size bytes.
2919            let cur_offset: usize = (1 - 1) * envelope_size;
2920
2921            // Zero reserved fields.
2922            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2923
2924            // Safety:
2925            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2926            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2927            //   envelope_size bytes, there is always sufficient room.
2928            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
2929                self.bssid
2930                    .as_ref()
2931                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
2932                encoder,
2933                offset + cur_offset,
2934                depth,
2935            )?;
2936
2937            _prev_end_offset = cur_offset + envelope_size;
2938
2939            Ok(())
2940        }
2941    }
2942
2943    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2944        for SupplicantStaNetworkSetBssidRequest
2945    {
2946        #[inline(always)]
2947        fn new_empty() -> Self {
2948            Self::default()
2949        }
2950
2951        unsafe fn decode(
2952            &mut self,
2953            decoder: &mut fidl::encoding::Decoder<'_, D>,
2954            offset: usize,
2955            mut depth: fidl::encoding::Depth,
2956        ) -> fidl::Result<()> {
2957            decoder.debug_check_bounds::<Self>(offset);
2958            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2959                None => return Err(fidl::Error::NotNullable),
2960                Some(len) => len,
2961            };
2962            // Calling decoder.out_of_line_offset(0) is not allowed.
2963            if len == 0 {
2964                return Ok(());
2965            };
2966            depth.increment()?;
2967            let envelope_size = 8;
2968            let bytes_len = len * envelope_size;
2969            let offset = decoder.out_of_line_offset(bytes_len)?;
2970            // Decode the envelope for each type.
2971            let mut _next_ordinal_to_read = 0;
2972            let mut next_offset = offset;
2973            let end_offset = offset + bytes_len;
2974            _next_ordinal_to_read += 1;
2975            if next_offset >= end_offset {
2976                return Ok(());
2977            }
2978
2979            // Decode unknown envelopes for gaps in ordinals.
2980            while _next_ordinal_to_read < 1 {
2981                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2982                _next_ordinal_to_read += 1;
2983                next_offset += envelope_size;
2984            }
2985
2986            let next_out_of_line = decoder.next_out_of_line();
2987            let handles_before = decoder.remaining_handles();
2988            if let Some((inlined, num_bytes, num_handles)) =
2989                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2990            {
2991                let member_inline_size =
2992                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
2993                        decoder.context,
2994                    );
2995                if inlined != (member_inline_size <= 4) {
2996                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2997                }
2998                let inner_offset;
2999                let mut inner_depth = depth.clone();
3000                if inlined {
3001                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3002                    inner_offset = next_offset;
3003                } else {
3004                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3005                    inner_depth.increment()?;
3006                }
3007                let val_ref = self
3008                    .bssid
3009                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
3010                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
3011                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3012                {
3013                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3014                }
3015                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3016                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3017                }
3018            }
3019
3020            next_offset += envelope_size;
3021
3022            // Decode the remaining unknown envelopes.
3023            while next_offset < end_offset {
3024                _next_ordinal_to_read += 1;
3025                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3026                next_offset += envelope_size;
3027            }
3028
3029            Ok(())
3030        }
3031    }
3032
3033    impl SupplicantStaNetworkSetPskPassphraseRequest {
3034        #[inline(always)]
3035        fn max_ordinal_present(&self) -> u64 {
3036            if let Some(_) = self.passphrase {
3037                return 1;
3038            }
3039            0
3040        }
3041    }
3042
3043    impl fidl::encoding::ValueTypeMarker for SupplicantStaNetworkSetPskPassphraseRequest {
3044        type Borrowed<'a> = &'a Self;
3045        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3046            value
3047        }
3048    }
3049
3050    unsafe impl fidl::encoding::TypeMarker for SupplicantStaNetworkSetPskPassphraseRequest {
3051        type Owned = Self;
3052
3053        #[inline(always)]
3054        fn inline_align(_context: fidl::encoding::Context) -> usize {
3055            8
3056        }
3057
3058        #[inline(always)]
3059        fn inline_size(_context: fidl::encoding::Context) -> usize {
3060            16
3061        }
3062    }
3063
3064    unsafe impl<D: fidl::encoding::ResourceDialect>
3065        fidl::encoding::Encode<SupplicantStaNetworkSetPskPassphraseRequest, D>
3066        for &SupplicantStaNetworkSetPskPassphraseRequest
3067    {
3068        unsafe fn encode(
3069            self,
3070            encoder: &mut fidl::encoding::Encoder<'_, D>,
3071            offset: usize,
3072            mut depth: fidl::encoding::Depth,
3073        ) -> fidl::Result<()> {
3074            encoder.debug_check_bounds::<SupplicantStaNetworkSetPskPassphraseRequest>(offset);
3075            // Vector header
3076            let max_ordinal: u64 = self.max_ordinal_present();
3077            encoder.write_num(max_ordinal, offset);
3078            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3079            // Calling encoder.out_of_line_offset(0) is not allowed.
3080            if max_ordinal == 0 {
3081                return Ok(());
3082            }
3083            depth.increment()?;
3084            let envelope_size = 8;
3085            let bytes_len = max_ordinal as usize * envelope_size;
3086            #[allow(unused_variables)]
3087            let offset = encoder.out_of_line_offset(bytes_len);
3088            let mut _prev_end_offset: usize = 0;
3089            if 1 > max_ordinal {
3090                return Ok(());
3091            }
3092
3093            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3094            // are envelope_size bytes.
3095            let cur_offset: usize = (1 - 1) * envelope_size;
3096
3097            // Zero reserved fields.
3098            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3099
3100            // Safety:
3101            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3102            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3103            //   envelope_size bytes, there is always sufficient room.
3104            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
3105            self.passphrase.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
3106            encoder, offset + cur_offset, depth
3107        )?;
3108
3109            _prev_end_offset = cur_offset + envelope_size;
3110
3111            Ok(())
3112        }
3113    }
3114
3115    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3116        for SupplicantStaNetworkSetPskPassphraseRequest
3117    {
3118        #[inline(always)]
3119        fn new_empty() -> Self {
3120            Self::default()
3121        }
3122
3123        unsafe fn decode(
3124            &mut self,
3125            decoder: &mut fidl::encoding::Decoder<'_, D>,
3126            offset: usize,
3127            mut depth: fidl::encoding::Depth,
3128        ) -> fidl::Result<()> {
3129            decoder.debug_check_bounds::<Self>(offset);
3130            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3131                None => return Err(fidl::Error::NotNullable),
3132                Some(len) => len,
3133            };
3134            // Calling decoder.out_of_line_offset(0) is not allowed.
3135            if len == 0 {
3136                return Ok(());
3137            };
3138            depth.increment()?;
3139            let envelope_size = 8;
3140            let bytes_len = len * envelope_size;
3141            let offset = decoder.out_of_line_offset(bytes_len)?;
3142            // Decode the envelope for each type.
3143            let mut _next_ordinal_to_read = 0;
3144            let mut next_offset = offset;
3145            let end_offset = offset + bytes_len;
3146            _next_ordinal_to_read += 1;
3147            if next_offset >= end_offset {
3148                return Ok(());
3149            }
3150
3151            // Decode unknown envelopes for gaps in ordinals.
3152            while _next_ordinal_to_read < 1 {
3153                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3154                _next_ordinal_to_read += 1;
3155                next_offset += envelope_size;
3156            }
3157
3158            let next_out_of_line = decoder.next_out_of_line();
3159            let handles_before = decoder.remaining_handles();
3160            if let Some((inlined, num_bytes, num_handles)) =
3161                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3162            {
3163                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3164                if inlined != (member_inline_size <= 4) {
3165                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3166                }
3167                let inner_offset;
3168                let mut inner_depth = depth.clone();
3169                if inlined {
3170                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3171                    inner_offset = next_offset;
3172                } else {
3173                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3174                    inner_depth.increment()?;
3175                }
3176                let val_ref = self.passphrase.get_or_insert_with(|| {
3177                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
3178                });
3179                fidl::decode!(
3180                    fidl::encoding::UnboundedVector<u8>,
3181                    D,
3182                    val_ref,
3183                    decoder,
3184                    inner_offset,
3185                    inner_depth
3186                )?;
3187                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3188                {
3189                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3190                }
3191                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3192                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3193                }
3194            }
3195
3196            next_offset += envelope_size;
3197
3198            // Decode the remaining unknown envelopes.
3199            while next_offset < end_offset {
3200                _next_ordinal_to_read += 1;
3201                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3202                next_offset += envelope_size;
3203            }
3204
3205            Ok(())
3206        }
3207    }
3208
3209    impl SupplicantStaNetworkSetSsidRequest {
3210        #[inline(always)]
3211        fn max_ordinal_present(&self) -> u64 {
3212            if let Some(_) = self.ssid {
3213                return 1;
3214            }
3215            0
3216        }
3217    }
3218
3219    impl fidl::encoding::ValueTypeMarker for SupplicantStaNetworkSetSsidRequest {
3220        type Borrowed<'a> = &'a Self;
3221        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3222            value
3223        }
3224    }
3225
3226    unsafe impl fidl::encoding::TypeMarker for SupplicantStaNetworkSetSsidRequest {
3227        type Owned = Self;
3228
3229        #[inline(always)]
3230        fn inline_align(_context: fidl::encoding::Context) -> usize {
3231            8
3232        }
3233
3234        #[inline(always)]
3235        fn inline_size(_context: fidl::encoding::Context) -> usize {
3236            16
3237        }
3238    }
3239
3240    unsafe impl<D: fidl::encoding::ResourceDialect>
3241        fidl::encoding::Encode<SupplicantStaNetworkSetSsidRequest, D>
3242        for &SupplicantStaNetworkSetSsidRequest
3243    {
3244        unsafe fn encode(
3245            self,
3246            encoder: &mut fidl::encoding::Encoder<'_, D>,
3247            offset: usize,
3248            mut depth: fidl::encoding::Depth,
3249        ) -> fidl::Result<()> {
3250            encoder.debug_check_bounds::<SupplicantStaNetworkSetSsidRequest>(offset);
3251            // Vector header
3252            let max_ordinal: u64 = self.max_ordinal_present();
3253            encoder.write_num(max_ordinal, offset);
3254            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3255            // Calling encoder.out_of_line_offset(0) is not allowed.
3256            if max_ordinal == 0 {
3257                return Ok(());
3258            }
3259            depth.increment()?;
3260            let envelope_size = 8;
3261            let bytes_len = max_ordinal as usize * envelope_size;
3262            #[allow(unused_variables)]
3263            let offset = encoder.out_of_line_offset(bytes_len);
3264            let mut _prev_end_offset: usize = 0;
3265            if 1 > max_ordinal {
3266                return Ok(());
3267            }
3268
3269            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3270            // are envelope_size bytes.
3271            let cur_offset: usize = (1 - 1) * envelope_size;
3272
3273            // Zero reserved fields.
3274            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3275
3276            // Safety:
3277            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3278            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3279            //   envelope_size bytes, there is always sufficient room.
3280            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
3281                self.ssid.as_ref().map(
3282                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
3283                ),
3284                encoder,
3285                offset + cur_offset,
3286                depth,
3287            )?;
3288
3289            _prev_end_offset = cur_offset + envelope_size;
3290
3291            Ok(())
3292        }
3293    }
3294
3295    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3296        for SupplicantStaNetworkSetSsidRequest
3297    {
3298        #[inline(always)]
3299        fn new_empty() -> Self {
3300            Self::default()
3301        }
3302
3303        unsafe fn decode(
3304            &mut self,
3305            decoder: &mut fidl::encoding::Decoder<'_, D>,
3306            offset: usize,
3307            mut depth: fidl::encoding::Depth,
3308        ) -> fidl::Result<()> {
3309            decoder.debug_check_bounds::<Self>(offset);
3310            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3311                None => return Err(fidl::Error::NotNullable),
3312                Some(len) => len,
3313            };
3314            // Calling decoder.out_of_line_offset(0) is not allowed.
3315            if len == 0 {
3316                return Ok(());
3317            };
3318            depth.increment()?;
3319            let envelope_size = 8;
3320            let bytes_len = len * envelope_size;
3321            let offset = decoder.out_of_line_offset(bytes_len)?;
3322            // Decode the envelope for each type.
3323            let mut _next_ordinal_to_read = 0;
3324            let mut next_offset = offset;
3325            let end_offset = offset + bytes_len;
3326            _next_ordinal_to_read += 1;
3327            if next_offset >= end_offset {
3328                return Ok(());
3329            }
3330
3331            // Decode unknown envelopes for gaps in ordinals.
3332            while _next_ordinal_to_read < 1 {
3333                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3334                _next_ordinal_to_read += 1;
3335                next_offset += envelope_size;
3336            }
3337
3338            let next_out_of_line = decoder.next_out_of_line();
3339            let handles_before = decoder.remaining_handles();
3340            if let Some((inlined, num_bytes, num_handles)) =
3341                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3342            {
3343                let member_inline_size =
3344                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
3345                        decoder.context,
3346                    );
3347                if inlined != (member_inline_size <= 4) {
3348                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3349                }
3350                let inner_offset;
3351                let mut inner_depth = depth.clone();
3352                if inlined {
3353                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3354                    inner_offset = next_offset;
3355                } else {
3356                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3357                    inner_depth.increment()?;
3358                }
3359                let val_ref = self
3360                    .ssid
3361                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
3362                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
3363                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3364                {
3365                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3366                }
3367                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3368                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3369                }
3370            }
3371
3372            next_offset += envelope_size;
3373
3374            // Decode the remaining unknown envelopes.
3375            while next_offset < end_offset {
3376                _next_ordinal_to_read += 1;
3377                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3378                next_offset += envelope_size;
3379            }
3380
3381            Ok(())
3382        }
3383    }
3384
3385    impl WifiChipGetAvailableModesResponse {
3386        #[inline(always)]
3387        fn max_ordinal_present(&self) -> u64 {
3388            if let Some(_) = self.chip_modes {
3389                return 1;
3390            }
3391            0
3392        }
3393    }
3394
3395    impl fidl::encoding::ValueTypeMarker for WifiChipGetAvailableModesResponse {
3396        type Borrowed<'a> = &'a Self;
3397        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3398            value
3399        }
3400    }
3401
3402    unsafe impl fidl::encoding::TypeMarker for WifiChipGetAvailableModesResponse {
3403        type Owned = Self;
3404
3405        #[inline(always)]
3406        fn inline_align(_context: fidl::encoding::Context) -> usize {
3407            8
3408        }
3409
3410        #[inline(always)]
3411        fn inline_size(_context: fidl::encoding::Context) -> usize {
3412            16
3413        }
3414    }
3415
3416    unsafe impl<D: fidl::encoding::ResourceDialect>
3417        fidl::encoding::Encode<WifiChipGetAvailableModesResponse, D>
3418        for &WifiChipGetAvailableModesResponse
3419    {
3420        unsafe fn encode(
3421            self,
3422            encoder: &mut fidl::encoding::Encoder<'_, D>,
3423            offset: usize,
3424            mut depth: fidl::encoding::Depth,
3425        ) -> fidl::Result<()> {
3426            encoder.debug_check_bounds::<WifiChipGetAvailableModesResponse>(offset);
3427            // Vector header
3428            let max_ordinal: u64 = self.max_ordinal_present();
3429            encoder.write_num(max_ordinal, offset);
3430            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3431            // Calling encoder.out_of_line_offset(0) is not allowed.
3432            if max_ordinal == 0 {
3433                return Ok(());
3434            }
3435            depth.increment()?;
3436            let envelope_size = 8;
3437            let bytes_len = max_ordinal as usize * envelope_size;
3438            #[allow(unused_variables)]
3439            let offset = encoder.out_of_line_offset(bytes_len);
3440            let mut _prev_end_offset: usize = 0;
3441            if 1 > max_ordinal {
3442                return Ok(());
3443            }
3444
3445            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3446            // are envelope_size bytes.
3447            let cur_offset: usize = (1 - 1) * envelope_size;
3448
3449            // Zero reserved fields.
3450            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3451
3452            // Safety:
3453            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3454            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3455            //   envelope_size bytes, there is always sufficient room.
3456            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ChipMode>, D>(
3457            self.chip_modes.as_ref().map(<fidl::encoding::UnboundedVector<ChipMode> as fidl::encoding::ValueTypeMarker>::borrow),
3458            encoder, offset + cur_offset, depth
3459        )?;
3460
3461            _prev_end_offset = cur_offset + envelope_size;
3462
3463            Ok(())
3464        }
3465    }
3466
3467    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3468        for WifiChipGetAvailableModesResponse
3469    {
3470        #[inline(always)]
3471        fn new_empty() -> Self {
3472            Self::default()
3473        }
3474
3475        unsafe fn decode(
3476            &mut self,
3477            decoder: &mut fidl::encoding::Decoder<'_, D>,
3478            offset: usize,
3479            mut depth: fidl::encoding::Depth,
3480        ) -> fidl::Result<()> {
3481            decoder.debug_check_bounds::<Self>(offset);
3482            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3483                None => return Err(fidl::Error::NotNullable),
3484                Some(len) => len,
3485            };
3486            // Calling decoder.out_of_line_offset(0) is not allowed.
3487            if len == 0 {
3488                return Ok(());
3489            };
3490            depth.increment()?;
3491            let envelope_size = 8;
3492            let bytes_len = len * envelope_size;
3493            let offset = decoder.out_of_line_offset(bytes_len)?;
3494            // Decode the envelope for each type.
3495            let mut _next_ordinal_to_read = 0;
3496            let mut next_offset = offset;
3497            let end_offset = offset + bytes_len;
3498            _next_ordinal_to_read += 1;
3499            if next_offset >= end_offset {
3500                return Ok(());
3501            }
3502
3503            // Decode unknown envelopes for gaps in ordinals.
3504            while _next_ordinal_to_read < 1 {
3505                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3506                _next_ordinal_to_read += 1;
3507                next_offset += envelope_size;
3508            }
3509
3510            let next_out_of_line = decoder.next_out_of_line();
3511            let handles_before = decoder.remaining_handles();
3512            if let Some((inlined, num_bytes, num_handles)) =
3513                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3514            {
3515                let member_inline_size = <fidl::encoding::UnboundedVector<ChipMode> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3516                if inlined != (member_inline_size <= 4) {
3517                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3518                }
3519                let inner_offset;
3520                let mut inner_depth = depth.clone();
3521                if inlined {
3522                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3523                    inner_offset = next_offset;
3524                } else {
3525                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3526                    inner_depth.increment()?;
3527                }
3528                let val_ref = self.chip_modes.get_or_insert_with(|| {
3529                    fidl::new_empty!(fidl::encoding::UnboundedVector<ChipMode>, D)
3530                });
3531                fidl::decode!(
3532                    fidl::encoding::UnboundedVector<ChipMode>,
3533                    D,
3534                    val_ref,
3535                    decoder,
3536                    inner_offset,
3537                    inner_depth
3538                )?;
3539                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3540                {
3541                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3542                }
3543                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3544                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3545                }
3546            }
3547
3548            next_offset += envelope_size;
3549
3550            // Decode the remaining unknown envelopes.
3551            while next_offset < end_offset {
3552                _next_ordinal_to_read += 1;
3553                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3554                next_offset += envelope_size;
3555            }
3556
3557            Ok(())
3558        }
3559    }
3560
3561    impl WifiChipGetCapabilitiesResponse {
3562        #[inline(always)]
3563        fn max_ordinal_present(&self) -> u64 {
3564            if let Some(_) = self.capabilities_mask {
3565                return 1;
3566            }
3567            0
3568        }
3569    }
3570
3571    impl fidl::encoding::ValueTypeMarker for WifiChipGetCapabilitiesResponse {
3572        type Borrowed<'a> = &'a Self;
3573        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3574            value
3575        }
3576    }
3577
3578    unsafe impl fidl::encoding::TypeMarker for WifiChipGetCapabilitiesResponse {
3579        type Owned = Self;
3580
3581        #[inline(always)]
3582        fn inline_align(_context: fidl::encoding::Context) -> usize {
3583            8
3584        }
3585
3586        #[inline(always)]
3587        fn inline_size(_context: fidl::encoding::Context) -> usize {
3588            16
3589        }
3590    }
3591
3592    unsafe impl<D: fidl::encoding::ResourceDialect>
3593        fidl::encoding::Encode<WifiChipGetCapabilitiesResponse, D>
3594        for &WifiChipGetCapabilitiesResponse
3595    {
3596        unsafe fn encode(
3597            self,
3598            encoder: &mut fidl::encoding::Encoder<'_, D>,
3599            offset: usize,
3600            mut depth: fidl::encoding::Depth,
3601        ) -> fidl::Result<()> {
3602            encoder.debug_check_bounds::<WifiChipGetCapabilitiesResponse>(offset);
3603            // Vector header
3604            let max_ordinal: u64 = self.max_ordinal_present();
3605            encoder.write_num(max_ordinal, offset);
3606            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3607            // Calling encoder.out_of_line_offset(0) is not allowed.
3608            if max_ordinal == 0 {
3609                return Ok(());
3610            }
3611            depth.increment()?;
3612            let envelope_size = 8;
3613            let bytes_len = max_ordinal as usize * envelope_size;
3614            #[allow(unused_variables)]
3615            let offset = encoder.out_of_line_offset(bytes_len);
3616            let mut _prev_end_offset: usize = 0;
3617            if 1 > max_ordinal {
3618                return Ok(());
3619            }
3620
3621            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3622            // are envelope_size bytes.
3623            let cur_offset: usize = (1 - 1) * envelope_size;
3624
3625            // Zero reserved fields.
3626            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3627
3628            // Safety:
3629            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3630            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3631            //   envelope_size bytes, there is always sufficient room.
3632            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3633                self.capabilities_mask
3634                    .as_ref()
3635                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3636                encoder,
3637                offset + cur_offset,
3638                depth,
3639            )?;
3640
3641            _prev_end_offset = cur_offset + envelope_size;
3642
3643            Ok(())
3644        }
3645    }
3646
3647    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3648        for WifiChipGetCapabilitiesResponse
3649    {
3650        #[inline(always)]
3651        fn new_empty() -> Self {
3652            Self::default()
3653        }
3654
3655        unsafe fn decode(
3656            &mut self,
3657            decoder: &mut fidl::encoding::Decoder<'_, D>,
3658            offset: usize,
3659            mut depth: fidl::encoding::Depth,
3660        ) -> fidl::Result<()> {
3661            decoder.debug_check_bounds::<Self>(offset);
3662            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3663                None => return Err(fidl::Error::NotNullable),
3664                Some(len) => len,
3665            };
3666            // Calling decoder.out_of_line_offset(0) is not allowed.
3667            if len == 0 {
3668                return Ok(());
3669            };
3670            depth.increment()?;
3671            let envelope_size = 8;
3672            let bytes_len = len * envelope_size;
3673            let offset = decoder.out_of_line_offset(bytes_len)?;
3674            // Decode the envelope for each type.
3675            let mut _next_ordinal_to_read = 0;
3676            let mut next_offset = offset;
3677            let end_offset = offset + bytes_len;
3678            _next_ordinal_to_read += 1;
3679            if next_offset >= end_offset {
3680                return Ok(());
3681            }
3682
3683            // Decode unknown envelopes for gaps in ordinals.
3684            while _next_ordinal_to_read < 1 {
3685                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3686                _next_ordinal_to_read += 1;
3687                next_offset += envelope_size;
3688            }
3689
3690            let next_out_of_line = decoder.next_out_of_line();
3691            let handles_before = decoder.remaining_handles();
3692            if let Some((inlined, num_bytes, num_handles)) =
3693                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3694            {
3695                let member_inline_size =
3696                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3697                if inlined != (member_inline_size <= 4) {
3698                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3699                }
3700                let inner_offset;
3701                let mut inner_depth = depth.clone();
3702                if inlined {
3703                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3704                    inner_offset = next_offset;
3705                } else {
3706                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3707                    inner_depth.increment()?;
3708                }
3709                let val_ref =
3710                    self.capabilities_mask.get_or_insert_with(|| fidl::new_empty!(u32, D));
3711                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3712                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3713                {
3714                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3715                }
3716                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3717                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3718                }
3719            }
3720
3721            next_offset += envelope_size;
3722
3723            // Decode the remaining unknown envelopes.
3724            while next_offset < end_offset {
3725                _next_ordinal_to_read += 1;
3726                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3727                next_offset += envelope_size;
3728            }
3729
3730            Ok(())
3731        }
3732    }
3733
3734    impl WifiChipGetIdResponse {
3735        #[inline(always)]
3736        fn max_ordinal_present(&self) -> u64 {
3737            if let Some(_) = self.id {
3738                return 1;
3739            }
3740            0
3741        }
3742    }
3743
3744    impl fidl::encoding::ValueTypeMarker for WifiChipGetIdResponse {
3745        type Borrowed<'a> = &'a Self;
3746        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3747            value
3748        }
3749    }
3750
3751    unsafe impl fidl::encoding::TypeMarker for WifiChipGetIdResponse {
3752        type Owned = Self;
3753
3754        #[inline(always)]
3755        fn inline_align(_context: fidl::encoding::Context) -> usize {
3756            8
3757        }
3758
3759        #[inline(always)]
3760        fn inline_size(_context: fidl::encoding::Context) -> usize {
3761            16
3762        }
3763    }
3764
3765    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WifiChipGetIdResponse, D>
3766        for &WifiChipGetIdResponse
3767    {
3768        unsafe fn encode(
3769            self,
3770            encoder: &mut fidl::encoding::Encoder<'_, D>,
3771            offset: usize,
3772            mut depth: fidl::encoding::Depth,
3773        ) -> fidl::Result<()> {
3774            encoder.debug_check_bounds::<WifiChipGetIdResponse>(offset);
3775            // Vector header
3776            let max_ordinal: u64 = self.max_ordinal_present();
3777            encoder.write_num(max_ordinal, offset);
3778            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3779            // Calling encoder.out_of_line_offset(0) is not allowed.
3780            if max_ordinal == 0 {
3781                return Ok(());
3782            }
3783            depth.increment()?;
3784            let envelope_size = 8;
3785            let bytes_len = max_ordinal as usize * envelope_size;
3786            #[allow(unused_variables)]
3787            let offset = encoder.out_of_line_offset(bytes_len);
3788            let mut _prev_end_offset: usize = 0;
3789            if 1 > max_ordinal {
3790                return Ok(());
3791            }
3792
3793            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3794            // are envelope_size bytes.
3795            let cur_offset: usize = (1 - 1) * envelope_size;
3796
3797            // Zero reserved fields.
3798            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3799
3800            // Safety:
3801            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3802            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3803            //   envelope_size bytes, there is always sufficient room.
3804            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3805                self.id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3806                encoder,
3807                offset + cur_offset,
3808                depth,
3809            )?;
3810
3811            _prev_end_offset = cur_offset + envelope_size;
3812
3813            Ok(())
3814        }
3815    }
3816
3817    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WifiChipGetIdResponse {
3818        #[inline(always)]
3819        fn new_empty() -> Self {
3820            Self::default()
3821        }
3822
3823        unsafe fn decode(
3824            &mut self,
3825            decoder: &mut fidl::encoding::Decoder<'_, D>,
3826            offset: usize,
3827            mut depth: fidl::encoding::Depth,
3828        ) -> fidl::Result<()> {
3829            decoder.debug_check_bounds::<Self>(offset);
3830            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3831                None => return Err(fidl::Error::NotNullable),
3832                Some(len) => len,
3833            };
3834            // Calling decoder.out_of_line_offset(0) is not allowed.
3835            if len == 0 {
3836                return Ok(());
3837            };
3838            depth.increment()?;
3839            let envelope_size = 8;
3840            let bytes_len = len * envelope_size;
3841            let offset = decoder.out_of_line_offset(bytes_len)?;
3842            // Decode the envelope for each type.
3843            let mut _next_ordinal_to_read = 0;
3844            let mut next_offset = offset;
3845            let end_offset = offset + bytes_len;
3846            _next_ordinal_to_read += 1;
3847            if next_offset >= end_offset {
3848                return Ok(());
3849            }
3850
3851            // Decode unknown envelopes for gaps in ordinals.
3852            while _next_ordinal_to_read < 1 {
3853                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3854                _next_ordinal_to_read += 1;
3855                next_offset += envelope_size;
3856            }
3857
3858            let next_out_of_line = decoder.next_out_of_line();
3859            let handles_before = decoder.remaining_handles();
3860            if let Some((inlined, num_bytes, num_handles)) =
3861                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3862            {
3863                let member_inline_size =
3864                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3865                if inlined != (member_inline_size <= 4) {
3866                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3867                }
3868                let inner_offset;
3869                let mut inner_depth = depth.clone();
3870                if inlined {
3871                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3872                    inner_offset = next_offset;
3873                } else {
3874                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3875                    inner_depth.increment()?;
3876                }
3877                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u32, D));
3878                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3879                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3880                {
3881                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3882                }
3883                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3884                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3885                }
3886            }
3887
3888            next_offset += envelope_size;
3889
3890            // Decode the remaining unknown envelopes.
3891            while next_offset < end_offset {
3892                _next_ordinal_to_read += 1;
3893                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3894                next_offset += envelope_size;
3895            }
3896
3897            Ok(())
3898        }
3899    }
3900
3901    impl WifiChipGetModeResponse {
3902        #[inline(always)]
3903        fn max_ordinal_present(&self) -> u64 {
3904            if let Some(_) = self.mode {
3905                return 1;
3906            }
3907            0
3908        }
3909    }
3910
3911    impl fidl::encoding::ValueTypeMarker for WifiChipGetModeResponse {
3912        type Borrowed<'a> = &'a Self;
3913        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3914            value
3915        }
3916    }
3917
3918    unsafe impl fidl::encoding::TypeMarker for WifiChipGetModeResponse {
3919        type Owned = Self;
3920
3921        #[inline(always)]
3922        fn inline_align(_context: fidl::encoding::Context) -> usize {
3923            8
3924        }
3925
3926        #[inline(always)]
3927        fn inline_size(_context: fidl::encoding::Context) -> usize {
3928            16
3929        }
3930    }
3931
3932    unsafe impl<D: fidl::encoding::ResourceDialect>
3933        fidl::encoding::Encode<WifiChipGetModeResponse, D> for &WifiChipGetModeResponse
3934    {
3935        unsafe fn encode(
3936            self,
3937            encoder: &mut fidl::encoding::Encoder<'_, D>,
3938            offset: usize,
3939            mut depth: fidl::encoding::Depth,
3940        ) -> fidl::Result<()> {
3941            encoder.debug_check_bounds::<WifiChipGetModeResponse>(offset);
3942            // Vector header
3943            let max_ordinal: u64 = self.max_ordinal_present();
3944            encoder.write_num(max_ordinal, offset);
3945            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3946            // Calling encoder.out_of_line_offset(0) is not allowed.
3947            if max_ordinal == 0 {
3948                return Ok(());
3949            }
3950            depth.increment()?;
3951            let envelope_size = 8;
3952            let bytes_len = max_ordinal as usize * envelope_size;
3953            #[allow(unused_variables)]
3954            let offset = encoder.out_of_line_offset(bytes_len);
3955            let mut _prev_end_offset: usize = 0;
3956            if 1 > max_ordinal {
3957                return Ok(());
3958            }
3959
3960            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3961            // are envelope_size bytes.
3962            let cur_offset: usize = (1 - 1) * envelope_size;
3963
3964            // Zero reserved fields.
3965            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3966
3967            // Safety:
3968            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3969            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3970            //   envelope_size bytes, there is always sufficient room.
3971            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3972                self.mode.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3973                encoder,
3974                offset + cur_offset,
3975                depth,
3976            )?;
3977
3978            _prev_end_offset = cur_offset + envelope_size;
3979
3980            Ok(())
3981        }
3982    }
3983
3984    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3985        for WifiChipGetModeResponse
3986    {
3987        #[inline(always)]
3988        fn new_empty() -> Self {
3989            Self::default()
3990        }
3991
3992        unsafe fn decode(
3993            &mut self,
3994            decoder: &mut fidl::encoding::Decoder<'_, D>,
3995            offset: usize,
3996            mut depth: fidl::encoding::Depth,
3997        ) -> fidl::Result<()> {
3998            decoder.debug_check_bounds::<Self>(offset);
3999            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4000                None => return Err(fidl::Error::NotNullable),
4001                Some(len) => len,
4002            };
4003            // Calling decoder.out_of_line_offset(0) is not allowed.
4004            if len == 0 {
4005                return Ok(());
4006            };
4007            depth.increment()?;
4008            let envelope_size = 8;
4009            let bytes_len = len * envelope_size;
4010            let offset = decoder.out_of_line_offset(bytes_len)?;
4011            // Decode the envelope for each type.
4012            let mut _next_ordinal_to_read = 0;
4013            let mut next_offset = offset;
4014            let end_offset = offset + bytes_len;
4015            _next_ordinal_to_read += 1;
4016            if next_offset >= end_offset {
4017                return Ok(());
4018            }
4019
4020            // Decode unknown envelopes for gaps in ordinals.
4021            while _next_ordinal_to_read < 1 {
4022                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4023                _next_ordinal_to_read += 1;
4024                next_offset += envelope_size;
4025            }
4026
4027            let next_out_of_line = decoder.next_out_of_line();
4028            let handles_before = decoder.remaining_handles();
4029            if let Some((inlined, num_bytes, num_handles)) =
4030                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4031            {
4032                let member_inline_size =
4033                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4034                if inlined != (member_inline_size <= 4) {
4035                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4036                }
4037                let inner_offset;
4038                let mut inner_depth = depth.clone();
4039                if inlined {
4040                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4041                    inner_offset = next_offset;
4042                } else {
4043                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4044                    inner_depth.increment()?;
4045                }
4046                let val_ref = self.mode.get_or_insert_with(|| fidl::new_empty!(u32, D));
4047                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4048                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4049                {
4050                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4051                }
4052                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4053                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4054                }
4055            }
4056
4057            next_offset += envelope_size;
4058
4059            // Decode the remaining unknown envelopes.
4060            while next_offset < end_offset {
4061                _next_ordinal_to_read += 1;
4062                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4063                next_offset += envelope_size;
4064            }
4065
4066            Ok(())
4067        }
4068    }
4069
4070    impl WifiChipGetStaIfaceNamesResponse {
4071        #[inline(always)]
4072        fn max_ordinal_present(&self) -> u64 {
4073            if let Some(_) = self.iface_names {
4074                return 1;
4075            }
4076            0
4077        }
4078    }
4079
4080    impl fidl::encoding::ValueTypeMarker for WifiChipGetStaIfaceNamesResponse {
4081        type Borrowed<'a> = &'a Self;
4082        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4083            value
4084        }
4085    }
4086
4087    unsafe impl fidl::encoding::TypeMarker for WifiChipGetStaIfaceNamesResponse {
4088        type Owned = Self;
4089
4090        #[inline(always)]
4091        fn inline_align(_context: fidl::encoding::Context) -> usize {
4092            8
4093        }
4094
4095        #[inline(always)]
4096        fn inline_size(_context: fidl::encoding::Context) -> usize {
4097            16
4098        }
4099    }
4100
4101    unsafe impl<D: fidl::encoding::ResourceDialect>
4102        fidl::encoding::Encode<WifiChipGetStaIfaceNamesResponse, D>
4103        for &WifiChipGetStaIfaceNamesResponse
4104    {
4105        unsafe fn encode(
4106            self,
4107            encoder: &mut fidl::encoding::Encoder<'_, D>,
4108            offset: usize,
4109            mut depth: fidl::encoding::Depth,
4110        ) -> fidl::Result<()> {
4111            encoder.debug_check_bounds::<WifiChipGetStaIfaceNamesResponse>(offset);
4112            // Vector header
4113            let max_ordinal: u64 = self.max_ordinal_present();
4114            encoder.write_num(max_ordinal, offset);
4115            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4116            // Calling encoder.out_of_line_offset(0) is not allowed.
4117            if max_ordinal == 0 {
4118                return Ok(());
4119            }
4120            depth.increment()?;
4121            let envelope_size = 8;
4122            let bytes_len = max_ordinal as usize * envelope_size;
4123            #[allow(unused_variables)]
4124            let offset = encoder.out_of_line_offset(bytes_len);
4125            let mut _prev_end_offset: usize = 0;
4126            if 1 > max_ordinal {
4127                return Ok(());
4128            }
4129
4130            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4131            // are envelope_size bytes.
4132            let cur_offset: usize = (1 - 1) * envelope_size;
4133
4134            // Zero reserved fields.
4135            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4136
4137            // Safety:
4138            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4139            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4140            //   envelope_size bytes, there is always sufficient room.
4141            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<16>>, D>(
4142            self.iface_names.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<16>> as fidl::encoding::ValueTypeMarker>::borrow),
4143            encoder, offset + cur_offset, depth
4144        )?;
4145
4146            _prev_end_offset = cur_offset + envelope_size;
4147
4148            Ok(())
4149        }
4150    }
4151
4152    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4153        for WifiChipGetStaIfaceNamesResponse
4154    {
4155        #[inline(always)]
4156        fn new_empty() -> Self {
4157            Self::default()
4158        }
4159
4160        unsafe fn decode(
4161            &mut self,
4162            decoder: &mut fidl::encoding::Decoder<'_, D>,
4163            offset: usize,
4164            mut depth: fidl::encoding::Depth,
4165        ) -> fidl::Result<()> {
4166            decoder.debug_check_bounds::<Self>(offset);
4167            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4168                None => return Err(fidl::Error::NotNullable),
4169                Some(len) => len,
4170            };
4171            // Calling decoder.out_of_line_offset(0) is not allowed.
4172            if len == 0 {
4173                return Ok(());
4174            };
4175            depth.increment()?;
4176            let envelope_size = 8;
4177            let bytes_len = len * envelope_size;
4178            let offset = decoder.out_of_line_offset(bytes_len)?;
4179            // Decode the envelope for each type.
4180            let mut _next_ordinal_to_read = 0;
4181            let mut next_offset = offset;
4182            let end_offset = offset + bytes_len;
4183            _next_ordinal_to_read += 1;
4184            if next_offset >= end_offset {
4185                return Ok(());
4186            }
4187
4188            // Decode unknown envelopes for gaps in ordinals.
4189            while _next_ordinal_to_read < 1 {
4190                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4191                _next_ordinal_to_read += 1;
4192                next_offset += envelope_size;
4193            }
4194
4195            let next_out_of_line = decoder.next_out_of_line();
4196            let handles_before = decoder.remaining_handles();
4197            if let Some((inlined, num_bytes, num_handles)) =
4198                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4199            {
4200                let member_inline_size = <fidl::encoding::UnboundedVector<
4201                    fidl::encoding::BoundedString<16>,
4202                > as fidl::encoding::TypeMarker>::inline_size(
4203                    decoder.context
4204                );
4205                if inlined != (member_inline_size <= 4) {
4206                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4207                }
4208                let inner_offset;
4209                let mut inner_depth = depth.clone();
4210                if inlined {
4211                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4212                    inner_offset = next_offset;
4213                } else {
4214                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4215                    inner_depth.increment()?;
4216                }
4217                let val_ref = self.iface_names.get_or_insert_with(|| {
4218                    fidl::new_empty!(
4219                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<16>>,
4220                        D
4221                    )
4222                });
4223                fidl::decode!(
4224                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<16>>,
4225                    D,
4226                    val_ref,
4227                    decoder,
4228                    inner_offset,
4229                    inner_depth
4230                )?;
4231                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4232                {
4233                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4234                }
4235                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4236                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4237                }
4238            }
4239
4240            next_offset += envelope_size;
4241
4242            // Decode the remaining unknown envelopes.
4243            while next_offset < end_offset {
4244                _next_ordinal_to_read += 1;
4245                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4246                next_offset += envelope_size;
4247            }
4248
4249            Ok(())
4250        }
4251    }
4252
4253    impl WifiStaIfaceGetNameResponse {
4254        #[inline(always)]
4255        fn max_ordinal_present(&self) -> u64 {
4256            if let Some(_) = self.iface_name {
4257                return 1;
4258            }
4259            0
4260        }
4261    }
4262
4263    impl fidl::encoding::ValueTypeMarker for WifiStaIfaceGetNameResponse {
4264        type Borrowed<'a> = &'a Self;
4265        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4266            value
4267        }
4268    }
4269
4270    unsafe impl fidl::encoding::TypeMarker for WifiStaIfaceGetNameResponse {
4271        type Owned = Self;
4272
4273        #[inline(always)]
4274        fn inline_align(_context: fidl::encoding::Context) -> usize {
4275            8
4276        }
4277
4278        #[inline(always)]
4279        fn inline_size(_context: fidl::encoding::Context) -> usize {
4280            16
4281        }
4282    }
4283
4284    unsafe impl<D: fidl::encoding::ResourceDialect>
4285        fidl::encoding::Encode<WifiStaIfaceGetNameResponse, D> for &WifiStaIfaceGetNameResponse
4286    {
4287        unsafe fn encode(
4288            self,
4289            encoder: &mut fidl::encoding::Encoder<'_, D>,
4290            offset: usize,
4291            mut depth: fidl::encoding::Depth,
4292        ) -> fidl::Result<()> {
4293            encoder.debug_check_bounds::<WifiStaIfaceGetNameResponse>(offset);
4294            // Vector header
4295            let max_ordinal: u64 = self.max_ordinal_present();
4296            encoder.write_num(max_ordinal, offset);
4297            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4298            // Calling encoder.out_of_line_offset(0) is not allowed.
4299            if max_ordinal == 0 {
4300                return Ok(());
4301            }
4302            depth.increment()?;
4303            let envelope_size = 8;
4304            let bytes_len = max_ordinal as usize * envelope_size;
4305            #[allow(unused_variables)]
4306            let offset = encoder.out_of_line_offset(bytes_len);
4307            let mut _prev_end_offset: usize = 0;
4308            if 1 > max_ordinal {
4309                return Ok(());
4310            }
4311
4312            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4313            // are envelope_size bytes.
4314            let cur_offset: usize = (1 - 1) * envelope_size;
4315
4316            // Zero reserved fields.
4317            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4318
4319            // Safety:
4320            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4321            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4322            //   envelope_size bytes, there is always sufficient room.
4323            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<16>, D>(
4324                self.iface_name.as_ref().map(
4325                    <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow,
4326                ),
4327                encoder,
4328                offset + cur_offset,
4329                depth,
4330            )?;
4331
4332            _prev_end_offset = cur_offset + envelope_size;
4333
4334            Ok(())
4335        }
4336    }
4337
4338    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4339        for WifiStaIfaceGetNameResponse
4340    {
4341        #[inline(always)]
4342        fn new_empty() -> Self {
4343            Self::default()
4344        }
4345
4346        unsafe fn decode(
4347            &mut self,
4348            decoder: &mut fidl::encoding::Decoder<'_, D>,
4349            offset: usize,
4350            mut depth: fidl::encoding::Depth,
4351        ) -> fidl::Result<()> {
4352            decoder.debug_check_bounds::<Self>(offset);
4353            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4354                None => return Err(fidl::Error::NotNullable),
4355                Some(len) => len,
4356            };
4357            // Calling decoder.out_of_line_offset(0) is not allowed.
4358            if len == 0 {
4359                return Ok(());
4360            };
4361            depth.increment()?;
4362            let envelope_size = 8;
4363            let bytes_len = len * envelope_size;
4364            let offset = decoder.out_of_line_offset(bytes_len)?;
4365            // Decode the envelope for each type.
4366            let mut _next_ordinal_to_read = 0;
4367            let mut next_offset = offset;
4368            let end_offset = offset + bytes_len;
4369            _next_ordinal_to_read += 1;
4370            if next_offset >= end_offset {
4371                return Ok(());
4372            }
4373
4374            // Decode unknown envelopes for gaps in ordinals.
4375            while _next_ordinal_to_read < 1 {
4376                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4377                _next_ordinal_to_read += 1;
4378                next_offset += envelope_size;
4379            }
4380
4381            let next_out_of_line = decoder.next_out_of_line();
4382            let handles_before = decoder.remaining_handles();
4383            if let Some((inlined, num_bytes, num_handles)) =
4384                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4385            {
4386                let member_inline_size =
4387                    <fidl::encoding::BoundedString<16> as fidl::encoding::TypeMarker>::inline_size(
4388                        decoder.context,
4389                    );
4390                if inlined != (member_inline_size <= 4) {
4391                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4392                }
4393                let inner_offset;
4394                let mut inner_depth = depth.clone();
4395                if inlined {
4396                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4397                    inner_offset = next_offset;
4398                } else {
4399                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4400                    inner_depth.increment()?;
4401                }
4402                let val_ref = self
4403                    .iface_name
4404                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<16>, D));
4405                fidl::decode!(
4406                    fidl::encoding::BoundedString<16>,
4407                    D,
4408                    val_ref,
4409                    decoder,
4410                    inner_offset,
4411                    inner_depth
4412                )?;
4413                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4414                {
4415                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4416                }
4417                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4418                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4419                }
4420            }
4421
4422            next_offset += envelope_size;
4423
4424            // Decode the remaining unknown envelopes.
4425            while next_offset < end_offset {
4426                _next_ordinal_to_read += 1;
4427                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4428                next_offset += envelope_size;
4429            }
4430
4431            Ok(())
4432        }
4433    }
4434
4435    impl WifiGetChipIdsResponse {
4436        #[inline(always)]
4437        fn max_ordinal_present(&self) -> u64 {
4438            if let Some(_) = self.chip_ids {
4439                return 1;
4440            }
4441            0
4442        }
4443    }
4444
4445    impl fidl::encoding::ValueTypeMarker for WifiGetChipIdsResponse {
4446        type Borrowed<'a> = &'a Self;
4447        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4448            value
4449        }
4450    }
4451
4452    unsafe impl fidl::encoding::TypeMarker for WifiGetChipIdsResponse {
4453        type Owned = Self;
4454
4455        #[inline(always)]
4456        fn inline_align(_context: fidl::encoding::Context) -> usize {
4457            8
4458        }
4459
4460        #[inline(always)]
4461        fn inline_size(_context: fidl::encoding::Context) -> usize {
4462            16
4463        }
4464    }
4465
4466    unsafe impl<D: fidl::encoding::ResourceDialect>
4467        fidl::encoding::Encode<WifiGetChipIdsResponse, D> for &WifiGetChipIdsResponse
4468    {
4469        unsafe fn encode(
4470            self,
4471            encoder: &mut fidl::encoding::Encoder<'_, D>,
4472            offset: usize,
4473            mut depth: fidl::encoding::Depth,
4474        ) -> fidl::Result<()> {
4475            encoder.debug_check_bounds::<WifiGetChipIdsResponse>(offset);
4476            // Vector header
4477            let max_ordinal: u64 = self.max_ordinal_present();
4478            encoder.write_num(max_ordinal, offset);
4479            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4480            // Calling encoder.out_of_line_offset(0) is not allowed.
4481            if max_ordinal == 0 {
4482                return Ok(());
4483            }
4484            depth.increment()?;
4485            let envelope_size = 8;
4486            let bytes_len = max_ordinal as usize * envelope_size;
4487            #[allow(unused_variables)]
4488            let offset = encoder.out_of_line_offset(bytes_len);
4489            let mut _prev_end_offset: usize = 0;
4490            if 1 > max_ordinal {
4491                return Ok(());
4492            }
4493
4494            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4495            // are envelope_size bytes.
4496            let cur_offset: usize = (1 - 1) * envelope_size;
4497
4498            // Zero reserved fields.
4499            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4500
4501            // Safety:
4502            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4503            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4504            //   envelope_size bytes, there is always sufficient room.
4505            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u32>, D>(
4506            self.chip_ids.as_ref().map(<fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow),
4507            encoder, offset + cur_offset, depth
4508        )?;
4509
4510            _prev_end_offset = cur_offset + envelope_size;
4511
4512            Ok(())
4513        }
4514    }
4515
4516    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4517        for WifiGetChipIdsResponse
4518    {
4519        #[inline(always)]
4520        fn new_empty() -> Self {
4521            Self::default()
4522        }
4523
4524        unsafe fn decode(
4525            &mut self,
4526            decoder: &mut fidl::encoding::Decoder<'_, D>,
4527            offset: usize,
4528            mut depth: fidl::encoding::Depth,
4529        ) -> fidl::Result<()> {
4530            decoder.debug_check_bounds::<Self>(offset);
4531            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4532                None => return Err(fidl::Error::NotNullable),
4533                Some(len) => len,
4534            };
4535            // Calling decoder.out_of_line_offset(0) is not allowed.
4536            if len == 0 {
4537                return Ok(());
4538            };
4539            depth.increment()?;
4540            let envelope_size = 8;
4541            let bytes_len = len * envelope_size;
4542            let offset = decoder.out_of_line_offset(bytes_len)?;
4543            // Decode the envelope for each type.
4544            let mut _next_ordinal_to_read = 0;
4545            let mut next_offset = offset;
4546            let end_offset = offset + bytes_len;
4547            _next_ordinal_to_read += 1;
4548            if next_offset >= end_offset {
4549                return Ok(());
4550            }
4551
4552            // Decode unknown envelopes for gaps in ordinals.
4553            while _next_ordinal_to_read < 1 {
4554                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4555                _next_ordinal_to_read += 1;
4556                next_offset += envelope_size;
4557            }
4558
4559            let next_out_of_line = decoder.next_out_of_line();
4560            let handles_before = decoder.remaining_handles();
4561            if let Some((inlined, num_bytes, num_handles)) =
4562                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4563            {
4564                let member_inline_size = <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4565                if inlined != (member_inline_size <= 4) {
4566                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4567                }
4568                let inner_offset;
4569                let mut inner_depth = depth.clone();
4570                if inlined {
4571                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4572                    inner_offset = next_offset;
4573                } else {
4574                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4575                    inner_depth.increment()?;
4576                }
4577                let val_ref = self.chip_ids.get_or_insert_with(|| {
4578                    fidl::new_empty!(fidl::encoding::UnboundedVector<u32>, D)
4579                });
4580                fidl::decode!(
4581                    fidl::encoding::UnboundedVector<u32>,
4582                    D,
4583                    val_ref,
4584                    decoder,
4585                    inner_offset,
4586                    inner_depth
4587                )?;
4588                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4589                {
4590                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4591                }
4592                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4593                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4594                }
4595            }
4596
4597            next_offset += envelope_size;
4598
4599            // Decode the remaining unknown envelopes.
4600            while next_offset < end_offset {
4601                _next_ordinal_to_read += 1;
4602                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4603                next_offset += envelope_size;
4604            }
4605
4606            Ok(())
4607        }
4608    }
4609
4610    impl WifiGetStateResponse {
4611        #[inline(always)]
4612        fn max_ordinal_present(&self) -> u64 {
4613            if let Some(_) = self.is_started {
4614                return 1;
4615            }
4616            0
4617        }
4618    }
4619
4620    impl fidl::encoding::ValueTypeMarker for WifiGetStateResponse {
4621        type Borrowed<'a> = &'a Self;
4622        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4623            value
4624        }
4625    }
4626
4627    unsafe impl fidl::encoding::TypeMarker for WifiGetStateResponse {
4628        type Owned = Self;
4629
4630        #[inline(always)]
4631        fn inline_align(_context: fidl::encoding::Context) -> usize {
4632            8
4633        }
4634
4635        #[inline(always)]
4636        fn inline_size(_context: fidl::encoding::Context) -> usize {
4637            16
4638        }
4639    }
4640
4641    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WifiGetStateResponse, D>
4642        for &WifiGetStateResponse
4643    {
4644        unsafe fn encode(
4645            self,
4646            encoder: &mut fidl::encoding::Encoder<'_, D>,
4647            offset: usize,
4648            mut depth: fidl::encoding::Depth,
4649        ) -> fidl::Result<()> {
4650            encoder.debug_check_bounds::<WifiGetStateResponse>(offset);
4651            // Vector header
4652            let max_ordinal: u64 = self.max_ordinal_present();
4653            encoder.write_num(max_ordinal, offset);
4654            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4655            // Calling encoder.out_of_line_offset(0) is not allowed.
4656            if max_ordinal == 0 {
4657                return Ok(());
4658            }
4659            depth.increment()?;
4660            let envelope_size = 8;
4661            let bytes_len = max_ordinal as usize * envelope_size;
4662            #[allow(unused_variables)]
4663            let offset = encoder.out_of_line_offset(bytes_len);
4664            let mut _prev_end_offset: usize = 0;
4665            if 1 > max_ordinal {
4666                return Ok(());
4667            }
4668
4669            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4670            // are envelope_size bytes.
4671            let cur_offset: usize = (1 - 1) * envelope_size;
4672
4673            // Zero reserved fields.
4674            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4675
4676            // Safety:
4677            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4678            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4679            //   envelope_size bytes, there is always sufficient room.
4680            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4681                self.is_started.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4682                encoder,
4683                offset + cur_offset,
4684                depth,
4685            )?;
4686
4687            _prev_end_offset = cur_offset + envelope_size;
4688
4689            Ok(())
4690        }
4691    }
4692
4693    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WifiGetStateResponse {
4694        #[inline(always)]
4695        fn new_empty() -> Self {
4696            Self::default()
4697        }
4698
4699        unsafe fn decode(
4700            &mut self,
4701            decoder: &mut fidl::encoding::Decoder<'_, D>,
4702            offset: usize,
4703            mut depth: fidl::encoding::Depth,
4704        ) -> fidl::Result<()> {
4705            decoder.debug_check_bounds::<Self>(offset);
4706            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4707                None => return Err(fidl::Error::NotNullable),
4708                Some(len) => len,
4709            };
4710            // Calling decoder.out_of_line_offset(0) is not allowed.
4711            if len == 0 {
4712                return Ok(());
4713            };
4714            depth.increment()?;
4715            let envelope_size = 8;
4716            let bytes_len = len * envelope_size;
4717            let offset = decoder.out_of_line_offset(bytes_len)?;
4718            // Decode the envelope for each type.
4719            let mut _next_ordinal_to_read = 0;
4720            let mut next_offset = offset;
4721            let end_offset = offset + bytes_len;
4722            _next_ordinal_to_read += 1;
4723            if next_offset >= end_offset {
4724                return Ok(());
4725            }
4726
4727            // Decode unknown envelopes for gaps in ordinals.
4728            while _next_ordinal_to_read < 1 {
4729                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4730                _next_ordinal_to_read += 1;
4731                next_offset += envelope_size;
4732            }
4733
4734            let next_out_of_line = decoder.next_out_of_line();
4735            let handles_before = decoder.remaining_handles();
4736            if let Some((inlined, num_bytes, num_handles)) =
4737                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4738            {
4739                let member_inline_size =
4740                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4741                if inlined != (member_inline_size <= 4) {
4742                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4743                }
4744                let inner_offset;
4745                let mut inner_depth = depth.clone();
4746                if inlined {
4747                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4748                    inner_offset = next_offset;
4749                } else {
4750                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4751                    inner_depth.increment()?;
4752                }
4753                let val_ref = self.is_started.get_or_insert_with(|| fidl::new_empty!(bool, D));
4754                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4755                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4756                {
4757                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4758                }
4759                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4760                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4761                }
4762            }
4763
4764            next_offset += envelope_size;
4765
4766            // Decode the remaining unknown envelopes.
4767            while next_offset < end_offset {
4768                _next_ordinal_to_read += 1;
4769                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4770                next_offset += envelope_size;
4771            }
4772
4773            Ok(())
4774        }
4775    }
4776}