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