fidl_fuchsia_wlan_fullmac__common/
fidl_fuchsia_wlan_fullmac__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub const WLAN_MAX_KEYLIST_SIZE: u32 = 4;
12
13/// Max length for vendor IEs to be added to the association request. This is currently
14/// used for WPA.
15pub const WLAN_VIE_MAX_LEN: u32 = 514;
16
17#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
18pub enum EapolTxResult {
19    Success,
20    TransmissionFailure,
21    #[doc(hidden)]
22    __SourceBreaking {
23        unknown_ordinal: u8,
24    },
25}
26
27/// Pattern that matches an unknown `EapolTxResult` member.
28#[macro_export]
29macro_rules! EapolTxResultUnknown {
30    () => {
31        _
32    };
33}
34
35impl EapolTxResult {
36    #[inline]
37    pub fn from_primitive(prim: u8) -> Option<Self> {
38        match prim {
39            0 => Some(Self::Success),
40            1 => Some(Self::TransmissionFailure),
41            _ => None,
42        }
43    }
44
45    #[inline]
46    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
47        match prim {
48            0 => Self::Success,
49            1 => Self::TransmissionFailure,
50            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
51        }
52    }
53
54    #[inline]
55    pub fn unknown() -> Self {
56        Self::__SourceBreaking { unknown_ordinal: 0xff }
57    }
58
59    #[inline]
60    pub const fn into_primitive(self) -> u8 {
61        match self {
62            Self::Success => 0,
63            Self::TransmissionFailure => 1,
64            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
65        }
66    }
67
68    #[inline]
69    pub fn is_unknown(&self) -> bool {
70        match self {
71            Self::__SourceBreaking { unknown_ordinal: _ } => true,
72            _ => false,
73        }
74    }
75}
76
77#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
78pub enum StartResult {
79    Success,
80    BssAlreadyStartedOrJoined,
81    ResetRequiredBeforeStart,
82    NotSupported,
83    #[doc(hidden)]
84    __SourceBreaking {
85        unknown_ordinal: u8,
86    },
87}
88
89/// Pattern that matches an unknown `StartResult` member.
90#[macro_export]
91macro_rules! StartResultUnknown {
92    () => {
93        _
94    };
95}
96
97impl StartResult {
98    #[inline]
99    pub fn from_primitive(prim: u8) -> Option<Self> {
100        match prim {
101            0 => Some(Self::Success),
102            1 => Some(Self::BssAlreadyStartedOrJoined),
103            2 => Some(Self::ResetRequiredBeforeStart),
104            3 => Some(Self::NotSupported),
105            _ => None,
106        }
107    }
108
109    #[inline]
110    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
111        match prim {
112            0 => Self::Success,
113            1 => Self::BssAlreadyStartedOrJoined,
114            2 => Self::ResetRequiredBeforeStart,
115            3 => Self::NotSupported,
116            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
117        }
118    }
119
120    #[inline]
121    pub fn unknown() -> Self {
122        Self::__SourceBreaking { unknown_ordinal: 0xff }
123    }
124
125    #[inline]
126    pub const fn into_primitive(self) -> u8 {
127        match self {
128            Self::Success => 0,
129            Self::BssAlreadyStartedOrJoined => 1,
130            Self::ResetRequiredBeforeStart => 2,
131            Self::NotSupported => 3,
132            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
133        }
134    }
135
136    #[inline]
137    pub fn is_unknown(&self) -> bool {
138        match self {
139            Self::__SourceBreaking { unknown_ordinal: _ } => true,
140            _ => false,
141        }
142    }
143}
144
145#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
146pub enum StopResult {
147    Success,
148    BssAlreadyStopped,
149    InternalError,
150    #[doc(hidden)]
151    __SourceBreaking {
152        unknown_ordinal: u8,
153    },
154}
155
156/// Pattern that matches an unknown `StopResult` member.
157#[macro_export]
158macro_rules! StopResultUnknown {
159    () => {
160        _
161    };
162}
163
164impl StopResult {
165    #[inline]
166    pub fn from_primitive(prim: u8) -> Option<Self> {
167        match prim {
168            0 => Some(Self::Success),
169            1 => Some(Self::BssAlreadyStopped),
170            2 => Some(Self::InternalError),
171            _ => None,
172        }
173    }
174
175    #[inline]
176    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
177        match prim {
178            0 => Self::Success,
179            1 => Self::BssAlreadyStopped,
180            2 => Self::InternalError,
181            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
182        }
183    }
184
185    #[inline]
186    pub fn unknown() -> Self {
187        Self::__SourceBreaking { unknown_ordinal: 0xff }
188    }
189
190    #[inline]
191    pub const fn into_primitive(self) -> u8 {
192        match self {
193            Self::Success => 0,
194            Self::BssAlreadyStopped => 1,
195            Self::InternalError => 2,
196            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
197        }
198    }
199
200    #[inline]
201    pub fn is_unknown(&self) -> bool {
202        match self {
203            Self::__SourceBreaking { unknown_ordinal: _ } => true,
204            _ => false,
205        }
206    }
207}
208
209#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
210pub enum WlanAssocResult {
211    Success,
212    RefusedReasonUnspecified,
213    RefusedNotAuthenticated,
214    RefusedCapabilitiesMismatch,
215    RefusedExternalReason,
216    RefusedApOutOfMemory,
217    RefusedBasicRatesMismatch,
218    RejectedEmergencyServicesNotSupported,
219    RefusedTemporarily,
220    #[doc(hidden)]
221    __SourceBreaking {
222        unknown_ordinal: u8,
223    },
224}
225
226/// Pattern that matches an unknown `WlanAssocResult` member.
227#[macro_export]
228macro_rules! WlanAssocResultUnknown {
229    () => {
230        _
231    };
232}
233
234impl WlanAssocResult {
235    #[inline]
236    pub fn from_primitive(prim: u8) -> Option<Self> {
237        match prim {
238            0 => Some(Self::Success),
239            1 => Some(Self::RefusedReasonUnspecified),
240            2 => Some(Self::RefusedNotAuthenticated),
241            3 => Some(Self::RefusedCapabilitiesMismatch),
242            4 => Some(Self::RefusedExternalReason),
243            5 => Some(Self::RefusedApOutOfMemory),
244            6 => Some(Self::RefusedBasicRatesMismatch),
245            7 => Some(Self::RejectedEmergencyServicesNotSupported),
246            8 => Some(Self::RefusedTemporarily),
247            _ => None,
248        }
249    }
250
251    #[inline]
252    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
253        match prim {
254            0 => Self::Success,
255            1 => Self::RefusedReasonUnspecified,
256            2 => Self::RefusedNotAuthenticated,
257            3 => Self::RefusedCapabilitiesMismatch,
258            4 => Self::RefusedExternalReason,
259            5 => Self::RefusedApOutOfMemory,
260            6 => Self::RefusedBasicRatesMismatch,
261            7 => Self::RejectedEmergencyServicesNotSupported,
262            8 => Self::RefusedTemporarily,
263            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
264        }
265    }
266
267    #[inline]
268    pub fn unknown() -> Self {
269        Self::__SourceBreaking { unknown_ordinal: 0xff }
270    }
271
272    #[inline]
273    pub const fn into_primitive(self) -> u8 {
274        match self {
275            Self::Success => 0,
276            Self::RefusedReasonUnspecified => 1,
277            Self::RefusedNotAuthenticated => 2,
278            Self::RefusedCapabilitiesMismatch => 3,
279            Self::RefusedExternalReason => 4,
280            Self::RefusedApOutOfMemory => 5,
281            Self::RefusedBasicRatesMismatch => 6,
282            Self::RejectedEmergencyServicesNotSupported => 7,
283            Self::RefusedTemporarily => 8,
284            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
285        }
286    }
287
288    #[inline]
289    pub fn is_unknown(&self) -> bool {
290        match self {
291            Self::__SourceBreaking { unknown_ordinal: _ } => true,
292            _ => false,
293        }
294    }
295}
296
297#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
298pub enum WlanAuthResult {
299    Success,
300    Refused,
301    AntiCloggingTokenRequired,
302    FiniteCyclicGroupNotSupported,
303    Rejected,
304    FailureTimeout,
305    #[doc(hidden)]
306    __SourceBreaking {
307        unknown_ordinal: u8,
308    },
309}
310
311/// Pattern that matches an unknown `WlanAuthResult` member.
312#[macro_export]
313macro_rules! WlanAuthResultUnknown {
314    () => {
315        _
316    };
317}
318
319impl WlanAuthResult {
320    #[inline]
321    pub fn from_primitive(prim: u8) -> Option<Self> {
322        match prim {
323            0 => Some(Self::Success),
324            1 => Some(Self::Refused),
325            2 => Some(Self::AntiCloggingTokenRequired),
326            3 => Some(Self::FiniteCyclicGroupNotSupported),
327            4 => Some(Self::Rejected),
328            5 => Some(Self::FailureTimeout),
329            _ => None,
330        }
331    }
332
333    #[inline]
334    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
335        match prim {
336            0 => Self::Success,
337            1 => Self::Refused,
338            2 => Self::AntiCloggingTokenRequired,
339            3 => Self::FiniteCyclicGroupNotSupported,
340            4 => Self::Rejected,
341            5 => Self::FailureTimeout,
342            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
343        }
344    }
345
346    #[inline]
347    pub fn unknown() -> Self {
348        Self::__SourceBreaking { unknown_ordinal: 0xff }
349    }
350
351    #[inline]
352    pub const fn into_primitive(self) -> u8 {
353        match self {
354            Self::Success => 0,
355            Self::Refused => 1,
356            Self::AntiCloggingTokenRequired => 2,
357            Self::FiniteCyclicGroupNotSupported => 3,
358            Self::Rejected => 4,
359            Self::FailureTimeout => 5,
360            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
361        }
362    }
363
364    #[inline]
365    pub fn is_unknown(&self) -> bool {
366        match self {
367            Self::__SourceBreaking { unknown_ordinal: _ } => true,
368            _ => false,
369        }
370    }
371}
372
373#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
374pub enum WlanAuthType {
375    OpenSystem,
376    SharedKey,
377    FastBssTransition,
378    Sae,
379    #[doc(hidden)]
380    __SourceBreaking {
381        unknown_ordinal: u8,
382    },
383}
384
385/// Pattern that matches an unknown `WlanAuthType` member.
386#[macro_export]
387macro_rules! WlanAuthTypeUnknown {
388    () => {
389        _
390    };
391}
392
393impl WlanAuthType {
394    #[inline]
395    pub fn from_primitive(prim: u8) -> Option<Self> {
396        match prim {
397            1 => Some(Self::OpenSystem),
398            2 => Some(Self::SharedKey),
399            3 => Some(Self::FastBssTransition),
400            4 => Some(Self::Sae),
401            _ => None,
402        }
403    }
404
405    #[inline]
406    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
407        match prim {
408            1 => Self::OpenSystem,
409            2 => Self::SharedKey,
410            3 => Self::FastBssTransition,
411            4 => Self::Sae,
412            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
413        }
414    }
415
416    #[inline]
417    pub fn unknown() -> Self {
418        Self::__SourceBreaking { unknown_ordinal: 0xff }
419    }
420
421    #[inline]
422    pub const fn into_primitive(self) -> u8 {
423        match self {
424            Self::OpenSystem => 1,
425            Self::SharedKey => 2,
426            Self::FastBssTransition => 3,
427            Self::Sae => 4,
428            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
429        }
430    }
431
432    #[inline]
433    pub fn is_unknown(&self) -> bool {
434        match self {
435            Self::__SourceBreaking { unknown_ordinal: _ } => true,
436            _ => false,
437        }
438    }
439}
440
441#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
442pub enum WlanScanResult {
443    Success,
444    NotSupported,
445    InvalidArgs,
446    InternalError,
447    ShouldWait,
448    CanceledByDriverOrFirmware,
449    #[doc(hidden)]
450    __SourceBreaking {
451        unknown_ordinal: u8,
452    },
453}
454
455/// Pattern that matches an unknown `WlanScanResult` member.
456#[macro_export]
457macro_rules! WlanScanResultUnknown {
458    () => {
459        _
460    };
461}
462
463impl WlanScanResult {
464    #[inline]
465    pub fn from_primitive(prim: u8) -> Option<Self> {
466        match prim {
467            0 => Some(Self::Success),
468            1 => Some(Self::NotSupported),
469            2 => Some(Self::InvalidArgs),
470            3 => Some(Self::InternalError),
471            4 => Some(Self::ShouldWait),
472            5 => Some(Self::CanceledByDriverOrFirmware),
473            _ => None,
474        }
475    }
476
477    #[inline]
478    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
479        match prim {
480            0 => Self::Success,
481            1 => Self::NotSupported,
482            2 => Self::InvalidArgs,
483            3 => Self::InternalError,
484            4 => Self::ShouldWait,
485            5 => Self::CanceledByDriverOrFirmware,
486            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
487        }
488    }
489
490    #[inline]
491    pub fn unknown() -> Self {
492        Self::__SourceBreaking { unknown_ordinal: 0xff }
493    }
494
495    #[inline]
496    pub const fn into_primitive(self) -> u8 {
497        match self {
498            Self::Success => 0,
499            Self::NotSupported => 1,
500            Self::InvalidArgs => 2,
501            Self::InternalError => 3,
502            Self::ShouldWait => 4,
503            Self::CanceledByDriverOrFirmware => 5,
504            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
505        }
506    }
507
508    #[inline]
509    pub fn is_unknown(&self) -> bool {
510        match self {
511            Self::__SourceBreaking { unknown_ordinal: _ } => true,
512            _ => false,
513        }
514    }
515}
516
517#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
518pub enum WlanScanType {
519    Active,
520    Passive,
521    #[doc(hidden)]
522    __SourceBreaking {
523        unknown_ordinal: u8,
524    },
525}
526
527/// Pattern that matches an unknown `WlanScanType` member.
528#[macro_export]
529macro_rules! WlanScanTypeUnknown {
530    () => {
531        _
532    };
533}
534
535impl WlanScanType {
536    #[inline]
537    pub fn from_primitive(prim: u8) -> Option<Self> {
538        match prim {
539            1 => Some(Self::Active),
540            2 => Some(Self::Passive),
541            _ => None,
542        }
543    }
544
545    #[inline]
546    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
547        match prim {
548            1 => Self::Active,
549            2 => Self::Passive,
550            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
551        }
552    }
553
554    #[inline]
555    pub fn unknown() -> Self {
556        Self::__SourceBreaking { unknown_ordinal: 0xff }
557    }
558
559    #[inline]
560    pub const fn into_primitive(self) -> u8 {
561        match self {
562            Self::Active => 1,
563            Self::Passive => 2,
564            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
565        }
566    }
567
568    #[inline]
569    pub fn is_unknown(&self) -> bool {
570        match self {
571            Self::__SourceBreaking { unknown_ordinal: _ } => true,
572            _ => false,
573        }
574    }
575}
576
577#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
578#[repr(C)]
579pub struct WlanFullmacChannelSwitchInfo {
580    pub new_channel: u8,
581}
582
583impl fidl::Persistable for WlanFullmacChannelSwitchInfo {}
584
585#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
586#[repr(C)]
587pub struct WlanFullmacImplIfcOnChannelSwitchRequest {
588    pub ind: WlanFullmacChannelSwitchInfo,
589}
590
591impl fidl::Persistable for WlanFullmacImplIfcOnChannelSwitchRequest {}
592
593#[derive(Clone, Debug, PartialEq)]
594pub struct WlanFullmacImplIfcOnWmmStatusRespRequest {
595    pub status: i32,
596    pub wmm_params: fidl_fuchsia_wlan_common__common::WlanWmmParameters,
597}
598
599impl fidl::Persistable for WlanFullmacImplIfcOnWmmStatusRespRequest {}
600
601#[derive(Clone, Debug, PartialEq)]
602pub struct WlanFullmacImplIfcSaeFrameRxRequest {
603    pub frame: SaeFrame,
604}
605
606impl fidl::Persistable for WlanFullmacImplIfcSaeFrameRxRequest {}
607
608#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
609#[repr(C)]
610pub struct WlanFullmacImplIfcSignalReportRequest {
611    pub ind: WlanFullmacSignalReportIndication,
612}
613
614impl fidl::Persistable for WlanFullmacImplIfcSignalReportRequest {}
615
616#[derive(Clone, Debug, PartialEq)]
617pub struct WlanFullmacImplSaeFrameTxRequest {
618    pub frame: SaeFrame,
619}
620
621impl fidl::Persistable for WlanFullmacImplSaeFrameTxRequest {}
622
623#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
624pub struct WlanFullmacImplSetKeysResponse {
625    pub resp: WlanFullmacSetKeysResp,
626}
627
628impl fidl::Persistable for WlanFullmacImplSetKeysResponse {}
629
630#[derive(Clone, Debug, PartialEq)]
631pub struct WlanFullmacImplGetIfaceHistogramStatsResponse {
632    pub stats: fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
633}
634
635impl fidl::Persistable for WlanFullmacImplGetIfaceHistogramStatsResponse {}
636
637#[derive(Clone, Debug, PartialEq)]
638pub struct WlanFullmacImplGetIfaceStatsResponse {
639    pub stats: fidl_fuchsia_wlan_stats__common::IfaceStats,
640}
641
642impl fidl::Persistable for WlanFullmacImplGetIfaceStatsResponse {}
643
644#[derive(Clone, Debug, PartialEq)]
645pub struct WlanFullmacImplQuerySecuritySupportResponse {
646    pub resp: fidl_fuchsia_wlan_common__common::SecuritySupport,
647}
648
649impl fidl::Persistable for WlanFullmacImplQuerySecuritySupportResponse {}
650
651#[derive(Clone, Debug, PartialEq)]
652pub struct WlanFullmacImplQuerySpectrumManagementSupportResponse {
653    pub resp: fidl_fuchsia_wlan_common__common::SpectrumManagementSupport,
654}
655
656impl fidl::Persistable for WlanFullmacImplQuerySpectrumManagementSupportResponse {}
657
658#[derive(Clone, Debug, PartialEq)]
659pub struct WlanFullmacImplQueryTelemetrySupportResponse {
660    pub resp: fidl_fuchsia_wlan_stats__common::TelemetrySupport,
661}
662
663impl fidl::Persistable for WlanFullmacImplQueryTelemetrySupportResponse {}
664
665#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
666pub struct WlanFullmacRssiStats {
667    pub hist: Vec<u64>,
668}
669
670impl fidl::Persistable for WlanFullmacRssiStats {}
671
672#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
673pub struct WlanFullmacSetKeysResp {
674    pub statuslist: Vec<i32>,
675}
676
677impl fidl::Persistable for WlanFullmacSetKeysResp {}
678
679#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
680#[repr(C)]
681pub struct WlanFullmacSignalReportIndication {
682    pub rssi_dbm: i8,
683    pub snr_db: i8,
684}
685
686impl fidl::Persistable for WlanFullmacSignalReportIndication {}
687
688/// Describes parameters and capabilities for a single WlanBand.
689#[derive(Clone, Debug, Default, PartialEq)]
690pub struct BandCapability {
691    /// The values of this table apply to the band indicated in this field.
692    ///
693    /// Required.
694    pub band: Option<fidl_fuchsia_wlan_ieee80211__common::WlanBand>,
695    /// Basic rates supported in units of 500 kbit/s (as defined in
696    /// IEEE Std 802.11-2016, 9.4.2.3), e.g., 0x02 represents 1 Mbps.
697    /// The value returned by this type indicates all the non-HT rates
698    /// the device supports transmitting and receiving.
699    ///
700    /// Required.
701    pub basic_rates: Option<Vec<u8>>,
702    /// HT PHY mode capabilities.
703    ///
704    /// Optional. If this field is not present, then the device does not support HT PHY mode in this
705    /// band.
706    pub ht_caps: Option<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>,
707    /// VHT PHY mode capabilities.
708    ///
709    /// Optional. If this field is not present, then the device does not support VHT PHY mode in
710    /// this band.
711    pub vht_caps: Option<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>,
712    /// A list of operating channels considered valid by hardware, in the context of
713    /// regulatory information known to the device driver, at the time of its
714    /// construction during iface creation. In this context, an operating channel
715    /// means a channel which APs may transmit Beacon frames on in the current
716    /// regulatory domain.
717    ///
718    /// This list should be used to determine efficacy of subsequent requests to
719    /// scan a subset of channels using the iface, or to determine which operating
720    /// channel to use when starting an AP.
721    ///
722    /// Required.
723    pub operating_channels: Option<Vec<u8>>,
724    #[doc(hidden)]
725    pub __source_breaking: fidl::marker::SourceBreaking,
726}
727
728impl fidl::Persistable for BandCapability {}
729
730/// Contains the information of SAE authentication frames. Shared between transmit and receive
731/// directions, see WlanFullmacImplIfc::SaeFrameRx and WlanFullmacImpl::SaeFrameTx.
732#[derive(Clone, Debug, Default, PartialEq)]
733pub struct SaeFrame {
734    /// The peer's MAC address. Required.
735    pub peer_sta_address: Option<[u8; 6]>,
736    /// The status code for this SAE frame. Required.
737    pub status_code: Option<fidl_fuchsia_wlan_ieee80211__common::StatusCode>,
738    /// The sequence number. Required.
739    pub seq_num: Option<u16>,
740    /// Contains fields in the frame body relevant to SAE.
741    /// See IEEE Std 802.11-2016 table 9-35 and table 9-36 for more details.
742    /// Required.
743    pub sae_fields: Option<Vec<u8>>,
744    #[doc(hidden)]
745    pub __source_breaking: fidl::marker::SourceBreaking,
746}
747
748impl fidl::Persistable for SaeFrame {}
749
750#[derive(Clone, Debug, Default, PartialEq)]
751pub struct WlanFullmacImplAssocRespRequest {
752    pub peer_sta_address: Option<[u8; 6]>,
753    pub result_code: Option<WlanAssocResult>,
754    pub association_id: Option<u16>,
755    #[doc(hidden)]
756    pub __source_breaking: fidl::marker::SourceBreaking,
757}
758
759impl fidl::Persistable for WlanFullmacImplAssocRespRequest {}
760
761#[derive(Clone, Debug, Default, PartialEq)]
762pub struct WlanFullmacImplAuthRespRequest {
763    pub peer_sta_address: Option<[u8; 6]>,
764    pub result_code: Option<WlanAuthResult>,
765    #[doc(hidden)]
766    pub __source_breaking: fidl::marker::SourceBreaking,
767}
768
769impl fidl::Persistable for WlanFullmacImplAuthRespRequest {}
770
771#[derive(Clone, Debug, Default, PartialEq)]
772pub struct WlanFullmacImplConnectRequest {
773    pub selected_bss: Option<fidl_fuchsia_wlan_common__common::BssDescription>,
774    /// Timeout specified in beacon interval.
775    pub connect_failure_timeout: Option<u32>,
776    /// Additional parameters specific to the authentication exchange.
777    pub auth_type: Option<WlanAuthType>,
778    /// sae_password is ignored except when SAE_DRIVER_AUTH is enabled and the
779    /// auth_type is SAE.
780    pub sae_password: Option<Vec<u8>>,
781    /// WEP key used in the authentication exchange.
782    /// This is only populated for the WEP security type, otherwise this field is empty.
783    pub wep_key: Option<fidl_fuchsia_wlan_common__common::WlanKeyConfig>,
784    /// Additional parameters specific to the association exchange.
785    pub security_ie: Option<Vec<u8>>,
786    /// WEP key used in the authentication exchange.
787    /// This is only populated for the WEP security type, otherwise this field is empty.
788    pub wep_key_desc: Option<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor>,
789    #[doc(hidden)]
790    pub __source_breaking: fidl::marker::SourceBreaking,
791}
792
793impl fidl::Persistable for WlanFullmacImplConnectRequest {}
794
795#[derive(Clone, Debug, Default, PartialEq)]
796pub struct WlanFullmacImplDeauthRequest {
797    pub peer_sta_address: Option<[u8; 6]>,
798    pub reason_code: Option<fidl_fuchsia_wlan_ieee80211__common::ReasonCode>,
799    #[doc(hidden)]
800    pub __source_breaking: fidl::marker::SourceBreaking,
801}
802
803impl fidl::Persistable for WlanFullmacImplDeauthRequest {}
804
805#[derive(Clone, Debug, Default, PartialEq)]
806pub struct WlanFullmacImplDisassocRequest {
807    pub peer_sta_address: Option<[u8; 6]>,
808    pub reason_code: Option<fidl_fuchsia_wlan_ieee80211__common::ReasonCode>,
809    #[doc(hidden)]
810    pub __source_breaking: fidl::marker::SourceBreaking,
811}
812
813impl fidl::Persistable for WlanFullmacImplDisassocRequest {}
814
815#[derive(Clone, Debug, Default, PartialEq)]
816pub struct WlanFullmacImplEapolTxRequest {
817    pub src_addr: Option<[u8; 6]>,
818    pub dst_addr: Option<[u8; 6]>,
819    pub data: Option<Vec<u8>>,
820    #[doc(hidden)]
821    pub __source_breaking: fidl::marker::SourceBreaking,
822}
823
824impl fidl::Persistable for WlanFullmacImplEapolTxRequest {}
825
826#[derive(Clone, Debug, Default, PartialEq)]
827pub struct WlanFullmacImplIfcAssocIndRequest {
828    pub peer_sta_address: Option<[u8; 6]>,
829    pub listen_interval: Option<u16>,
830    pub ssid: Option<Vec<u8>>,
831    pub rsne: Option<Vec<u8>>,
832    pub vendor_ie: Option<Vec<u8>>,
833    #[doc(hidden)]
834    pub __source_breaking: fidl::marker::SourceBreaking,
835}
836
837impl fidl::Persistable for WlanFullmacImplIfcAssocIndRequest {}
838
839#[derive(Clone, Debug, Default, PartialEq)]
840pub struct WlanFullmacImplIfcAuthIndRequest {
841    pub peer_sta_address: Option<[u8; 6]>,
842    pub auth_type: Option<WlanAuthType>,
843    #[doc(hidden)]
844    pub __source_breaking: fidl::marker::SourceBreaking,
845}
846
847impl fidl::Persistable for WlanFullmacImplIfcAuthIndRequest {}
848
849#[derive(Clone, Debug, Default, PartialEq)]
850pub struct WlanFullmacImplIfcConnectConfRequest {
851    pub peer_sta_address: Option<[u8; 6]>,
852    pub result_code: Option<fidl_fuchsia_wlan_ieee80211__common::StatusCode>,
853    pub association_id: Option<u16>,
854    pub association_ies: Option<Vec<u8>>,
855    #[doc(hidden)]
856    pub __source_breaking: fidl::marker::SourceBreaking,
857}
858
859impl fidl::Persistable for WlanFullmacImplIfcConnectConfRequest {}
860
861#[derive(Clone, Debug, Default, PartialEq)]
862pub struct WlanFullmacImplIfcDeauthConfRequest {
863    pub peer_sta_address: Option<[u8; 6]>,
864    #[doc(hidden)]
865    pub __source_breaking: fidl::marker::SourceBreaking,
866}
867
868impl fidl::Persistable for WlanFullmacImplIfcDeauthConfRequest {}
869
870#[derive(Clone, Debug, Default, PartialEq)]
871pub struct WlanFullmacImplIfcDeauthIndRequest {
872    /// MAC address of the peer. Required.
873    pub peer_sta_address: Option<[u8; 6]>,
874    /// Reason code for deauthentication. Required.
875    pub reason_code: Option<fidl_fuchsia_wlan_ieee80211__common::ReasonCode>,
876    /// locally_initiated is true if deauth is initiated from the device,
877    /// and is false if it's initiated remotely (e.g. due to deauth frame)
878    pub locally_initiated: Option<bool>,
879    #[doc(hidden)]
880    pub __source_breaking: fidl::marker::SourceBreaking,
881}
882
883impl fidl::Persistable for WlanFullmacImplIfcDeauthIndRequest {}
884
885#[derive(Clone, Debug, Default, PartialEq)]
886pub struct WlanFullmacImplIfcDisassocConfRequest {
887    /// ZX_OK indicates that the disassociate request was serviced and the peer was
888    /// disassociated. Other errors indicate that the request could not be serviced, for these
889    /// or other reasons:
890    ///   - ZX_ERR_BAD_STATE: association not possible in current state (e.g. disconnected)
891    ///   - ZX_ERR_INVALID_ARGS: no association exists with specified peer
892    ///   - ZX_ERR_SHOULD_WAIT: disassociate request could not be serviced because firmware or
893    ///     driver was busy
894    pub status: Option<i32>,
895    #[doc(hidden)]
896    pub __source_breaking: fidl::marker::SourceBreaking,
897}
898
899impl fidl::Persistable for WlanFullmacImplIfcDisassocConfRequest {}
900
901#[derive(Clone, Debug, Default, PartialEq)]
902pub struct WlanFullmacImplIfcDisassocIndRequest {
903    /// Address of the peer that was disassociated. Required.
904    pub peer_sta_address: Option<[u8; 6]>,
905    /// Reason for the disassociation. Required.
906    pub reason_code: Option<fidl_fuchsia_wlan_ieee80211__common::ReasonCode>,
907    /// Whether the disassociation was initiated from the device. Required.
908    /// locally_initiated is true if disassociation was initiated from the device (e.g. firmware
909    /// or vendor driver started the disassociation); false if the disassociation was initiated
910    /// externally (e.g. due to receipt of a disassociate frame from an AP).
911    pub locally_initiated: Option<bool>,
912    #[doc(hidden)]
913    pub __source_breaking: fidl::marker::SourceBreaking,
914}
915
916impl fidl::Persistable for WlanFullmacImplIfcDisassocIndRequest {}
917
918#[derive(Clone, Debug, Default, PartialEq)]
919pub struct WlanFullmacImplIfcEapolConfRequest {
920    /// The result of the transmission. Required.
921    pub result_code: Option<EapolTxResult>,
922    /// This value corresponds to the dst_addr in the EapolTxRequest we're confirming.
923    /// IEEE 802.11-2020 does not include this field, but we need it to disambiguate
924    /// if multiple EAPoL handshakes are ongoing.
925    /// Required.
926    pub dst_addr: Option<[u8; 6]>,
927    #[doc(hidden)]
928    pub __source_breaking: fidl::marker::SourceBreaking,
929}
930
931impl fidl::Persistable for WlanFullmacImplIfcEapolConfRequest {}
932
933#[derive(Clone, Debug, Default, PartialEq)]
934pub struct WlanFullmacImplIfcEapolIndRequest {
935    /// The address of the sender. Required.
936    pub src_addr: Option<[u8; 6]>,
937    /// The address of the intended destination. Required.
938    pub dst_addr: Option<[u8; 6]>,
939    /// The bytes of the EAPoL frame data. Required.
940    pub data: Option<Vec<u8>>,
941    #[doc(hidden)]
942    pub __source_breaking: fidl::marker::SourceBreaking,
943}
944
945impl fidl::Persistable for WlanFullmacImplIfcEapolIndRequest {}
946
947#[derive(Clone, Debug, Default, PartialEq)]
948pub struct WlanFullmacImplIfcOnPmkAvailableRequest {
949    /// The pairwise master key bytes. Required.
950    pub pmk: Option<Vec<u8>>,
951    /// The PMK IDs. Required.
952    pub pmkid: Option<Vec<u8>>,
953    #[doc(hidden)]
954    pub __source_breaking: fidl::marker::SourceBreaking,
955}
956
957impl fidl::Persistable for WlanFullmacImplIfcOnPmkAvailableRequest {}
958
959#[derive(Clone, Debug, Default, PartialEq)]
960pub struct WlanFullmacImplIfcOnScanEndRequest {
961    pub txn_id: Option<u64>,
962    pub code: Option<WlanScanResult>,
963    #[doc(hidden)]
964    pub __source_breaking: fidl::marker::SourceBreaking,
965}
966
967impl fidl::Persistable for WlanFullmacImplIfcOnScanEndRequest {}
968
969#[derive(Clone, Debug, Default, PartialEq)]
970pub struct WlanFullmacImplIfcOnScanResultRequest {
971    pub txn_id: Option<u64>,
972    pub timestamp_nanos: Option<i64>,
973    pub bss: Option<fidl_fuchsia_wlan_common__common::BssDescription>,
974    #[doc(hidden)]
975    pub __source_breaking: fidl::marker::SourceBreaking,
976}
977
978impl fidl::Persistable for WlanFullmacImplIfcOnScanResultRequest {}
979
980#[derive(Clone, Debug, Default, PartialEq)]
981pub struct WlanFullmacImplIfcRoamConfRequest {
982    /// BSSID of the target BSS. Required.
983    pub selected_bssid: Option<[u8; 6]>,
984    /// Result of the roam attempt. Required.
985    pub status_code: Option<fidl_fuchsia_wlan_ieee80211__common::StatusCode>,
986    /// Whether the original BSS association has been maintained through the roam attempt. Required.
987    /// A successful roam always incurs disassociation from the original BSS, so if `status_code` is
988    /// success then this field must be set to false; a roam failure typically incurs disassociation
989    /// from the original BSS, but may not in some cases (e.g. in some Fast BSS Transition scenarios).
990    pub original_association_maintained: Option<bool>,
991    /// Whether the client is authenticated with the target BSS. If `status_code` is success, then
992    /// this field must be set to true; if the roam attempt failed, this field may be true or false.
993    /// This allows higher layers to decide how to clean up connection state after a failed roam
994    /// attempt.
995    pub target_bss_authenticated: Option<bool>,
996    /// Association ID for this association with the AP. Required if `status_code` is success.
997    pub association_id: Option<u16>,
998    /// IEs for this association with the AP. Required if `status_code` is success.
999    pub association_ies: Option<Vec<u8>>,
1000    #[doc(hidden)]
1001    pub __source_breaking: fidl::marker::SourceBreaking,
1002}
1003
1004impl fidl::Persistable for WlanFullmacImplIfcRoamConfRequest {}
1005
1006#[derive(Clone, Debug, Default, PartialEq)]
1007pub struct WlanFullmacImplIfcRoamResultIndRequest {
1008    /// BSSID of the target BSS. Required.
1009    pub selected_bssid: Option<[u8; 6]>,
1010    /// Result of the roam attempt. Required.
1011    pub status_code: Option<fidl_fuchsia_wlan_ieee80211__common::StatusCode>,
1012    /// Whether the original BSS association has been maintained through the roam attempt. Required.
1013    /// A successful roam always incurs disassociation from the original BSS, so if `status_code` is
1014    /// success then this field must be set to false; a roam failure typically incurs disassociation
1015    /// from the original BSS, but may not in some cases (e.g. in some Fast BSS Transition scenarios).
1016    pub original_association_maintained: Option<bool>,
1017    /// Whether the client is authenticated with the target BSS. If `status_code` is success, then
1018    /// this field must be set to true; if the roam attempt failed, this field may be true or false.
1019    /// This allows higher layers to decide how to clean up connection state after a failed roam
1020    /// attempt.
1021    pub target_bss_authenticated: Option<bool>,
1022    /// Association ID for this association with the AP. Required if `status_code` is success.
1023    pub association_id: Option<u16>,
1024    /// IEs for this association with the AP. Required if `status_code` is success.
1025    pub association_ies: Option<Vec<u8>>,
1026    #[doc(hidden)]
1027    pub __source_breaking: fidl::marker::SourceBreaking,
1028}
1029
1030impl fidl::Persistable for WlanFullmacImplIfcRoamResultIndRequest {}
1031
1032#[derive(Clone, Debug, Default, PartialEq)]
1033pub struct WlanFullmacImplIfcRoamStartIndRequest {
1034    /// BSSID of the target BSS. Required.
1035    pub selected_bssid: Option<[u8; 6]>,
1036    /// Full BSS description of the target BSS. Required.
1037    /// If the data in BssDescription is incorrect or incomplete, the roam cannot succeed,
1038    /// because higher layers will not be able to complete required actions (e.g. SAE).
1039    pub selected_bss: Option<fidl_fuchsia_wlan_common__common::BssDescription>,
1040    /// Whether the original BSS association has been maintained at the start of a roam attempt.
1041    /// Required. 802.11 dictates that a STA can only be associated with a single BSS, so a roam
1042    /// attempt typically incurs disassociation at the start of the roam attempt. However,
1043    /// 802.11 also provides a mechanism (i.e. Fast BSS Transition) that allows a device to
1044    /// maintain association with the original BSS while establishing authentication with the
1045    /// target BSS, in order to avoid losing the original association if authentication with the
1046    /// target BSS fails.
1047    pub original_association_maintained: Option<bool>,
1048    #[doc(hidden)]
1049    pub __source_breaking: fidl::marker::SourceBreaking,
1050}
1051
1052impl fidl::Persistable for WlanFullmacImplIfcRoamStartIndRequest {}
1053
1054#[derive(Clone, Debug, Default, PartialEq)]
1055pub struct WlanFullmacImplIfcSaeHandshakeIndRequest {
1056    pub peer_sta_address: Option<[u8; 6]>,
1057    #[doc(hidden)]
1058    pub __source_breaking: fidl::marker::SourceBreaking,
1059}
1060
1061impl fidl::Persistable for WlanFullmacImplIfcSaeHandshakeIndRequest {}
1062
1063#[derive(Clone, Debug, Default, PartialEq)]
1064pub struct WlanFullmacImplIfcStartConfRequest {
1065    /// The result of the StartBss request. Required.
1066    pub result_code: Option<StartResult>,
1067    #[doc(hidden)]
1068    pub __source_breaking: fidl::marker::SourceBreaking,
1069}
1070
1071impl fidl::Persistable for WlanFullmacImplIfcStartConfRequest {}
1072
1073#[derive(Clone, Debug, Default, PartialEq)]
1074pub struct WlanFullmacImplIfcStopConfRequest {
1075    /// The result of the StopBss request. Required.
1076    pub result_code: Option<StopResult>,
1077    #[doc(hidden)]
1078    pub __source_breaking: fidl::marker::SourceBreaking,
1079}
1080
1081impl fidl::Persistable for WlanFullmacImplIfcStopConfRequest {}
1082
1083#[derive(Clone, Debug, Default, PartialEq)]
1084pub struct WlanFullmacImplOnLinkStateChangedRequest {
1085    pub online: Option<bool>,
1086    #[doc(hidden)]
1087    pub __source_breaking: fidl::marker::SourceBreaking,
1088}
1089
1090impl fidl::Persistable for WlanFullmacImplOnLinkStateChangedRequest {}
1091
1092#[derive(Clone, Debug, Default, PartialEq)]
1093pub struct WlanFullmacImplReconnectRequest {
1094    pub peer_sta_address: Option<[u8; 6]>,
1095    #[doc(hidden)]
1096    pub __source_breaking: fidl::marker::SourceBreaking,
1097}
1098
1099impl fidl::Persistable for WlanFullmacImplReconnectRequest {}
1100
1101#[derive(Clone, Debug, Default, PartialEq)]
1102pub struct WlanFullmacImplRoamRequest {
1103    /// Full BSS description of the target BSS. Required.
1104    /// If the data in BssDescription is incorrect or incomplete, the roam cannot succeed,
1105    /// because higher layers will not be able to complete required actions (e.g. SAE).
1106    pub selected_bss: Option<fidl_fuchsia_wlan_common__common::BssDescription>,
1107    #[doc(hidden)]
1108    pub __source_breaking: fidl::marker::SourceBreaking,
1109}
1110
1111impl fidl::Persistable for WlanFullmacImplRoamRequest {}
1112
1113#[derive(Clone, Debug, Default, PartialEq)]
1114pub struct WlanFullmacImplSaeHandshakeRespRequest {
1115    /// The peer's MAC address. Required.
1116    pub peer_sta_address: Option<[u8; 6]>,
1117    /// The status of the SAE handshake. Required.
1118    pub status_code: Option<fidl_fuchsia_wlan_ieee80211__common::StatusCode>,
1119    #[doc(hidden)]
1120    pub __source_breaking: fidl::marker::SourceBreaking,
1121}
1122
1123impl fidl::Persistable for WlanFullmacImplSaeHandshakeRespRequest {}
1124
1125#[derive(Clone, Debug, Default, PartialEq)]
1126pub struct WlanFullmacImplSetKeysRequest {
1127    pub keylist: Option<Vec<fidl_fuchsia_wlan_common__common::WlanKeyConfig>>,
1128    pub key_descriptors: Option<Vec<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor>>,
1129    #[doc(hidden)]
1130    pub __source_breaking: fidl::marker::SourceBreaking,
1131}
1132
1133impl fidl::Persistable for WlanFullmacImplSetKeysRequest {}
1134
1135#[derive(Clone, Debug, Default, PartialEq)]
1136pub struct WlanFullmacImplStartBssRequest {
1137    pub ssid: Option<Vec<u8>>,
1138    pub bss_type: Option<fidl_fuchsia_wlan_common__common::BssType>,
1139    pub beacon_period: Option<u32>,
1140    pub dtim_period: Option<u32>,
1141    pub channel: Option<u8>,
1142    pub rsne: Option<Vec<u8>>,
1143    pub vendor_ie: Option<Vec<u8>>,
1144    #[doc(hidden)]
1145    pub __source_breaking: fidl::marker::SourceBreaking,
1146}
1147
1148impl fidl::Persistable for WlanFullmacImplStartBssRequest {}
1149
1150#[derive(Clone, Debug, Default, PartialEq)]
1151pub struct WlanFullmacImplStartScanRequest {
1152    /// Unique transaction id (will be indicated in corresponding scan results).
1153    pub txn_id: Option<u64>,
1154    pub scan_type: Option<WlanScanType>,
1155    /// List of channels to scan on. An empty list of channels will cause a
1156    /// scan request to immediately return a OnScanEnd with code INVALID_ARGS.
1157    ///
1158    /// Invalid channel numbers will be silently ignored. The validity of a channel
1159    /// number depends on the current regulatory region, and a FullMAC driver cannot
1160    /// always determine the region setting. This is especially the case when
1161    /// firmware changes the region setting dynamically.
1162    pub channels: Option<Vec<u8>>,
1163    /// List of SSIDs to scan for. An empty list of ssids is the same as specifying
1164    /// a list containing only the wildcard SSID.
1165    ///
1166    /// There is no limit on the number of SSIDs specified. A large number of
1167    /// SSIDs may result in extended scan times because of hardware limitations on
1168    /// the number of SSIDs permitted per scan request and the technical limitation
1169    /// in IEEE 802.11-2016 that limits the number of SSIDs in a single Probe Request
1170    /// frame to ieee80211.SSID_LIST_MAX SSIDs.
1171    pub ssids: Option<Vec<Vec<u8>>>,
1172    /// Minimum amount of time in msecs spent on a channel during scan.
1173    pub min_channel_time: Option<u32>,
1174    /// Maximum amount of time in msecs spent on a channel during scan.
1175    pub max_channel_time: Option<u32>,
1176    #[doc(hidden)]
1177    pub __source_breaking: fidl::marker::SourceBreaking,
1178}
1179
1180impl fidl::Persistable for WlanFullmacImplStartScanRequest {}
1181
1182#[derive(Clone, Debug, Default, PartialEq)]
1183pub struct WlanFullmacImplStopBssRequest {
1184    pub ssid: Option<Vec<u8>>,
1185    #[doc(hidden)]
1186    pub __source_breaking: fidl::marker::SourceBreaking,
1187}
1188
1189impl fidl::Persistable for WlanFullmacImplStopBssRequest {}
1190
1191#[derive(Clone, Debug, Default, PartialEq)]
1192pub struct WlanFullmacImplQueryResponse {
1193    /// Station address. Required.
1194    pub sta_addr: Option<[u8; 6]>,
1195    /// MAC role. Required.
1196    pub role: Option<fidl_fuchsia_wlan_common__common::WlanMacRole>,
1197    /// Supported bands. Required.
1198    pub band_caps: Option<Vec<BandCapability>>,
1199    #[doc(hidden)]
1200    pub __source_breaking: fidl::marker::SourceBreaking,
1201}
1202
1203impl fidl::Persistable for WlanFullmacImplQueryResponse {}
1204
1205mod internal {
1206    use super::*;
1207    unsafe impl fidl::encoding::TypeMarker for EapolTxResult {
1208        type Owned = Self;
1209
1210        #[inline(always)]
1211        fn inline_align(_context: fidl::encoding::Context) -> usize {
1212            std::mem::align_of::<u8>()
1213        }
1214
1215        #[inline(always)]
1216        fn inline_size(_context: fidl::encoding::Context) -> usize {
1217            std::mem::size_of::<u8>()
1218        }
1219
1220        #[inline(always)]
1221        fn encode_is_copy() -> bool {
1222            false
1223        }
1224
1225        #[inline(always)]
1226        fn decode_is_copy() -> bool {
1227            false
1228        }
1229    }
1230
1231    impl fidl::encoding::ValueTypeMarker for EapolTxResult {
1232        type Borrowed<'a> = Self;
1233        #[inline(always)]
1234        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1235            *value
1236        }
1237    }
1238
1239    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for EapolTxResult {
1240        #[inline]
1241        unsafe fn encode(
1242            self,
1243            encoder: &mut fidl::encoding::Encoder<'_, D>,
1244            offset: usize,
1245            _depth: fidl::encoding::Depth,
1246        ) -> fidl::Result<()> {
1247            encoder.debug_check_bounds::<Self>(offset);
1248            encoder.write_num(self.into_primitive(), offset);
1249            Ok(())
1250        }
1251    }
1252
1253    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EapolTxResult {
1254        #[inline(always)]
1255        fn new_empty() -> Self {
1256            Self::unknown()
1257        }
1258
1259        #[inline]
1260        unsafe fn decode(
1261            &mut self,
1262            decoder: &mut fidl::encoding::Decoder<'_, D>,
1263            offset: usize,
1264            _depth: fidl::encoding::Depth,
1265        ) -> fidl::Result<()> {
1266            decoder.debug_check_bounds::<Self>(offset);
1267            let prim = decoder.read_num::<u8>(offset);
1268
1269            *self = Self::from_primitive_allow_unknown(prim);
1270            Ok(())
1271        }
1272    }
1273    unsafe impl fidl::encoding::TypeMarker for StartResult {
1274        type Owned = Self;
1275
1276        #[inline(always)]
1277        fn inline_align(_context: fidl::encoding::Context) -> usize {
1278            std::mem::align_of::<u8>()
1279        }
1280
1281        #[inline(always)]
1282        fn inline_size(_context: fidl::encoding::Context) -> usize {
1283            std::mem::size_of::<u8>()
1284        }
1285
1286        #[inline(always)]
1287        fn encode_is_copy() -> bool {
1288            false
1289        }
1290
1291        #[inline(always)]
1292        fn decode_is_copy() -> bool {
1293            false
1294        }
1295    }
1296
1297    impl fidl::encoding::ValueTypeMarker for StartResult {
1298        type Borrowed<'a> = Self;
1299        #[inline(always)]
1300        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1301            *value
1302        }
1303    }
1304
1305    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StartResult {
1306        #[inline]
1307        unsafe fn encode(
1308            self,
1309            encoder: &mut fidl::encoding::Encoder<'_, D>,
1310            offset: usize,
1311            _depth: fidl::encoding::Depth,
1312        ) -> fidl::Result<()> {
1313            encoder.debug_check_bounds::<Self>(offset);
1314            encoder.write_num(self.into_primitive(), offset);
1315            Ok(())
1316        }
1317    }
1318
1319    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartResult {
1320        #[inline(always)]
1321        fn new_empty() -> Self {
1322            Self::unknown()
1323        }
1324
1325        #[inline]
1326        unsafe fn decode(
1327            &mut self,
1328            decoder: &mut fidl::encoding::Decoder<'_, D>,
1329            offset: usize,
1330            _depth: fidl::encoding::Depth,
1331        ) -> fidl::Result<()> {
1332            decoder.debug_check_bounds::<Self>(offset);
1333            let prim = decoder.read_num::<u8>(offset);
1334
1335            *self = Self::from_primitive_allow_unknown(prim);
1336            Ok(())
1337        }
1338    }
1339    unsafe impl fidl::encoding::TypeMarker for StopResult {
1340        type Owned = Self;
1341
1342        #[inline(always)]
1343        fn inline_align(_context: fidl::encoding::Context) -> usize {
1344            std::mem::align_of::<u8>()
1345        }
1346
1347        #[inline(always)]
1348        fn inline_size(_context: fidl::encoding::Context) -> usize {
1349            std::mem::size_of::<u8>()
1350        }
1351
1352        #[inline(always)]
1353        fn encode_is_copy() -> bool {
1354            false
1355        }
1356
1357        #[inline(always)]
1358        fn decode_is_copy() -> bool {
1359            false
1360        }
1361    }
1362
1363    impl fidl::encoding::ValueTypeMarker for StopResult {
1364        type Borrowed<'a> = Self;
1365        #[inline(always)]
1366        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1367            *value
1368        }
1369    }
1370
1371    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StopResult {
1372        #[inline]
1373        unsafe fn encode(
1374            self,
1375            encoder: &mut fidl::encoding::Encoder<'_, D>,
1376            offset: usize,
1377            _depth: fidl::encoding::Depth,
1378        ) -> fidl::Result<()> {
1379            encoder.debug_check_bounds::<Self>(offset);
1380            encoder.write_num(self.into_primitive(), offset);
1381            Ok(())
1382        }
1383    }
1384
1385    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopResult {
1386        #[inline(always)]
1387        fn new_empty() -> Self {
1388            Self::unknown()
1389        }
1390
1391        #[inline]
1392        unsafe fn decode(
1393            &mut self,
1394            decoder: &mut fidl::encoding::Decoder<'_, D>,
1395            offset: usize,
1396            _depth: fidl::encoding::Depth,
1397        ) -> fidl::Result<()> {
1398            decoder.debug_check_bounds::<Self>(offset);
1399            let prim = decoder.read_num::<u8>(offset);
1400
1401            *self = Self::from_primitive_allow_unknown(prim);
1402            Ok(())
1403        }
1404    }
1405    unsafe impl fidl::encoding::TypeMarker for WlanAssocResult {
1406        type Owned = Self;
1407
1408        #[inline(always)]
1409        fn inline_align(_context: fidl::encoding::Context) -> usize {
1410            std::mem::align_of::<u8>()
1411        }
1412
1413        #[inline(always)]
1414        fn inline_size(_context: fidl::encoding::Context) -> usize {
1415            std::mem::size_of::<u8>()
1416        }
1417
1418        #[inline(always)]
1419        fn encode_is_copy() -> bool {
1420            false
1421        }
1422
1423        #[inline(always)]
1424        fn decode_is_copy() -> bool {
1425            false
1426        }
1427    }
1428
1429    impl fidl::encoding::ValueTypeMarker for WlanAssocResult {
1430        type Borrowed<'a> = Self;
1431        #[inline(always)]
1432        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1433            *value
1434        }
1435    }
1436
1437    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1438        for WlanAssocResult
1439    {
1440        #[inline]
1441        unsafe fn encode(
1442            self,
1443            encoder: &mut fidl::encoding::Encoder<'_, D>,
1444            offset: usize,
1445            _depth: fidl::encoding::Depth,
1446        ) -> fidl::Result<()> {
1447            encoder.debug_check_bounds::<Self>(offset);
1448            encoder.write_num(self.into_primitive(), offset);
1449            Ok(())
1450        }
1451    }
1452
1453    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanAssocResult {
1454        #[inline(always)]
1455        fn new_empty() -> Self {
1456            Self::unknown()
1457        }
1458
1459        #[inline]
1460        unsafe fn decode(
1461            &mut self,
1462            decoder: &mut fidl::encoding::Decoder<'_, D>,
1463            offset: usize,
1464            _depth: fidl::encoding::Depth,
1465        ) -> fidl::Result<()> {
1466            decoder.debug_check_bounds::<Self>(offset);
1467            let prim = decoder.read_num::<u8>(offset);
1468
1469            *self = Self::from_primitive_allow_unknown(prim);
1470            Ok(())
1471        }
1472    }
1473    unsafe impl fidl::encoding::TypeMarker for WlanAuthResult {
1474        type Owned = Self;
1475
1476        #[inline(always)]
1477        fn inline_align(_context: fidl::encoding::Context) -> usize {
1478            std::mem::align_of::<u8>()
1479        }
1480
1481        #[inline(always)]
1482        fn inline_size(_context: fidl::encoding::Context) -> usize {
1483            std::mem::size_of::<u8>()
1484        }
1485
1486        #[inline(always)]
1487        fn encode_is_copy() -> bool {
1488            false
1489        }
1490
1491        #[inline(always)]
1492        fn decode_is_copy() -> bool {
1493            false
1494        }
1495    }
1496
1497    impl fidl::encoding::ValueTypeMarker for WlanAuthResult {
1498        type Borrowed<'a> = Self;
1499        #[inline(always)]
1500        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1501            *value
1502        }
1503    }
1504
1505    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanAuthResult {
1506        #[inline]
1507        unsafe fn encode(
1508            self,
1509            encoder: &mut fidl::encoding::Encoder<'_, D>,
1510            offset: usize,
1511            _depth: fidl::encoding::Depth,
1512        ) -> fidl::Result<()> {
1513            encoder.debug_check_bounds::<Self>(offset);
1514            encoder.write_num(self.into_primitive(), offset);
1515            Ok(())
1516        }
1517    }
1518
1519    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanAuthResult {
1520        #[inline(always)]
1521        fn new_empty() -> Self {
1522            Self::unknown()
1523        }
1524
1525        #[inline]
1526        unsafe fn decode(
1527            &mut self,
1528            decoder: &mut fidl::encoding::Decoder<'_, D>,
1529            offset: usize,
1530            _depth: fidl::encoding::Depth,
1531        ) -> fidl::Result<()> {
1532            decoder.debug_check_bounds::<Self>(offset);
1533            let prim = decoder.read_num::<u8>(offset);
1534
1535            *self = Self::from_primitive_allow_unknown(prim);
1536            Ok(())
1537        }
1538    }
1539    unsafe impl fidl::encoding::TypeMarker for WlanAuthType {
1540        type Owned = Self;
1541
1542        #[inline(always)]
1543        fn inline_align(_context: fidl::encoding::Context) -> usize {
1544            std::mem::align_of::<u8>()
1545        }
1546
1547        #[inline(always)]
1548        fn inline_size(_context: fidl::encoding::Context) -> usize {
1549            std::mem::size_of::<u8>()
1550        }
1551
1552        #[inline(always)]
1553        fn encode_is_copy() -> bool {
1554            false
1555        }
1556
1557        #[inline(always)]
1558        fn decode_is_copy() -> bool {
1559            false
1560        }
1561    }
1562
1563    impl fidl::encoding::ValueTypeMarker for WlanAuthType {
1564        type Borrowed<'a> = Self;
1565        #[inline(always)]
1566        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1567            *value
1568        }
1569    }
1570
1571    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanAuthType {
1572        #[inline]
1573        unsafe fn encode(
1574            self,
1575            encoder: &mut fidl::encoding::Encoder<'_, D>,
1576            offset: usize,
1577            _depth: fidl::encoding::Depth,
1578        ) -> fidl::Result<()> {
1579            encoder.debug_check_bounds::<Self>(offset);
1580            encoder.write_num(self.into_primitive(), offset);
1581            Ok(())
1582        }
1583    }
1584
1585    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanAuthType {
1586        #[inline(always)]
1587        fn new_empty() -> Self {
1588            Self::unknown()
1589        }
1590
1591        #[inline]
1592        unsafe fn decode(
1593            &mut self,
1594            decoder: &mut fidl::encoding::Decoder<'_, D>,
1595            offset: usize,
1596            _depth: fidl::encoding::Depth,
1597        ) -> fidl::Result<()> {
1598            decoder.debug_check_bounds::<Self>(offset);
1599            let prim = decoder.read_num::<u8>(offset);
1600
1601            *self = Self::from_primitive_allow_unknown(prim);
1602            Ok(())
1603        }
1604    }
1605    unsafe impl fidl::encoding::TypeMarker for WlanScanResult {
1606        type Owned = Self;
1607
1608        #[inline(always)]
1609        fn inline_align(_context: fidl::encoding::Context) -> usize {
1610            std::mem::align_of::<u8>()
1611        }
1612
1613        #[inline(always)]
1614        fn inline_size(_context: fidl::encoding::Context) -> usize {
1615            std::mem::size_of::<u8>()
1616        }
1617
1618        #[inline(always)]
1619        fn encode_is_copy() -> bool {
1620            false
1621        }
1622
1623        #[inline(always)]
1624        fn decode_is_copy() -> bool {
1625            false
1626        }
1627    }
1628
1629    impl fidl::encoding::ValueTypeMarker for WlanScanResult {
1630        type Borrowed<'a> = Self;
1631        #[inline(always)]
1632        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1633            *value
1634        }
1635    }
1636
1637    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanScanResult {
1638        #[inline]
1639        unsafe fn encode(
1640            self,
1641            encoder: &mut fidl::encoding::Encoder<'_, D>,
1642            offset: usize,
1643            _depth: fidl::encoding::Depth,
1644        ) -> fidl::Result<()> {
1645            encoder.debug_check_bounds::<Self>(offset);
1646            encoder.write_num(self.into_primitive(), offset);
1647            Ok(())
1648        }
1649    }
1650
1651    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanScanResult {
1652        #[inline(always)]
1653        fn new_empty() -> Self {
1654            Self::unknown()
1655        }
1656
1657        #[inline]
1658        unsafe fn decode(
1659            &mut self,
1660            decoder: &mut fidl::encoding::Decoder<'_, D>,
1661            offset: usize,
1662            _depth: fidl::encoding::Depth,
1663        ) -> fidl::Result<()> {
1664            decoder.debug_check_bounds::<Self>(offset);
1665            let prim = decoder.read_num::<u8>(offset);
1666
1667            *self = Self::from_primitive_allow_unknown(prim);
1668            Ok(())
1669        }
1670    }
1671    unsafe impl fidl::encoding::TypeMarker for WlanScanType {
1672        type Owned = Self;
1673
1674        #[inline(always)]
1675        fn inline_align(_context: fidl::encoding::Context) -> usize {
1676            std::mem::align_of::<u8>()
1677        }
1678
1679        #[inline(always)]
1680        fn inline_size(_context: fidl::encoding::Context) -> usize {
1681            std::mem::size_of::<u8>()
1682        }
1683
1684        #[inline(always)]
1685        fn encode_is_copy() -> bool {
1686            false
1687        }
1688
1689        #[inline(always)]
1690        fn decode_is_copy() -> bool {
1691            false
1692        }
1693    }
1694
1695    impl fidl::encoding::ValueTypeMarker for WlanScanType {
1696        type Borrowed<'a> = Self;
1697        #[inline(always)]
1698        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1699            *value
1700        }
1701    }
1702
1703    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanScanType {
1704        #[inline]
1705        unsafe fn encode(
1706            self,
1707            encoder: &mut fidl::encoding::Encoder<'_, D>,
1708            offset: usize,
1709            _depth: fidl::encoding::Depth,
1710        ) -> fidl::Result<()> {
1711            encoder.debug_check_bounds::<Self>(offset);
1712            encoder.write_num(self.into_primitive(), offset);
1713            Ok(())
1714        }
1715    }
1716
1717    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanScanType {
1718        #[inline(always)]
1719        fn new_empty() -> Self {
1720            Self::unknown()
1721        }
1722
1723        #[inline]
1724        unsafe fn decode(
1725            &mut self,
1726            decoder: &mut fidl::encoding::Decoder<'_, D>,
1727            offset: usize,
1728            _depth: fidl::encoding::Depth,
1729        ) -> fidl::Result<()> {
1730            decoder.debug_check_bounds::<Self>(offset);
1731            let prim = decoder.read_num::<u8>(offset);
1732
1733            *self = Self::from_primitive_allow_unknown(prim);
1734            Ok(())
1735        }
1736    }
1737
1738    impl fidl::encoding::ValueTypeMarker for WlanFullmacChannelSwitchInfo {
1739        type Borrowed<'a> = &'a Self;
1740        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1741            value
1742        }
1743    }
1744
1745    unsafe impl fidl::encoding::TypeMarker for WlanFullmacChannelSwitchInfo {
1746        type Owned = Self;
1747
1748        #[inline(always)]
1749        fn inline_align(_context: fidl::encoding::Context) -> usize {
1750            1
1751        }
1752
1753        #[inline(always)]
1754        fn inline_size(_context: fidl::encoding::Context) -> usize {
1755            1
1756        }
1757        #[inline(always)]
1758        fn encode_is_copy() -> bool {
1759            true
1760        }
1761
1762        #[inline(always)]
1763        fn decode_is_copy() -> bool {
1764            true
1765        }
1766    }
1767
1768    unsafe impl<D: fidl::encoding::ResourceDialect>
1769        fidl::encoding::Encode<WlanFullmacChannelSwitchInfo, D> for &WlanFullmacChannelSwitchInfo
1770    {
1771        #[inline]
1772        unsafe fn encode(
1773            self,
1774            encoder: &mut fidl::encoding::Encoder<'_, D>,
1775            offset: usize,
1776            _depth: fidl::encoding::Depth,
1777        ) -> fidl::Result<()> {
1778            encoder.debug_check_bounds::<WlanFullmacChannelSwitchInfo>(offset);
1779            unsafe {
1780                // Copy the object into the buffer.
1781                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1782                (buf_ptr as *mut WlanFullmacChannelSwitchInfo)
1783                    .write_unaligned((self as *const WlanFullmacChannelSwitchInfo).read());
1784                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1785                // done second because the memcpy will write garbage to these bytes.
1786            }
1787            Ok(())
1788        }
1789    }
1790    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
1791        fidl::encoding::Encode<WlanFullmacChannelSwitchInfo, D> for (T0,)
1792    {
1793        #[inline]
1794        unsafe fn encode(
1795            self,
1796            encoder: &mut fidl::encoding::Encoder<'_, D>,
1797            offset: usize,
1798            depth: fidl::encoding::Depth,
1799        ) -> fidl::Result<()> {
1800            encoder.debug_check_bounds::<WlanFullmacChannelSwitchInfo>(offset);
1801            // Zero out padding regions. There's no need to apply masks
1802            // because the unmasked parts will be overwritten by fields.
1803            // Write the fields.
1804            self.0.encode(encoder, offset + 0, depth)?;
1805            Ok(())
1806        }
1807    }
1808
1809    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1810        for WlanFullmacChannelSwitchInfo
1811    {
1812        #[inline(always)]
1813        fn new_empty() -> Self {
1814            Self { new_channel: fidl::new_empty!(u8, D) }
1815        }
1816
1817        #[inline]
1818        unsafe fn decode(
1819            &mut self,
1820            decoder: &mut fidl::encoding::Decoder<'_, D>,
1821            offset: usize,
1822            _depth: fidl::encoding::Depth,
1823        ) -> fidl::Result<()> {
1824            decoder.debug_check_bounds::<Self>(offset);
1825            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1826            // Verify that padding bytes are zero.
1827            // Copy from the buffer into the object.
1828            unsafe {
1829                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
1830            }
1831            Ok(())
1832        }
1833    }
1834
1835    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnChannelSwitchRequest {
1836        type Borrowed<'a> = &'a Self;
1837        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1838            value
1839        }
1840    }
1841
1842    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnChannelSwitchRequest {
1843        type Owned = Self;
1844
1845        #[inline(always)]
1846        fn inline_align(_context: fidl::encoding::Context) -> usize {
1847            1
1848        }
1849
1850        #[inline(always)]
1851        fn inline_size(_context: fidl::encoding::Context) -> usize {
1852            1
1853        }
1854        #[inline(always)]
1855        fn encode_is_copy() -> bool {
1856            true
1857        }
1858
1859        #[inline(always)]
1860        fn decode_is_copy() -> bool {
1861            true
1862        }
1863    }
1864
1865    unsafe impl<D: fidl::encoding::ResourceDialect>
1866        fidl::encoding::Encode<WlanFullmacImplIfcOnChannelSwitchRequest, D>
1867        for &WlanFullmacImplIfcOnChannelSwitchRequest
1868    {
1869        #[inline]
1870        unsafe fn encode(
1871            self,
1872            encoder: &mut fidl::encoding::Encoder<'_, D>,
1873            offset: usize,
1874            _depth: fidl::encoding::Depth,
1875        ) -> fidl::Result<()> {
1876            encoder.debug_check_bounds::<WlanFullmacImplIfcOnChannelSwitchRequest>(offset);
1877            unsafe {
1878                // Copy the object into the buffer.
1879                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1880                (buf_ptr as *mut WlanFullmacImplIfcOnChannelSwitchRequest).write_unaligned(
1881                    (self as *const WlanFullmacImplIfcOnChannelSwitchRequest).read(),
1882                );
1883                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1884                // done second because the memcpy will write garbage to these bytes.
1885            }
1886            Ok(())
1887        }
1888    }
1889    unsafe impl<
1890            D: fidl::encoding::ResourceDialect,
1891            T0: fidl::encoding::Encode<WlanFullmacChannelSwitchInfo, D>,
1892        > fidl::encoding::Encode<WlanFullmacImplIfcOnChannelSwitchRequest, D> for (T0,)
1893    {
1894        #[inline]
1895        unsafe fn encode(
1896            self,
1897            encoder: &mut fidl::encoding::Encoder<'_, D>,
1898            offset: usize,
1899            depth: fidl::encoding::Depth,
1900        ) -> fidl::Result<()> {
1901            encoder.debug_check_bounds::<WlanFullmacImplIfcOnChannelSwitchRequest>(offset);
1902            // Zero out padding regions. There's no need to apply masks
1903            // because the unmasked parts will be overwritten by fields.
1904            // Write the fields.
1905            self.0.encode(encoder, offset + 0, depth)?;
1906            Ok(())
1907        }
1908    }
1909
1910    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1911        for WlanFullmacImplIfcOnChannelSwitchRequest
1912    {
1913        #[inline(always)]
1914        fn new_empty() -> Self {
1915            Self { ind: fidl::new_empty!(WlanFullmacChannelSwitchInfo, D) }
1916        }
1917
1918        #[inline]
1919        unsafe fn decode(
1920            &mut self,
1921            decoder: &mut fidl::encoding::Decoder<'_, D>,
1922            offset: usize,
1923            _depth: fidl::encoding::Depth,
1924        ) -> fidl::Result<()> {
1925            decoder.debug_check_bounds::<Self>(offset);
1926            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1927            // Verify that padding bytes are zero.
1928            // Copy from the buffer into the object.
1929            unsafe {
1930                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
1931            }
1932            Ok(())
1933        }
1934    }
1935
1936    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnWmmStatusRespRequest {
1937        type Borrowed<'a> = &'a Self;
1938        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1939            value
1940        }
1941    }
1942
1943    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnWmmStatusRespRequest {
1944        type Owned = Self;
1945
1946        #[inline(always)]
1947        fn inline_align(_context: fidl::encoding::Context) -> usize {
1948            4
1949        }
1950
1951        #[inline(always)]
1952        fn inline_size(_context: fidl::encoding::Context) -> usize {
1953            40
1954        }
1955    }
1956
1957    unsafe impl<D: fidl::encoding::ResourceDialect>
1958        fidl::encoding::Encode<WlanFullmacImplIfcOnWmmStatusRespRequest, D>
1959        for &WlanFullmacImplIfcOnWmmStatusRespRequest
1960    {
1961        #[inline]
1962        unsafe fn encode(
1963            self,
1964            encoder: &mut fidl::encoding::Encoder<'_, D>,
1965            offset: usize,
1966            _depth: fidl::encoding::Depth,
1967        ) -> fidl::Result<()> {
1968            encoder.debug_check_bounds::<WlanFullmacImplIfcOnWmmStatusRespRequest>(offset);
1969            // Delegate to tuple encoding.
1970            fidl::encoding::Encode::<WlanFullmacImplIfcOnWmmStatusRespRequest, D>::encode(
1971                (
1972                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
1973                    <fidl_fuchsia_wlan_common__common::WlanWmmParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.wmm_params),
1974                ),
1975                encoder, offset, _depth
1976            )
1977        }
1978    }
1979    unsafe impl<
1980            D: fidl::encoding::ResourceDialect,
1981            T0: fidl::encoding::Encode<i32, D>,
1982            T1: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::WlanWmmParameters, D>,
1983        > fidl::encoding::Encode<WlanFullmacImplIfcOnWmmStatusRespRequest, D> for (T0, T1)
1984    {
1985        #[inline]
1986        unsafe fn encode(
1987            self,
1988            encoder: &mut fidl::encoding::Encoder<'_, D>,
1989            offset: usize,
1990            depth: fidl::encoding::Depth,
1991        ) -> fidl::Result<()> {
1992            encoder.debug_check_bounds::<WlanFullmacImplIfcOnWmmStatusRespRequest>(offset);
1993            // Zero out padding regions. There's no need to apply masks
1994            // because the unmasked parts will be overwritten by fields.
1995            unsafe {
1996                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(36);
1997                (ptr as *mut u32).write_unaligned(0);
1998            }
1999            // Write the fields.
2000            self.0.encode(encoder, offset + 0, depth)?;
2001            self.1.encode(encoder, offset + 4, depth)?;
2002            Ok(())
2003        }
2004    }
2005
2006    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2007        for WlanFullmacImplIfcOnWmmStatusRespRequest
2008    {
2009        #[inline(always)]
2010        fn new_empty() -> Self {
2011            Self {
2012                status: fidl::new_empty!(i32, D),
2013                wmm_params: fidl::new_empty!(
2014                    fidl_fuchsia_wlan_common__common::WlanWmmParameters,
2015                    D
2016                ),
2017            }
2018        }
2019
2020        #[inline]
2021        unsafe fn decode(
2022            &mut self,
2023            decoder: &mut fidl::encoding::Decoder<'_, D>,
2024            offset: usize,
2025            _depth: fidl::encoding::Depth,
2026        ) -> fidl::Result<()> {
2027            decoder.debug_check_bounds::<Self>(offset);
2028            // Verify that padding bytes are zero.
2029            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(36) };
2030            let padval = unsafe { (ptr as *const u32).read_unaligned() };
2031            let mask = 0xffff0000u32;
2032            let maskedval = padval & mask;
2033            if maskedval != 0 {
2034                return Err(fidl::Error::NonZeroPadding {
2035                    padding_start: offset + 36 + ((mask as u64).trailing_zeros() / 8) as usize,
2036                });
2037            }
2038            fidl::decode!(i32, D, &mut self.status, decoder, offset + 0, _depth)?;
2039            fidl::decode!(
2040                fidl_fuchsia_wlan_common__common::WlanWmmParameters,
2041                D,
2042                &mut self.wmm_params,
2043                decoder,
2044                offset + 4,
2045                _depth
2046            )?;
2047            Ok(())
2048        }
2049    }
2050
2051    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcSaeFrameRxRequest {
2052        type Borrowed<'a> = &'a Self;
2053        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2054            value
2055        }
2056    }
2057
2058    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcSaeFrameRxRequest {
2059        type Owned = Self;
2060
2061        #[inline(always)]
2062        fn inline_align(_context: fidl::encoding::Context) -> usize {
2063            8
2064        }
2065
2066        #[inline(always)]
2067        fn inline_size(_context: fidl::encoding::Context) -> usize {
2068            16
2069        }
2070    }
2071
2072    unsafe impl<D: fidl::encoding::ResourceDialect>
2073        fidl::encoding::Encode<WlanFullmacImplIfcSaeFrameRxRequest, D>
2074        for &WlanFullmacImplIfcSaeFrameRxRequest
2075    {
2076        #[inline]
2077        unsafe fn encode(
2078            self,
2079            encoder: &mut fidl::encoding::Encoder<'_, D>,
2080            offset: usize,
2081            _depth: fidl::encoding::Depth,
2082        ) -> fidl::Result<()> {
2083            encoder.debug_check_bounds::<WlanFullmacImplIfcSaeFrameRxRequest>(offset);
2084            // Delegate to tuple encoding.
2085            fidl::encoding::Encode::<WlanFullmacImplIfcSaeFrameRxRequest, D>::encode(
2086                (<SaeFrame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
2087                encoder,
2088                offset,
2089                _depth,
2090            )
2091        }
2092    }
2093    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SaeFrame, D>>
2094        fidl::encoding::Encode<WlanFullmacImplIfcSaeFrameRxRequest, D> for (T0,)
2095    {
2096        #[inline]
2097        unsafe fn encode(
2098            self,
2099            encoder: &mut fidl::encoding::Encoder<'_, D>,
2100            offset: usize,
2101            depth: fidl::encoding::Depth,
2102        ) -> fidl::Result<()> {
2103            encoder.debug_check_bounds::<WlanFullmacImplIfcSaeFrameRxRequest>(offset);
2104            // Zero out padding regions. There's no need to apply masks
2105            // because the unmasked parts will be overwritten by fields.
2106            // Write the fields.
2107            self.0.encode(encoder, offset + 0, depth)?;
2108            Ok(())
2109        }
2110    }
2111
2112    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2113        for WlanFullmacImplIfcSaeFrameRxRequest
2114    {
2115        #[inline(always)]
2116        fn new_empty() -> Self {
2117            Self { frame: fidl::new_empty!(SaeFrame, D) }
2118        }
2119
2120        #[inline]
2121        unsafe fn decode(
2122            &mut self,
2123            decoder: &mut fidl::encoding::Decoder<'_, D>,
2124            offset: usize,
2125            _depth: fidl::encoding::Depth,
2126        ) -> fidl::Result<()> {
2127            decoder.debug_check_bounds::<Self>(offset);
2128            // Verify that padding bytes are zero.
2129            fidl::decode!(SaeFrame, D, &mut self.frame, decoder, offset + 0, _depth)?;
2130            Ok(())
2131        }
2132    }
2133
2134    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcSignalReportRequest {
2135        type Borrowed<'a> = &'a Self;
2136        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2137            value
2138        }
2139    }
2140
2141    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcSignalReportRequest {
2142        type Owned = Self;
2143
2144        #[inline(always)]
2145        fn inline_align(_context: fidl::encoding::Context) -> usize {
2146            1
2147        }
2148
2149        #[inline(always)]
2150        fn inline_size(_context: fidl::encoding::Context) -> usize {
2151            2
2152        }
2153        #[inline(always)]
2154        fn encode_is_copy() -> bool {
2155            true
2156        }
2157
2158        #[inline(always)]
2159        fn decode_is_copy() -> bool {
2160            true
2161        }
2162    }
2163
2164    unsafe impl<D: fidl::encoding::ResourceDialect>
2165        fidl::encoding::Encode<WlanFullmacImplIfcSignalReportRequest, D>
2166        for &WlanFullmacImplIfcSignalReportRequest
2167    {
2168        #[inline]
2169        unsafe fn encode(
2170            self,
2171            encoder: &mut fidl::encoding::Encoder<'_, D>,
2172            offset: usize,
2173            _depth: fidl::encoding::Depth,
2174        ) -> fidl::Result<()> {
2175            encoder.debug_check_bounds::<WlanFullmacImplIfcSignalReportRequest>(offset);
2176            unsafe {
2177                // Copy the object into the buffer.
2178                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2179                (buf_ptr as *mut WlanFullmacImplIfcSignalReportRequest)
2180                    .write_unaligned((self as *const WlanFullmacImplIfcSignalReportRequest).read());
2181                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2182                // done second because the memcpy will write garbage to these bytes.
2183            }
2184            Ok(())
2185        }
2186    }
2187    unsafe impl<
2188            D: fidl::encoding::ResourceDialect,
2189            T0: fidl::encoding::Encode<WlanFullmacSignalReportIndication, D>,
2190        > fidl::encoding::Encode<WlanFullmacImplIfcSignalReportRequest, D> for (T0,)
2191    {
2192        #[inline]
2193        unsafe fn encode(
2194            self,
2195            encoder: &mut fidl::encoding::Encoder<'_, D>,
2196            offset: usize,
2197            depth: fidl::encoding::Depth,
2198        ) -> fidl::Result<()> {
2199            encoder.debug_check_bounds::<WlanFullmacImplIfcSignalReportRequest>(offset);
2200            // Zero out padding regions. There's no need to apply masks
2201            // because the unmasked parts will be overwritten by fields.
2202            // Write the fields.
2203            self.0.encode(encoder, offset + 0, depth)?;
2204            Ok(())
2205        }
2206    }
2207
2208    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2209        for WlanFullmacImplIfcSignalReportRequest
2210    {
2211        #[inline(always)]
2212        fn new_empty() -> Self {
2213            Self { ind: fidl::new_empty!(WlanFullmacSignalReportIndication, D) }
2214        }
2215
2216        #[inline]
2217        unsafe fn decode(
2218            &mut self,
2219            decoder: &mut fidl::encoding::Decoder<'_, D>,
2220            offset: usize,
2221            _depth: fidl::encoding::Depth,
2222        ) -> fidl::Result<()> {
2223            decoder.debug_check_bounds::<Self>(offset);
2224            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2225            // Verify that padding bytes are zero.
2226            // Copy from the buffer into the object.
2227            unsafe {
2228                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2229            }
2230            Ok(())
2231        }
2232    }
2233
2234    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSaeFrameTxRequest {
2235        type Borrowed<'a> = &'a Self;
2236        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2237            value
2238        }
2239    }
2240
2241    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSaeFrameTxRequest {
2242        type Owned = Self;
2243
2244        #[inline(always)]
2245        fn inline_align(_context: fidl::encoding::Context) -> usize {
2246            8
2247        }
2248
2249        #[inline(always)]
2250        fn inline_size(_context: fidl::encoding::Context) -> usize {
2251            16
2252        }
2253    }
2254
2255    unsafe impl<D: fidl::encoding::ResourceDialect>
2256        fidl::encoding::Encode<WlanFullmacImplSaeFrameTxRequest, D>
2257        for &WlanFullmacImplSaeFrameTxRequest
2258    {
2259        #[inline]
2260        unsafe fn encode(
2261            self,
2262            encoder: &mut fidl::encoding::Encoder<'_, D>,
2263            offset: usize,
2264            _depth: fidl::encoding::Depth,
2265        ) -> fidl::Result<()> {
2266            encoder.debug_check_bounds::<WlanFullmacImplSaeFrameTxRequest>(offset);
2267            // Delegate to tuple encoding.
2268            fidl::encoding::Encode::<WlanFullmacImplSaeFrameTxRequest, D>::encode(
2269                (<SaeFrame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
2270                encoder,
2271                offset,
2272                _depth,
2273            )
2274        }
2275    }
2276    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SaeFrame, D>>
2277        fidl::encoding::Encode<WlanFullmacImplSaeFrameTxRequest, D> for (T0,)
2278    {
2279        #[inline]
2280        unsafe fn encode(
2281            self,
2282            encoder: &mut fidl::encoding::Encoder<'_, D>,
2283            offset: usize,
2284            depth: fidl::encoding::Depth,
2285        ) -> fidl::Result<()> {
2286            encoder.debug_check_bounds::<WlanFullmacImplSaeFrameTxRequest>(offset);
2287            // Zero out padding regions. There's no need to apply masks
2288            // because the unmasked parts will be overwritten by fields.
2289            // Write the fields.
2290            self.0.encode(encoder, offset + 0, depth)?;
2291            Ok(())
2292        }
2293    }
2294
2295    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2296        for WlanFullmacImplSaeFrameTxRequest
2297    {
2298        #[inline(always)]
2299        fn new_empty() -> Self {
2300            Self { frame: fidl::new_empty!(SaeFrame, D) }
2301        }
2302
2303        #[inline]
2304        unsafe fn decode(
2305            &mut self,
2306            decoder: &mut fidl::encoding::Decoder<'_, D>,
2307            offset: usize,
2308            _depth: fidl::encoding::Depth,
2309        ) -> fidl::Result<()> {
2310            decoder.debug_check_bounds::<Self>(offset);
2311            // Verify that padding bytes are zero.
2312            fidl::decode!(SaeFrame, D, &mut self.frame, decoder, offset + 0, _depth)?;
2313            Ok(())
2314        }
2315    }
2316
2317    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSetKeysResponse {
2318        type Borrowed<'a> = &'a Self;
2319        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2320            value
2321        }
2322    }
2323
2324    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSetKeysResponse {
2325        type Owned = Self;
2326
2327        #[inline(always)]
2328        fn inline_align(_context: fidl::encoding::Context) -> usize {
2329            8
2330        }
2331
2332        #[inline(always)]
2333        fn inline_size(_context: fidl::encoding::Context) -> usize {
2334            16
2335        }
2336    }
2337
2338    unsafe impl<D: fidl::encoding::ResourceDialect>
2339        fidl::encoding::Encode<WlanFullmacImplSetKeysResponse, D>
2340        for &WlanFullmacImplSetKeysResponse
2341    {
2342        #[inline]
2343        unsafe fn encode(
2344            self,
2345            encoder: &mut fidl::encoding::Encoder<'_, D>,
2346            offset: usize,
2347            _depth: fidl::encoding::Depth,
2348        ) -> fidl::Result<()> {
2349            encoder.debug_check_bounds::<WlanFullmacImplSetKeysResponse>(offset);
2350            // Delegate to tuple encoding.
2351            fidl::encoding::Encode::<WlanFullmacImplSetKeysResponse, D>::encode(
2352                (<WlanFullmacSetKeysResp as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
2353                encoder,
2354                offset,
2355                _depth,
2356            )
2357        }
2358    }
2359    unsafe impl<
2360            D: fidl::encoding::ResourceDialect,
2361            T0: fidl::encoding::Encode<WlanFullmacSetKeysResp, D>,
2362        > fidl::encoding::Encode<WlanFullmacImplSetKeysResponse, D> for (T0,)
2363    {
2364        #[inline]
2365        unsafe fn encode(
2366            self,
2367            encoder: &mut fidl::encoding::Encoder<'_, D>,
2368            offset: usize,
2369            depth: fidl::encoding::Depth,
2370        ) -> fidl::Result<()> {
2371            encoder.debug_check_bounds::<WlanFullmacImplSetKeysResponse>(offset);
2372            // Zero out padding regions. There's no need to apply masks
2373            // because the unmasked parts will be overwritten by fields.
2374            // Write the fields.
2375            self.0.encode(encoder, offset + 0, depth)?;
2376            Ok(())
2377        }
2378    }
2379
2380    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2381        for WlanFullmacImplSetKeysResponse
2382    {
2383        #[inline(always)]
2384        fn new_empty() -> Self {
2385            Self { resp: fidl::new_empty!(WlanFullmacSetKeysResp, D) }
2386        }
2387
2388        #[inline]
2389        unsafe fn decode(
2390            &mut self,
2391            decoder: &mut fidl::encoding::Decoder<'_, D>,
2392            offset: usize,
2393            _depth: fidl::encoding::Depth,
2394        ) -> fidl::Result<()> {
2395            decoder.debug_check_bounds::<Self>(offset);
2396            // Verify that padding bytes are zero.
2397            fidl::decode!(WlanFullmacSetKeysResp, D, &mut self.resp, decoder, offset + 0, _depth)?;
2398            Ok(())
2399        }
2400    }
2401
2402    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplGetIfaceHistogramStatsResponse {
2403        type Borrowed<'a> = &'a Self;
2404        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2405            value
2406        }
2407    }
2408
2409    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplGetIfaceHistogramStatsResponse {
2410        type Owned = Self;
2411
2412        #[inline(always)]
2413        fn inline_align(_context: fidl::encoding::Context) -> usize {
2414            8
2415        }
2416
2417        #[inline(always)]
2418        fn inline_size(_context: fidl::encoding::Context) -> usize {
2419            16
2420        }
2421    }
2422
2423    unsafe impl<D: fidl::encoding::ResourceDialect>
2424        fidl::encoding::Encode<WlanFullmacImplGetIfaceHistogramStatsResponse, D>
2425        for &WlanFullmacImplGetIfaceHistogramStatsResponse
2426    {
2427        #[inline]
2428        unsafe fn encode(
2429            self,
2430            encoder: &mut fidl::encoding::Encoder<'_, D>,
2431            offset: usize,
2432            _depth: fidl::encoding::Depth,
2433        ) -> fidl::Result<()> {
2434            encoder.debug_check_bounds::<WlanFullmacImplGetIfaceHistogramStatsResponse>(offset);
2435            // Delegate to tuple encoding.
2436            fidl::encoding::Encode::<WlanFullmacImplGetIfaceHistogramStatsResponse, D>::encode(
2437                (
2438                    <fidl_fuchsia_wlan_stats__common::IfaceHistogramStats as fidl::encoding::ValueTypeMarker>::borrow(&self.stats),
2439                ),
2440                encoder, offset, _depth
2441            )
2442        }
2443    }
2444    unsafe impl<
2445            D: fidl::encoding::ResourceDialect,
2446            T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D>,
2447        > fidl::encoding::Encode<WlanFullmacImplGetIfaceHistogramStatsResponse, D> for (T0,)
2448    {
2449        #[inline]
2450        unsafe fn encode(
2451            self,
2452            encoder: &mut fidl::encoding::Encoder<'_, D>,
2453            offset: usize,
2454            depth: fidl::encoding::Depth,
2455        ) -> fidl::Result<()> {
2456            encoder.debug_check_bounds::<WlanFullmacImplGetIfaceHistogramStatsResponse>(offset);
2457            // Zero out padding regions. There's no need to apply masks
2458            // because the unmasked parts will be overwritten by fields.
2459            // Write the fields.
2460            self.0.encode(encoder, offset + 0, depth)?;
2461            Ok(())
2462        }
2463    }
2464
2465    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2466        for WlanFullmacImplGetIfaceHistogramStatsResponse
2467    {
2468        #[inline(always)]
2469        fn new_empty() -> Self {
2470            Self {
2471                stats: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D),
2472            }
2473        }
2474
2475        #[inline]
2476        unsafe fn decode(
2477            &mut self,
2478            decoder: &mut fidl::encoding::Decoder<'_, D>,
2479            offset: usize,
2480            _depth: fidl::encoding::Depth,
2481        ) -> fidl::Result<()> {
2482            decoder.debug_check_bounds::<Self>(offset);
2483            // Verify that padding bytes are zero.
2484            fidl::decode!(
2485                fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
2486                D,
2487                &mut self.stats,
2488                decoder,
2489                offset + 0,
2490                _depth
2491            )?;
2492            Ok(())
2493        }
2494    }
2495
2496    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplGetIfaceStatsResponse {
2497        type Borrowed<'a> = &'a Self;
2498        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2499            value
2500        }
2501    }
2502
2503    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplGetIfaceStatsResponse {
2504        type Owned = Self;
2505
2506        #[inline(always)]
2507        fn inline_align(_context: fidl::encoding::Context) -> usize {
2508            8
2509        }
2510
2511        #[inline(always)]
2512        fn inline_size(_context: fidl::encoding::Context) -> usize {
2513            16
2514        }
2515    }
2516
2517    unsafe impl<D: fidl::encoding::ResourceDialect>
2518        fidl::encoding::Encode<WlanFullmacImplGetIfaceStatsResponse, D>
2519        for &WlanFullmacImplGetIfaceStatsResponse
2520    {
2521        #[inline]
2522        unsafe fn encode(
2523            self,
2524            encoder: &mut fidl::encoding::Encoder<'_, D>,
2525            offset: usize,
2526            _depth: fidl::encoding::Depth,
2527        ) -> fidl::Result<()> {
2528            encoder.debug_check_bounds::<WlanFullmacImplGetIfaceStatsResponse>(offset);
2529            // Delegate to tuple encoding.
2530            fidl::encoding::Encode::<WlanFullmacImplGetIfaceStatsResponse, D>::encode(
2531                (
2532                    <fidl_fuchsia_wlan_stats__common::IfaceStats as fidl::encoding::ValueTypeMarker>::borrow(&self.stats),
2533                ),
2534                encoder, offset, _depth
2535            )
2536        }
2537    }
2538    unsafe impl<
2539            D: fidl::encoding::ResourceDialect,
2540            T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::IfaceStats, D>,
2541        > fidl::encoding::Encode<WlanFullmacImplGetIfaceStatsResponse, D> for (T0,)
2542    {
2543        #[inline]
2544        unsafe fn encode(
2545            self,
2546            encoder: &mut fidl::encoding::Encoder<'_, D>,
2547            offset: usize,
2548            depth: fidl::encoding::Depth,
2549        ) -> fidl::Result<()> {
2550            encoder.debug_check_bounds::<WlanFullmacImplGetIfaceStatsResponse>(offset);
2551            // Zero out padding regions. There's no need to apply masks
2552            // because the unmasked parts will be overwritten by fields.
2553            // Write the fields.
2554            self.0.encode(encoder, offset + 0, depth)?;
2555            Ok(())
2556        }
2557    }
2558
2559    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2560        for WlanFullmacImplGetIfaceStatsResponse
2561    {
2562        #[inline(always)]
2563        fn new_empty() -> Self {
2564            Self { stats: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceStats, D) }
2565        }
2566
2567        #[inline]
2568        unsafe fn decode(
2569            &mut self,
2570            decoder: &mut fidl::encoding::Decoder<'_, D>,
2571            offset: usize,
2572            _depth: fidl::encoding::Depth,
2573        ) -> fidl::Result<()> {
2574            decoder.debug_check_bounds::<Self>(offset);
2575            // Verify that padding bytes are zero.
2576            fidl::decode!(
2577                fidl_fuchsia_wlan_stats__common::IfaceStats,
2578                D,
2579                &mut self.stats,
2580                decoder,
2581                offset + 0,
2582                _depth
2583            )?;
2584            Ok(())
2585        }
2586    }
2587
2588    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQuerySecuritySupportResponse {
2589        type Borrowed<'a> = &'a Self;
2590        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2591            value
2592        }
2593    }
2594
2595    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQuerySecuritySupportResponse {
2596        type Owned = Self;
2597
2598        #[inline(always)]
2599        fn inline_align(_context: fidl::encoding::Context) -> usize {
2600            1
2601        }
2602
2603        #[inline(always)]
2604        fn inline_size(_context: fidl::encoding::Context) -> usize {
2605            3
2606        }
2607    }
2608
2609    unsafe impl<D: fidl::encoding::ResourceDialect>
2610        fidl::encoding::Encode<WlanFullmacImplQuerySecuritySupportResponse, D>
2611        for &WlanFullmacImplQuerySecuritySupportResponse
2612    {
2613        #[inline]
2614        unsafe fn encode(
2615            self,
2616            encoder: &mut fidl::encoding::Encoder<'_, D>,
2617            offset: usize,
2618            _depth: fidl::encoding::Depth,
2619        ) -> fidl::Result<()> {
2620            encoder.debug_check_bounds::<WlanFullmacImplQuerySecuritySupportResponse>(offset);
2621            // Delegate to tuple encoding.
2622            fidl::encoding::Encode::<WlanFullmacImplQuerySecuritySupportResponse, D>::encode(
2623                (
2624                    <fidl_fuchsia_wlan_common__common::SecuritySupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
2625                ),
2626                encoder, offset, _depth
2627            )
2628        }
2629    }
2630    unsafe impl<
2631            D: fidl::encoding::ResourceDialect,
2632            T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::SecuritySupport, D>,
2633        > fidl::encoding::Encode<WlanFullmacImplQuerySecuritySupportResponse, D> for (T0,)
2634    {
2635        #[inline]
2636        unsafe fn encode(
2637            self,
2638            encoder: &mut fidl::encoding::Encoder<'_, D>,
2639            offset: usize,
2640            depth: fidl::encoding::Depth,
2641        ) -> fidl::Result<()> {
2642            encoder.debug_check_bounds::<WlanFullmacImplQuerySecuritySupportResponse>(offset);
2643            // Zero out padding regions. There's no need to apply masks
2644            // because the unmasked parts will be overwritten by fields.
2645            // Write the fields.
2646            self.0.encode(encoder, offset + 0, depth)?;
2647            Ok(())
2648        }
2649    }
2650
2651    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2652        for WlanFullmacImplQuerySecuritySupportResponse
2653    {
2654        #[inline(always)]
2655        fn new_empty() -> Self {
2656            Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_common__common::SecuritySupport, D) }
2657        }
2658
2659        #[inline]
2660        unsafe fn decode(
2661            &mut self,
2662            decoder: &mut fidl::encoding::Decoder<'_, D>,
2663            offset: usize,
2664            _depth: fidl::encoding::Depth,
2665        ) -> fidl::Result<()> {
2666            decoder.debug_check_bounds::<Self>(offset);
2667            // Verify that padding bytes are zero.
2668            fidl::decode!(
2669                fidl_fuchsia_wlan_common__common::SecuritySupport,
2670                D,
2671                &mut self.resp,
2672                decoder,
2673                offset + 0,
2674                _depth
2675            )?;
2676            Ok(())
2677        }
2678    }
2679
2680    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQuerySpectrumManagementSupportResponse {
2681        type Borrowed<'a> = &'a Self;
2682        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2683            value
2684        }
2685    }
2686
2687    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQuerySpectrumManagementSupportResponse {
2688        type Owned = Self;
2689
2690        #[inline(always)]
2691        fn inline_align(_context: fidl::encoding::Context) -> usize {
2692            1
2693        }
2694
2695        #[inline(always)]
2696        fn inline_size(_context: fidl::encoding::Context) -> usize {
2697            1
2698        }
2699    }
2700
2701    unsafe impl<D: fidl::encoding::ResourceDialect>
2702        fidl::encoding::Encode<WlanFullmacImplQuerySpectrumManagementSupportResponse, D>
2703        for &WlanFullmacImplQuerySpectrumManagementSupportResponse
2704    {
2705        #[inline]
2706        unsafe fn encode(
2707            self,
2708            encoder: &mut fidl::encoding::Encoder<'_, D>,
2709            offset: usize,
2710            _depth: fidl::encoding::Depth,
2711        ) -> fidl::Result<()> {
2712            encoder.debug_check_bounds::<WlanFullmacImplQuerySpectrumManagementSupportResponse>(
2713                offset,
2714            );
2715            // Delegate to tuple encoding.
2716            fidl::encoding::Encode::<WlanFullmacImplQuerySpectrumManagementSupportResponse, D>::encode(
2717                (
2718                    <fidl_fuchsia_wlan_common__common::SpectrumManagementSupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
2719                ),
2720                encoder, offset, _depth
2721            )
2722        }
2723    }
2724    unsafe impl<
2725            D: fidl::encoding::ResourceDialect,
2726            T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::SpectrumManagementSupport, D>,
2727        > fidl::encoding::Encode<WlanFullmacImplQuerySpectrumManagementSupportResponse, D>
2728        for (T0,)
2729    {
2730        #[inline]
2731        unsafe fn encode(
2732            self,
2733            encoder: &mut fidl::encoding::Encoder<'_, D>,
2734            offset: usize,
2735            depth: fidl::encoding::Depth,
2736        ) -> fidl::Result<()> {
2737            encoder.debug_check_bounds::<WlanFullmacImplQuerySpectrumManagementSupportResponse>(
2738                offset,
2739            );
2740            // Zero out padding regions. There's no need to apply masks
2741            // because the unmasked parts will be overwritten by fields.
2742            // Write the fields.
2743            self.0.encode(encoder, offset + 0, depth)?;
2744            Ok(())
2745        }
2746    }
2747
2748    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2749        for WlanFullmacImplQuerySpectrumManagementSupportResponse
2750    {
2751        #[inline(always)]
2752        fn new_empty() -> Self {
2753            Self {
2754                resp: fidl::new_empty!(
2755                    fidl_fuchsia_wlan_common__common::SpectrumManagementSupport,
2756                    D
2757                ),
2758            }
2759        }
2760
2761        #[inline]
2762        unsafe fn decode(
2763            &mut self,
2764            decoder: &mut fidl::encoding::Decoder<'_, D>,
2765            offset: usize,
2766            _depth: fidl::encoding::Depth,
2767        ) -> fidl::Result<()> {
2768            decoder.debug_check_bounds::<Self>(offset);
2769            // Verify that padding bytes are zero.
2770            fidl::decode!(
2771                fidl_fuchsia_wlan_common__common::SpectrumManagementSupport,
2772                D,
2773                &mut self.resp,
2774                decoder,
2775                offset + 0,
2776                _depth
2777            )?;
2778            Ok(())
2779        }
2780    }
2781
2782    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQueryTelemetrySupportResponse {
2783        type Borrowed<'a> = &'a Self;
2784        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2785            value
2786        }
2787    }
2788
2789    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQueryTelemetrySupportResponse {
2790        type Owned = Self;
2791
2792        #[inline(always)]
2793        fn inline_align(_context: fidl::encoding::Context) -> usize {
2794            8
2795        }
2796
2797        #[inline(always)]
2798        fn inline_size(_context: fidl::encoding::Context) -> usize {
2799            16
2800        }
2801    }
2802
2803    unsafe impl<D: fidl::encoding::ResourceDialect>
2804        fidl::encoding::Encode<WlanFullmacImplQueryTelemetrySupportResponse, D>
2805        for &WlanFullmacImplQueryTelemetrySupportResponse
2806    {
2807        #[inline]
2808        unsafe fn encode(
2809            self,
2810            encoder: &mut fidl::encoding::Encoder<'_, D>,
2811            offset: usize,
2812            _depth: fidl::encoding::Depth,
2813        ) -> fidl::Result<()> {
2814            encoder.debug_check_bounds::<WlanFullmacImplQueryTelemetrySupportResponse>(offset);
2815            // Delegate to tuple encoding.
2816            fidl::encoding::Encode::<WlanFullmacImplQueryTelemetrySupportResponse, D>::encode(
2817                (
2818                    <fidl_fuchsia_wlan_stats__common::TelemetrySupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
2819                ),
2820                encoder, offset, _depth
2821            )
2822        }
2823    }
2824    unsafe impl<
2825            D: fidl::encoding::ResourceDialect,
2826            T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::TelemetrySupport, D>,
2827        > fidl::encoding::Encode<WlanFullmacImplQueryTelemetrySupportResponse, D> for (T0,)
2828    {
2829        #[inline]
2830        unsafe fn encode(
2831            self,
2832            encoder: &mut fidl::encoding::Encoder<'_, D>,
2833            offset: usize,
2834            depth: fidl::encoding::Depth,
2835        ) -> fidl::Result<()> {
2836            encoder.debug_check_bounds::<WlanFullmacImplQueryTelemetrySupportResponse>(offset);
2837            // Zero out padding regions. There's no need to apply masks
2838            // because the unmasked parts will be overwritten by fields.
2839            // Write the fields.
2840            self.0.encode(encoder, offset + 0, depth)?;
2841            Ok(())
2842        }
2843    }
2844
2845    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2846        for WlanFullmacImplQueryTelemetrySupportResponse
2847    {
2848        #[inline(always)]
2849        fn new_empty() -> Self {
2850            Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::TelemetrySupport, D) }
2851        }
2852
2853        #[inline]
2854        unsafe fn decode(
2855            &mut self,
2856            decoder: &mut fidl::encoding::Decoder<'_, D>,
2857            offset: usize,
2858            _depth: fidl::encoding::Depth,
2859        ) -> fidl::Result<()> {
2860            decoder.debug_check_bounds::<Self>(offset);
2861            // Verify that padding bytes are zero.
2862            fidl::decode!(
2863                fidl_fuchsia_wlan_stats__common::TelemetrySupport,
2864                D,
2865                &mut self.resp,
2866                decoder,
2867                offset + 0,
2868                _depth
2869            )?;
2870            Ok(())
2871        }
2872    }
2873
2874    impl fidl::encoding::ValueTypeMarker for WlanFullmacRssiStats {
2875        type Borrowed<'a> = &'a Self;
2876        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2877            value
2878        }
2879    }
2880
2881    unsafe impl fidl::encoding::TypeMarker for WlanFullmacRssiStats {
2882        type Owned = Self;
2883
2884        #[inline(always)]
2885        fn inline_align(_context: fidl::encoding::Context) -> usize {
2886            8
2887        }
2888
2889        #[inline(always)]
2890        fn inline_size(_context: fidl::encoding::Context) -> usize {
2891            16
2892        }
2893    }
2894
2895    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WlanFullmacRssiStats, D>
2896        for &WlanFullmacRssiStats
2897    {
2898        #[inline]
2899        unsafe fn encode(
2900            self,
2901            encoder: &mut fidl::encoding::Encoder<'_, D>,
2902            offset: usize,
2903            _depth: fidl::encoding::Depth,
2904        ) -> fidl::Result<()> {
2905            encoder.debug_check_bounds::<WlanFullmacRssiStats>(offset);
2906            // Delegate to tuple encoding.
2907            fidl::encoding::Encode::<WlanFullmacRssiStats, D>::encode(
2908                (
2909                    <fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(&self.hist),
2910                ),
2911                encoder, offset, _depth
2912            )
2913        }
2914    }
2915    unsafe impl<
2916            D: fidl::encoding::ResourceDialect,
2917            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u64>, D>,
2918        > fidl::encoding::Encode<WlanFullmacRssiStats, D> for (T0,)
2919    {
2920        #[inline]
2921        unsafe fn encode(
2922            self,
2923            encoder: &mut fidl::encoding::Encoder<'_, D>,
2924            offset: usize,
2925            depth: fidl::encoding::Depth,
2926        ) -> fidl::Result<()> {
2927            encoder.debug_check_bounds::<WlanFullmacRssiStats>(offset);
2928            // Zero out padding regions. There's no need to apply masks
2929            // because the unmasked parts will be overwritten by fields.
2930            // Write the fields.
2931            self.0.encode(encoder, offset + 0, depth)?;
2932            Ok(())
2933        }
2934    }
2935
2936    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanFullmacRssiStats {
2937        #[inline(always)]
2938        fn new_empty() -> Self {
2939            Self { hist: fidl::new_empty!(fidl::encoding::UnboundedVector<u64>, D) }
2940        }
2941
2942        #[inline]
2943        unsafe fn decode(
2944            &mut self,
2945            decoder: &mut fidl::encoding::Decoder<'_, D>,
2946            offset: usize,
2947            _depth: fidl::encoding::Depth,
2948        ) -> fidl::Result<()> {
2949            decoder.debug_check_bounds::<Self>(offset);
2950            // Verify that padding bytes are zero.
2951            fidl::decode!(
2952                fidl::encoding::UnboundedVector<u64>,
2953                D,
2954                &mut self.hist,
2955                decoder,
2956                offset + 0,
2957                _depth
2958            )?;
2959            Ok(())
2960        }
2961    }
2962
2963    impl fidl::encoding::ValueTypeMarker for WlanFullmacSetKeysResp {
2964        type Borrowed<'a> = &'a Self;
2965        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2966            value
2967        }
2968    }
2969
2970    unsafe impl fidl::encoding::TypeMarker for WlanFullmacSetKeysResp {
2971        type Owned = Self;
2972
2973        #[inline(always)]
2974        fn inline_align(_context: fidl::encoding::Context) -> usize {
2975            8
2976        }
2977
2978        #[inline(always)]
2979        fn inline_size(_context: fidl::encoding::Context) -> usize {
2980            16
2981        }
2982    }
2983
2984    unsafe impl<D: fidl::encoding::ResourceDialect>
2985        fidl::encoding::Encode<WlanFullmacSetKeysResp, D> for &WlanFullmacSetKeysResp
2986    {
2987        #[inline]
2988        unsafe fn encode(
2989            self,
2990            encoder: &mut fidl::encoding::Encoder<'_, D>,
2991            offset: usize,
2992            _depth: fidl::encoding::Depth,
2993        ) -> fidl::Result<()> {
2994            encoder.debug_check_bounds::<WlanFullmacSetKeysResp>(offset);
2995            // Delegate to tuple encoding.
2996            fidl::encoding::Encode::<WlanFullmacSetKeysResp, D>::encode(
2997                (<fidl::encoding::Vector<i32, 4> as fidl::encoding::ValueTypeMarker>::borrow(
2998                    &self.statuslist,
2999                ),),
3000                encoder,
3001                offset,
3002                _depth,
3003            )
3004        }
3005    }
3006    unsafe impl<
3007            D: fidl::encoding::ResourceDialect,
3008            T0: fidl::encoding::Encode<fidl::encoding::Vector<i32, 4>, D>,
3009        > fidl::encoding::Encode<WlanFullmacSetKeysResp, D> for (T0,)
3010    {
3011        #[inline]
3012        unsafe fn encode(
3013            self,
3014            encoder: &mut fidl::encoding::Encoder<'_, D>,
3015            offset: usize,
3016            depth: fidl::encoding::Depth,
3017        ) -> fidl::Result<()> {
3018            encoder.debug_check_bounds::<WlanFullmacSetKeysResp>(offset);
3019            // Zero out padding regions. There's no need to apply masks
3020            // because the unmasked parts will be overwritten by fields.
3021            // Write the fields.
3022            self.0.encode(encoder, offset + 0, depth)?;
3023            Ok(())
3024        }
3025    }
3026
3027    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3028        for WlanFullmacSetKeysResp
3029    {
3030        #[inline(always)]
3031        fn new_empty() -> Self {
3032            Self { statuslist: fidl::new_empty!(fidl::encoding::Vector<i32, 4>, D) }
3033        }
3034
3035        #[inline]
3036        unsafe fn decode(
3037            &mut self,
3038            decoder: &mut fidl::encoding::Decoder<'_, D>,
3039            offset: usize,
3040            _depth: fidl::encoding::Depth,
3041        ) -> fidl::Result<()> {
3042            decoder.debug_check_bounds::<Self>(offset);
3043            // Verify that padding bytes are zero.
3044            fidl::decode!(fidl::encoding::Vector<i32, 4>, D, &mut self.statuslist, decoder, offset + 0, _depth)?;
3045            Ok(())
3046        }
3047    }
3048
3049    impl fidl::encoding::ValueTypeMarker for WlanFullmacSignalReportIndication {
3050        type Borrowed<'a> = &'a Self;
3051        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3052            value
3053        }
3054    }
3055
3056    unsafe impl fidl::encoding::TypeMarker for WlanFullmacSignalReportIndication {
3057        type Owned = Self;
3058
3059        #[inline(always)]
3060        fn inline_align(_context: fidl::encoding::Context) -> usize {
3061            1
3062        }
3063
3064        #[inline(always)]
3065        fn inline_size(_context: fidl::encoding::Context) -> usize {
3066            2
3067        }
3068        #[inline(always)]
3069        fn encode_is_copy() -> bool {
3070            true
3071        }
3072
3073        #[inline(always)]
3074        fn decode_is_copy() -> bool {
3075            true
3076        }
3077    }
3078
3079    unsafe impl<D: fidl::encoding::ResourceDialect>
3080        fidl::encoding::Encode<WlanFullmacSignalReportIndication, D>
3081        for &WlanFullmacSignalReportIndication
3082    {
3083        #[inline]
3084        unsafe fn encode(
3085            self,
3086            encoder: &mut fidl::encoding::Encoder<'_, D>,
3087            offset: usize,
3088            _depth: fidl::encoding::Depth,
3089        ) -> fidl::Result<()> {
3090            encoder.debug_check_bounds::<WlanFullmacSignalReportIndication>(offset);
3091            unsafe {
3092                // Copy the object into the buffer.
3093                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3094                (buf_ptr as *mut WlanFullmacSignalReportIndication)
3095                    .write_unaligned((self as *const WlanFullmacSignalReportIndication).read());
3096                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
3097                // done second because the memcpy will write garbage to these bytes.
3098            }
3099            Ok(())
3100        }
3101    }
3102    unsafe impl<
3103            D: fidl::encoding::ResourceDialect,
3104            T0: fidl::encoding::Encode<i8, D>,
3105            T1: fidl::encoding::Encode<i8, D>,
3106        > fidl::encoding::Encode<WlanFullmacSignalReportIndication, D> for (T0, T1)
3107    {
3108        #[inline]
3109        unsafe fn encode(
3110            self,
3111            encoder: &mut fidl::encoding::Encoder<'_, D>,
3112            offset: usize,
3113            depth: fidl::encoding::Depth,
3114        ) -> fidl::Result<()> {
3115            encoder.debug_check_bounds::<WlanFullmacSignalReportIndication>(offset);
3116            // Zero out padding regions. There's no need to apply masks
3117            // because the unmasked parts will be overwritten by fields.
3118            // Write the fields.
3119            self.0.encode(encoder, offset + 0, depth)?;
3120            self.1.encode(encoder, offset + 1, depth)?;
3121            Ok(())
3122        }
3123    }
3124
3125    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3126        for WlanFullmacSignalReportIndication
3127    {
3128        #[inline(always)]
3129        fn new_empty() -> Self {
3130            Self { rssi_dbm: fidl::new_empty!(i8, D), snr_db: fidl::new_empty!(i8, D) }
3131        }
3132
3133        #[inline]
3134        unsafe fn decode(
3135            &mut self,
3136            decoder: &mut fidl::encoding::Decoder<'_, D>,
3137            offset: usize,
3138            _depth: fidl::encoding::Depth,
3139        ) -> fidl::Result<()> {
3140            decoder.debug_check_bounds::<Self>(offset);
3141            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3142            // Verify that padding bytes are zero.
3143            // Copy from the buffer into the object.
3144            unsafe {
3145                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
3146            }
3147            Ok(())
3148        }
3149    }
3150
3151    impl BandCapability {
3152        #[inline(always)]
3153        fn max_ordinal_present(&self) -> u64 {
3154            if let Some(_) = self.operating_channels {
3155                return 5;
3156            }
3157            if let Some(_) = self.vht_caps {
3158                return 4;
3159            }
3160            if let Some(_) = self.ht_caps {
3161                return 3;
3162            }
3163            if let Some(_) = self.basic_rates {
3164                return 2;
3165            }
3166            if let Some(_) = self.band {
3167                return 1;
3168            }
3169            0
3170        }
3171    }
3172
3173    impl fidl::encoding::ValueTypeMarker for BandCapability {
3174        type Borrowed<'a> = &'a Self;
3175        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3176            value
3177        }
3178    }
3179
3180    unsafe impl fidl::encoding::TypeMarker for BandCapability {
3181        type Owned = Self;
3182
3183        #[inline(always)]
3184        fn inline_align(_context: fidl::encoding::Context) -> usize {
3185            8
3186        }
3187
3188        #[inline(always)]
3189        fn inline_size(_context: fidl::encoding::Context) -> usize {
3190            16
3191        }
3192    }
3193
3194    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BandCapability, D>
3195        for &BandCapability
3196    {
3197        unsafe fn encode(
3198            self,
3199            encoder: &mut fidl::encoding::Encoder<'_, D>,
3200            offset: usize,
3201            mut depth: fidl::encoding::Depth,
3202        ) -> fidl::Result<()> {
3203            encoder.debug_check_bounds::<BandCapability>(offset);
3204            // Vector header
3205            let max_ordinal: u64 = self.max_ordinal_present();
3206            encoder.write_num(max_ordinal, offset);
3207            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3208            // Calling encoder.out_of_line_offset(0) is not allowed.
3209            if max_ordinal == 0 {
3210                return Ok(());
3211            }
3212            depth.increment()?;
3213            let envelope_size = 8;
3214            let bytes_len = max_ordinal as usize * envelope_size;
3215            #[allow(unused_variables)]
3216            let offset = encoder.out_of_line_offset(bytes_len);
3217            let mut _prev_end_offset: usize = 0;
3218            if 1 > max_ordinal {
3219                return Ok(());
3220            }
3221
3222            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3223            // are envelope_size bytes.
3224            let cur_offset: usize = (1 - 1) * envelope_size;
3225
3226            // Zero reserved fields.
3227            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3228
3229            // Safety:
3230            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3231            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3232            //   envelope_size bytes, there is always sufficient room.
3233            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::WlanBand, D>(
3234            self.band.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::WlanBand as fidl::encoding::ValueTypeMarker>::borrow),
3235            encoder, offset + cur_offset, depth
3236        )?;
3237
3238            _prev_end_offset = cur_offset + envelope_size;
3239            if 2 > max_ordinal {
3240                return Ok(());
3241            }
3242
3243            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3244            // are envelope_size bytes.
3245            let cur_offset: usize = (2 - 1) * envelope_size;
3246
3247            // Zero reserved fields.
3248            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3249
3250            // Safety:
3251            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3252            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3253            //   envelope_size bytes, there is always sufficient room.
3254            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 12>, D>(
3255                self.basic_rates.as_ref().map(
3256                    <fidl::encoding::Vector<u8, 12> as fidl::encoding::ValueTypeMarker>::borrow,
3257                ),
3258                encoder,
3259                offset + cur_offset,
3260                depth,
3261            )?;
3262
3263            _prev_end_offset = cur_offset + envelope_size;
3264            if 3 > max_ordinal {
3265                return Ok(());
3266            }
3267
3268            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3269            // are envelope_size bytes.
3270            let cur_offset: usize = (3 - 1) * envelope_size;
3271
3272            // Zero reserved fields.
3273            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3274
3275            // Safety:
3276            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3277            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3278            //   envelope_size bytes, there is always sufficient room.
3279            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities, D>(
3280            self.ht_caps.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
3281            encoder, offset + cur_offset, depth
3282        )?;
3283
3284            _prev_end_offset = cur_offset + envelope_size;
3285            if 4 > max_ordinal {
3286                return Ok(());
3287            }
3288
3289            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3290            // are envelope_size bytes.
3291            let cur_offset: usize = (4 - 1) * envelope_size;
3292
3293            // Zero reserved fields.
3294            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3295
3296            // Safety:
3297            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3298            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3299            //   envelope_size bytes, there is always sufficient room.
3300            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities, D>(
3301            self.vht_caps.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
3302            encoder, offset + cur_offset, depth
3303        )?;
3304
3305            _prev_end_offset = cur_offset + envelope_size;
3306            if 5 > max_ordinal {
3307                return Ok(());
3308            }
3309
3310            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3311            // are envelope_size bytes.
3312            let cur_offset: usize = (5 - 1) * envelope_size;
3313
3314            // Zero reserved fields.
3315            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3316
3317            // Safety:
3318            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3319            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3320            //   envelope_size bytes, there is always sufficient room.
3321            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 256>, D>(
3322                self.operating_channels.as_ref().map(
3323                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow,
3324                ),
3325                encoder,
3326                offset + cur_offset,
3327                depth,
3328            )?;
3329
3330            _prev_end_offset = cur_offset + envelope_size;
3331
3332            Ok(())
3333        }
3334    }
3335
3336    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BandCapability {
3337        #[inline(always)]
3338        fn new_empty() -> Self {
3339            Self::default()
3340        }
3341
3342        unsafe fn decode(
3343            &mut self,
3344            decoder: &mut fidl::encoding::Decoder<'_, D>,
3345            offset: usize,
3346            mut depth: fidl::encoding::Depth,
3347        ) -> fidl::Result<()> {
3348            decoder.debug_check_bounds::<Self>(offset);
3349            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3350                None => return Err(fidl::Error::NotNullable),
3351                Some(len) => len,
3352            };
3353            // Calling decoder.out_of_line_offset(0) is not allowed.
3354            if len == 0 {
3355                return Ok(());
3356            };
3357            depth.increment()?;
3358            let envelope_size = 8;
3359            let bytes_len = len * envelope_size;
3360            let offset = decoder.out_of_line_offset(bytes_len)?;
3361            // Decode the envelope for each type.
3362            let mut _next_ordinal_to_read = 0;
3363            let mut next_offset = offset;
3364            let end_offset = offset + bytes_len;
3365            _next_ordinal_to_read += 1;
3366            if next_offset >= end_offset {
3367                return Ok(());
3368            }
3369
3370            // Decode unknown envelopes for gaps in ordinals.
3371            while _next_ordinal_to_read < 1 {
3372                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3373                _next_ordinal_to_read += 1;
3374                next_offset += envelope_size;
3375            }
3376
3377            let next_out_of_line = decoder.next_out_of_line();
3378            let handles_before = decoder.remaining_handles();
3379            if let Some((inlined, num_bytes, num_handles)) =
3380                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3381            {
3382                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::WlanBand as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3383                if inlined != (member_inline_size <= 4) {
3384                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3385                }
3386                let inner_offset;
3387                let mut inner_depth = depth.clone();
3388                if inlined {
3389                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3390                    inner_offset = next_offset;
3391                } else {
3392                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3393                    inner_depth.increment()?;
3394                }
3395                let val_ref = self.band.get_or_insert_with(|| {
3396                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::WlanBand, D)
3397                });
3398                fidl::decode!(
3399                    fidl_fuchsia_wlan_ieee80211__common::WlanBand,
3400                    D,
3401                    val_ref,
3402                    decoder,
3403                    inner_offset,
3404                    inner_depth
3405                )?;
3406                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3407                {
3408                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3409                }
3410                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3411                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3412                }
3413            }
3414
3415            next_offset += envelope_size;
3416            _next_ordinal_to_read += 1;
3417            if next_offset >= end_offset {
3418                return Ok(());
3419            }
3420
3421            // Decode unknown envelopes for gaps in ordinals.
3422            while _next_ordinal_to_read < 2 {
3423                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3424                _next_ordinal_to_read += 1;
3425                next_offset += envelope_size;
3426            }
3427
3428            let next_out_of_line = decoder.next_out_of_line();
3429            let handles_before = decoder.remaining_handles();
3430            if let Some((inlined, num_bytes, num_handles)) =
3431                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3432            {
3433                let member_inline_size =
3434                    <fidl::encoding::Vector<u8, 12> as fidl::encoding::TypeMarker>::inline_size(
3435                        decoder.context,
3436                    );
3437                if inlined != (member_inline_size <= 4) {
3438                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3439                }
3440                let inner_offset;
3441                let mut inner_depth = depth.clone();
3442                if inlined {
3443                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3444                    inner_offset = next_offset;
3445                } else {
3446                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3447                    inner_depth.increment()?;
3448                }
3449                let val_ref = self
3450                    .basic_rates
3451                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 12>, D));
3452                fidl::decode!(fidl::encoding::Vector<u8, 12>, D, val_ref, decoder, inner_offset, inner_depth)?;
3453                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3454                {
3455                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3456                }
3457                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3458                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3459                }
3460            }
3461
3462            next_offset += envelope_size;
3463            _next_ordinal_to_read += 1;
3464            if next_offset >= end_offset {
3465                return Ok(());
3466            }
3467
3468            // Decode unknown envelopes for gaps in ordinals.
3469            while _next_ordinal_to_read < 3 {
3470                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3471                _next_ordinal_to_read += 1;
3472                next_offset += envelope_size;
3473            }
3474
3475            let next_out_of_line = decoder.next_out_of_line();
3476            let handles_before = decoder.remaining_handles();
3477            if let Some((inlined, num_bytes, num_handles)) =
3478                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3479            {
3480                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::HtCapabilities as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3481                if inlined != (member_inline_size <= 4) {
3482                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3483                }
3484                let inner_offset;
3485                let mut inner_depth = depth.clone();
3486                if inlined {
3487                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3488                    inner_offset = next_offset;
3489                } else {
3490                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3491                    inner_depth.increment()?;
3492                }
3493                let val_ref = self.ht_caps.get_or_insert_with(|| {
3494                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::HtCapabilities, D)
3495                });
3496                fidl::decode!(
3497                    fidl_fuchsia_wlan_ieee80211__common::HtCapabilities,
3498                    D,
3499                    val_ref,
3500                    decoder,
3501                    inner_offset,
3502                    inner_depth
3503                )?;
3504                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3505                {
3506                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3507                }
3508                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3509                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3510                }
3511            }
3512
3513            next_offset += envelope_size;
3514            _next_ordinal_to_read += 1;
3515            if next_offset >= end_offset {
3516                return Ok(());
3517            }
3518
3519            // Decode unknown envelopes for gaps in ordinals.
3520            while _next_ordinal_to_read < 4 {
3521                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3522                _next_ordinal_to_read += 1;
3523                next_offset += envelope_size;
3524            }
3525
3526            let next_out_of_line = decoder.next_out_of_line();
3527            let handles_before = decoder.remaining_handles();
3528            if let Some((inlined, num_bytes, num_handles)) =
3529                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3530            {
3531                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3532                if inlined != (member_inline_size <= 4) {
3533                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3534                }
3535                let inner_offset;
3536                let mut inner_depth = depth.clone();
3537                if inlined {
3538                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3539                    inner_offset = next_offset;
3540                } else {
3541                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3542                    inner_depth.increment()?;
3543                }
3544                let val_ref = self.vht_caps.get_or_insert_with(|| {
3545                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities, D)
3546                });
3547                fidl::decode!(
3548                    fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities,
3549                    D,
3550                    val_ref,
3551                    decoder,
3552                    inner_offset,
3553                    inner_depth
3554                )?;
3555                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3556                {
3557                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3558                }
3559                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3560                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3561                }
3562            }
3563
3564            next_offset += envelope_size;
3565            _next_ordinal_to_read += 1;
3566            if next_offset >= end_offset {
3567                return Ok(());
3568            }
3569
3570            // Decode unknown envelopes for gaps in ordinals.
3571            while _next_ordinal_to_read < 5 {
3572                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3573                _next_ordinal_to_read += 1;
3574                next_offset += envelope_size;
3575            }
3576
3577            let next_out_of_line = decoder.next_out_of_line();
3578            let handles_before = decoder.remaining_handles();
3579            if let Some((inlined, num_bytes, num_handles)) =
3580                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3581            {
3582                let member_inline_size =
3583                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::TypeMarker>::inline_size(
3584                        decoder.context,
3585                    );
3586                if inlined != (member_inline_size <= 4) {
3587                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3588                }
3589                let inner_offset;
3590                let mut inner_depth = depth.clone();
3591                if inlined {
3592                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3593                    inner_offset = next_offset;
3594                } else {
3595                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3596                    inner_depth.increment()?;
3597                }
3598                let val_ref = self
3599                    .operating_channels
3600                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D));
3601                fidl::decode!(fidl::encoding::Vector<u8, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
3602                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3603                {
3604                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3605                }
3606                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3607                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3608                }
3609            }
3610
3611            next_offset += envelope_size;
3612
3613            // Decode the remaining unknown envelopes.
3614            while next_offset < end_offset {
3615                _next_ordinal_to_read += 1;
3616                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3617                next_offset += envelope_size;
3618            }
3619
3620            Ok(())
3621        }
3622    }
3623
3624    impl SaeFrame {
3625        #[inline(always)]
3626        fn max_ordinal_present(&self) -> u64 {
3627            if let Some(_) = self.sae_fields {
3628                return 4;
3629            }
3630            if let Some(_) = self.seq_num {
3631                return 3;
3632            }
3633            if let Some(_) = self.status_code {
3634                return 2;
3635            }
3636            if let Some(_) = self.peer_sta_address {
3637                return 1;
3638            }
3639            0
3640        }
3641    }
3642
3643    impl fidl::encoding::ValueTypeMarker for SaeFrame {
3644        type Borrowed<'a> = &'a Self;
3645        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3646            value
3647        }
3648    }
3649
3650    unsafe impl fidl::encoding::TypeMarker for SaeFrame {
3651        type Owned = Self;
3652
3653        #[inline(always)]
3654        fn inline_align(_context: fidl::encoding::Context) -> usize {
3655            8
3656        }
3657
3658        #[inline(always)]
3659        fn inline_size(_context: fidl::encoding::Context) -> usize {
3660            16
3661        }
3662    }
3663
3664    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SaeFrame, D> for &SaeFrame {
3665        unsafe fn encode(
3666            self,
3667            encoder: &mut fidl::encoding::Encoder<'_, D>,
3668            offset: usize,
3669            mut depth: fidl::encoding::Depth,
3670        ) -> fidl::Result<()> {
3671            encoder.debug_check_bounds::<SaeFrame>(offset);
3672            // Vector header
3673            let max_ordinal: u64 = self.max_ordinal_present();
3674            encoder.write_num(max_ordinal, offset);
3675            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3676            // Calling encoder.out_of_line_offset(0) is not allowed.
3677            if max_ordinal == 0 {
3678                return Ok(());
3679            }
3680            depth.increment()?;
3681            let envelope_size = 8;
3682            let bytes_len = max_ordinal as usize * envelope_size;
3683            #[allow(unused_variables)]
3684            let offset = encoder.out_of_line_offset(bytes_len);
3685            let mut _prev_end_offset: usize = 0;
3686            if 1 > max_ordinal {
3687                return Ok(());
3688            }
3689
3690            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3691            // are envelope_size bytes.
3692            let cur_offset: usize = (1 - 1) * envelope_size;
3693
3694            // Zero reserved fields.
3695            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3696
3697            // Safety:
3698            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3699            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3700            //   envelope_size bytes, there is always sufficient room.
3701            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
3702                self.peer_sta_address
3703                    .as_ref()
3704                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
3705                encoder,
3706                offset + cur_offset,
3707                depth,
3708            )?;
3709
3710            _prev_end_offset = cur_offset + envelope_size;
3711            if 2 > max_ordinal {
3712                return Ok(());
3713            }
3714
3715            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3716            // are envelope_size bytes.
3717            let cur_offset: usize = (2 - 1) * envelope_size;
3718
3719            // Zero reserved fields.
3720            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3721
3722            // Safety:
3723            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3724            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3725            //   envelope_size bytes, there is always sufficient room.
3726            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
3727            self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
3728            encoder, offset + cur_offset, depth
3729        )?;
3730
3731            _prev_end_offset = cur_offset + envelope_size;
3732            if 3 > max_ordinal {
3733                return Ok(());
3734            }
3735
3736            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3737            // are envelope_size bytes.
3738            let cur_offset: usize = (3 - 1) * envelope_size;
3739
3740            // Zero reserved fields.
3741            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3742
3743            // Safety:
3744            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3745            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3746            //   envelope_size bytes, there is always sufficient room.
3747            fidl::encoding::encode_in_envelope_optional::<u16, D>(
3748                self.seq_num.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3749                encoder,
3750                offset + cur_offset,
3751                depth,
3752            )?;
3753
3754            _prev_end_offset = cur_offset + envelope_size;
3755            if 4 > max_ordinal {
3756                return Ok(());
3757            }
3758
3759            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3760            // are envelope_size bytes.
3761            let cur_offset: usize = (4 - 1) * envelope_size;
3762
3763            // Zero reserved fields.
3764            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3765
3766            // Safety:
3767            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3768            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3769            //   envelope_size bytes, there is always sufficient room.
3770            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
3771            self.sae_fields.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
3772            encoder, offset + cur_offset, depth
3773        )?;
3774
3775            _prev_end_offset = cur_offset + envelope_size;
3776
3777            Ok(())
3778        }
3779    }
3780
3781    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SaeFrame {
3782        #[inline(always)]
3783        fn new_empty() -> Self {
3784            Self::default()
3785        }
3786
3787        unsafe fn decode(
3788            &mut self,
3789            decoder: &mut fidl::encoding::Decoder<'_, D>,
3790            offset: usize,
3791            mut depth: fidl::encoding::Depth,
3792        ) -> fidl::Result<()> {
3793            decoder.debug_check_bounds::<Self>(offset);
3794            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3795                None => return Err(fidl::Error::NotNullable),
3796                Some(len) => len,
3797            };
3798            // Calling decoder.out_of_line_offset(0) is not allowed.
3799            if len == 0 {
3800                return Ok(());
3801            };
3802            depth.increment()?;
3803            let envelope_size = 8;
3804            let bytes_len = len * envelope_size;
3805            let offset = decoder.out_of_line_offset(bytes_len)?;
3806            // Decode the envelope for each type.
3807            let mut _next_ordinal_to_read = 0;
3808            let mut next_offset = offset;
3809            let end_offset = offset + bytes_len;
3810            _next_ordinal_to_read += 1;
3811            if next_offset >= end_offset {
3812                return Ok(());
3813            }
3814
3815            // Decode unknown envelopes for gaps in ordinals.
3816            while _next_ordinal_to_read < 1 {
3817                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3818                _next_ordinal_to_read += 1;
3819                next_offset += envelope_size;
3820            }
3821
3822            let next_out_of_line = decoder.next_out_of_line();
3823            let handles_before = decoder.remaining_handles();
3824            if let Some((inlined, num_bytes, num_handles)) =
3825                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3826            {
3827                let member_inline_size =
3828                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
3829                        decoder.context,
3830                    );
3831                if inlined != (member_inline_size <= 4) {
3832                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3833                }
3834                let inner_offset;
3835                let mut inner_depth = depth.clone();
3836                if inlined {
3837                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3838                    inner_offset = next_offset;
3839                } else {
3840                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3841                    inner_depth.increment()?;
3842                }
3843                let val_ref = self
3844                    .peer_sta_address
3845                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
3846                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
3847                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3848                {
3849                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3850                }
3851                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3852                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3853                }
3854            }
3855
3856            next_offset += envelope_size;
3857            _next_ordinal_to_read += 1;
3858            if next_offset >= end_offset {
3859                return Ok(());
3860            }
3861
3862            // Decode unknown envelopes for gaps in ordinals.
3863            while _next_ordinal_to_read < 2 {
3864                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3865                _next_ordinal_to_read += 1;
3866                next_offset += envelope_size;
3867            }
3868
3869            let next_out_of_line = decoder.next_out_of_line();
3870            let handles_before = decoder.remaining_handles();
3871            if let Some((inlined, num_bytes, num_handles)) =
3872                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3873            {
3874                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3875                if inlined != (member_inline_size <= 4) {
3876                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3877                }
3878                let inner_offset;
3879                let mut inner_depth = depth.clone();
3880                if inlined {
3881                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3882                    inner_offset = next_offset;
3883                } else {
3884                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3885                    inner_depth.increment()?;
3886                }
3887                let val_ref = self.status_code.get_or_insert_with(|| {
3888                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
3889                });
3890                fidl::decode!(
3891                    fidl_fuchsia_wlan_ieee80211__common::StatusCode,
3892                    D,
3893                    val_ref,
3894                    decoder,
3895                    inner_offset,
3896                    inner_depth
3897                )?;
3898                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3899                {
3900                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3901                }
3902                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3903                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3904                }
3905            }
3906
3907            next_offset += envelope_size;
3908            _next_ordinal_to_read += 1;
3909            if next_offset >= end_offset {
3910                return Ok(());
3911            }
3912
3913            // Decode unknown envelopes for gaps in ordinals.
3914            while _next_ordinal_to_read < 3 {
3915                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3916                _next_ordinal_to_read += 1;
3917                next_offset += envelope_size;
3918            }
3919
3920            let next_out_of_line = decoder.next_out_of_line();
3921            let handles_before = decoder.remaining_handles();
3922            if let Some((inlined, num_bytes, num_handles)) =
3923                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3924            {
3925                let member_inline_size =
3926                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3927                if inlined != (member_inline_size <= 4) {
3928                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3929                }
3930                let inner_offset;
3931                let mut inner_depth = depth.clone();
3932                if inlined {
3933                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3934                    inner_offset = next_offset;
3935                } else {
3936                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3937                    inner_depth.increment()?;
3938                }
3939                let val_ref = self.seq_num.get_or_insert_with(|| fidl::new_empty!(u16, D));
3940                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3941                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3942                {
3943                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3944                }
3945                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3946                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3947                }
3948            }
3949
3950            next_offset += envelope_size;
3951            _next_ordinal_to_read += 1;
3952            if next_offset >= end_offset {
3953                return Ok(());
3954            }
3955
3956            // Decode unknown envelopes for gaps in ordinals.
3957            while _next_ordinal_to_read < 4 {
3958                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3959                _next_ordinal_to_read += 1;
3960                next_offset += envelope_size;
3961            }
3962
3963            let next_out_of_line = decoder.next_out_of_line();
3964            let handles_before = decoder.remaining_handles();
3965            if let Some((inlined, num_bytes, num_handles)) =
3966                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3967            {
3968                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3969                if inlined != (member_inline_size <= 4) {
3970                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3971                }
3972                let inner_offset;
3973                let mut inner_depth = depth.clone();
3974                if inlined {
3975                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3976                    inner_offset = next_offset;
3977                } else {
3978                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3979                    inner_depth.increment()?;
3980                }
3981                let val_ref = self.sae_fields.get_or_insert_with(|| {
3982                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
3983                });
3984                fidl::decode!(
3985                    fidl::encoding::UnboundedVector<u8>,
3986                    D,
3987                    val_ref,
3988                    decoder,
3989                    inner_offset,
3990                    inner_depth
3991                )?;
3992                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3993                {
3994                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3995                }
3996                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3997                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3998                }
3999            }
4000
4001            next_offset += envelope_size;
4002
4003            // Decode the remaining unknown envelopes.
4004            while next_offset < end_offset {
4005                _next_ordinal_to_read += 1;
4006                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4007                next_offset += envelope_size;
4008            }
4009
4010            Ok(())
4011        }
4012    }
4013
4014    impl WlanFullmacImplAssocRespRequest {
4015        #[inline(always)]
4016        fn max_ordinal_present(&self) -> u64 {
4017            if let Some(_) = self.association_id {
4018                return 3;
4019            }
4020            if let Some(_) = self.result_code {
4021                return 2;
4022            }
4023            if let Some(_) = self.peer_sta_address {
4024                return 1;
4025            }
4026            0
4027        }
4028    }
4029
4030    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplAssocRespRequest {
4031        type Borrowed<'a> = &'a Self;
4032        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4033            value
4034        }
4035    }
4036
4037    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplAssocRespRequest {
4038        type Owned = Self;
4039
4040        #[inline(always)]
4041        fn inline_align(_context: fidl::encoding::Context) -> usize {
4042            8
4043        }
4044
4045        #[inline(always)]
4046        fn inline_size(_context: fidl::encoding::Context) -> usize {
4047            16
4048        }
4049    }
4050
4051    unsafe impl<D: fidl::encoding::ResourceDialect>
4052        fidl::encoding::Encode<WlanFullmacImplAssocRespRequest, D>
4053        for &WlanFullmacImplAssocRespRequest
4054    {
4055        unsafe fn encode(
4056            self,
4057            encoder: &mut fidl::encoding::Encoder<'_, D>,
4058            offset: usize,
4059            mut depth: fidl::encoding::Depth,
4060        ) -> fidl::Result<()> {
4061            encoder.debug_check_bounds::<WlanFullmacImplAssocRespRequest>(offset);
4062            // Vector header
4063            let max_ordinal: u64 = self.max_ordinal_present();
4064            encoder.write_num(max_ordinal, offset);
4065            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4066            // Calling encoder.out_of_line_offset(0) is not allowed.
4067            if max_ordinal == 0 {
4068                return Ok(());
4069            }
4070            depth.increment()?;
4071            let envelope_size = 8;
4072            let bytes_len = max_ordinal as usize * envelope_size;
4073            #[allow(unused_variables)]
4074            let offset = encoder.out_of_line_offset(bytes_len);
4075            let mut _prev_end_offset: usize = 0;
4076            if 1 > max_ordinal {
4077                return Ok(());
4078            }
4079
4080            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4081            // are envelope_size bytes.
4082            let cur_offset: usize = (1 - 1) * envelope_size;
4083
4084            // Zero reserved fields.
4085            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4086
4087            // Safety:
4088            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4089            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4090            //   envelope_size bytes, there is always sufficient room.
4091            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
4092                self.peer_sta_address
4093                    .as_ref()
4094                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
4095                encoder,
4096                offset + cur_offset,
4097                depth,
4098            )?;
4099
4100            _prev_end_offset = cur_offset + envelope_size;
4101            if 2 > max_ordinal {
4102                return Ok(());
4103            }
4104
4105            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4106            // are envelope_size bytes.
4107            let cur_offset: usize = (2 - 1) * envelope_size;
4108
4109            // Zero reserved fields.
4110            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4111
4112            // Safety:
4113            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4114            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4115            //   envelope_size bytes, there is always sufficient room.
4116            fidl::encoding::encode_in_envelope_optional::<WlanAssocResult, D>(
4117                self.result_code
4118                    .as_ref()
4119                    .map(<WlanAssocResult as fidl::encoding::ValueTypeMarker>::borrow),
4120                encoder,
4121                offset + cur_offset,
4122                depth,
4123            )?;
4124
4125            _prev_end_offset = cur_offset + envelope_size;
4126            if 3 > max_ordinal {
4127                return Ok(());
4128            }
4129
4130            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4131            // are envelope_size bytes.
4132            let cur_offset: usize = (3 - 1) * envelope_size;
4133
4134            // Zero reserved fields.
4135            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4136
4137            // Safety:
4138            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4139            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4140            //   envelope_size bytes, there is always sufficient room.
4141            fidl::encoding::encode_in_envelope_optional::<u16, D>(
4142                self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4143                encoder,
4144                offset + cur_offset,
4145                depth,
4146            )?;
4147
4148            _prev_end_offset = cur_offset + envelope_size;
4149
4150            Ok(())
4151        }
4152    }
4153
4154    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4155        for WlanFullmacImplAssocRespRequest
4156    {
4157        #[inline(always)]
4158        fn new_empty() -> Self {
4159            Self::default()
4160        }
4161
4162        unsafe fn decode(
4163            &mut self,
4164            decoder: &mut fidl::encoding::Decoder<'_, D>,
4165            offset: usize,
4166            mut depth: fidl::encoding::Depth,
4167        ) -> fidl::Result<()> {
4168            decoder.debug_check_bounds::<Self>(offset);
4169            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4170                None => return Err(fidl::Error::NotNullable),
4171                Some(len) => len,
4172            };
4173            // Calling decoder.out_of_line_offset(0) is not allowed.
4174            if len == 0 {
4175                return Ok(());
4176            };
4177            depth.increment()?;
4178            let envelope_size = 8;
4179            let bytes_len = len * envelope_size;
4180            let offset = decoder.out_of_line_offset(bytes_len)?;
4181            // Decode the envelope for each type.
4182            let mut _next_ordinal_to_read = 0;
4183            let mut next_offset = offset;
4184            let end_offset = offset + bytes_len;
4185            _next_ordinal_to_read += 1;
4186            if next_offset >= end_offset {
4187                return Ok(());
4188            }
4189
4190            // Decode unknown envelopes for gaps in ordinals.
4191            while _next_ordinal_to_read < 1 {
4192                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4193                _next_ordinal_to_read += 1;
4194                next_offset += envelope_size;
4195            }
4196
4197            let next_out_of_line = decoder.next_out_of_line();
4198            let handles_before = decoder.remaining_handles();
4199            if let Some((inlined, num_bytes, num_handles)) =
4200                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4201            {
4202                let member_inline_size =
4203                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
4204                        decoder.context,
4205                    );
4206                if inlined != (member_inline_size <= 4) {
4207                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4208                }
4209                let inner_offset;
4210                let mut inner_depth = depth.clone();
4211                if inlined {
4212                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4213                    inner_offset = next_offset;
4214                } else {
4215                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4216                    inner_depth.increment()?;
4217                }
4218                let val_ref = self
4219                    .peer_sta_address
4220                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
4221                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
4222                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4223                {
4224                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4225                }
4226                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4227                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4228                }
4229            }
4230
4231            next_offset += envelope_size;
4232            _next_ordinal_to_read += 1;
4233            if next_offset >= end_offset {
4234                return Ok(());
4235            }
4236
4237            // Decode unknown envelopes for gaps in ordinals.
4238            while _next_ordinal_to_read < 2 {
4239                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4240                _next_ordinal_to_read += 1;
4241                next_offset += envelope_size;
4242            }
4243
4244            let next_out_of_line = decoder.next_out_of_line();
4245            let handles_before = decoder.remaining_handles();
4246            if let Some((inlined, num_bytes, num_handles)) =
4247                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4248            {
4249                let member_inline_size =
4250                    <WlanAssocResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4251                if inlined != (member_inline_size <= 4) {
4252                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4253                }
4254                let inner_offset;
4255                let mut inner_depth = depth.clone();
4256                if inlined {
4257                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4258                    inner_offset = next_offset;
4259                } else {
4260                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4261                    inner_depth.increment()?;
4262                }
4263                let val_ref =
4264                    self.result_code.get_or_insert_with(|| fidl::new_empty!(WlanAssocResult, D));
4265                fidl::decode!(WlanAssocResult, D, val_ref, decoder, inner_offset, inner_depth)?;
4266                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4267                {
4268                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4269                }
4270                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4271                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4272                }
4273            }
4274
4275            next_offset += envelope_size;
4276            _next_ordinal_to_read += 1;
4277            if next_offset >= end_offset {
4278                return Ok(());
4279            }
4280
4281            // Decode unknown envelopes for gaps in ordinals.
4282            while _next_ordinal_to_read < 3 {
4283                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4284                _next_ordinal_to_read += 1;
4285                next_offset += envelope_size;
4286            }
4287
4288            let next_out_of_line = decoder.next_out_of_line();
4289            let handles_before = decoder.remaining_handles();
4290            if let Some((inlined, num_bytes, num_handles)) =
4291                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4292            {
4293                let member_inline_size =
4294                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4295                if inlined != (member_inline_size <= 4) {
4296                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4297                }
4298                let inner_offset;
4299                let mut inner_depth = depth.clone();
4300                if inlined {
4301                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4302                    inner_offset = next_offset;
4303                } else {
4304                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4305                    inner_depth.increment()?;
4306                }
4307                let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
4308                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4309                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4310                {
4311                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4312                }
4313                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4314                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4315                }
4316            }
4317
4318            next_offset += envelope_size;
4319
4320            // Decode the remaining unknown envelopes.
4321            while next_offset < end_offset {
4322                _next_ordinal_to_read += 1;
4323                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4324                next_offset += envelope_size;
4325            }
4326
4327            Ok(())
4328        }
4329    }
4330
4331    impl WlanFullmacImplAuthRespRequest {
4332        #[inline(always)]
4333        fn max_ordinal_present(&self) -> u64 {
4334            if let Some(_) = self.result_code {
4335                return 2;
4336            }
4337            if let Some(_) = self.peer_sta_address {
4338                return 1;
4339            }
4340            0
4341        }
4342    }
4343
4344    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplAuthRespRequest {
4345        type Borrowed<'a> = &'a Self;
4346        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4347            value
4348        }
4349    }
4350
4351    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplAuthRespRequest {
4352        type Owned = Self;
4353
4354        #[inline(always)]
4355        fn inline_align(_context: fidl::encoding::Context) -> usize {
4356            8
4357        }
4358
4359        #[inline(always)]
4360        fn inline_size(_context: fidl::encoding::Context) -> usize {
4361            16
4362        }
4363    }
4364
4365    unsafe impl<D: fidl::encoding::ResourceDialect>
4366        fidl::encoding::Encode<WlanFullmacImplAuthRespRequest, D>
4367        for &WlanFullmacImplAuthRespRequest
4368    {
4369        unsafe fn encode(
4370            self,
4371            encoder: &mut fidl::encoding::Encoder<'_, D>,
4372            offset: usize,
4373            mut depth: fidl::encoding::Depth,
4374        ) -> fidl::Result<()> {
4375            encoder.debug_check_bounds::<WlanFullmacImplAuthRespRequest>(offset);
4376            // Vector header
4377            let max_ordinal: u64 = self.max_ordinal_present();
4378            encoder.write_num(max_ordinal, offset);
4379            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4380            // Calling encoder.out_of_line_offset(0) is not allowed.
4381            if max_ordinal == 0 {
4382                return Ok(());
4383            }
4384            depth.increment()?;
4385            let envelope_size = 8;
4386            let bytes_len = max_ordinal as usize * envelope_size;
4387            #[allow(unused_variables)]
4388            let offset = encoder.out_of_line_offset(bytes_len);
4389            let mut _prev_end_offset: usize = 0;
4390            if 1 > max_ordinal {
4391                return Ok(());
4392            }
4393
4394            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4395            // are envelope_size bytes.
4396            let cur_offset: usize = (1 - 1) * envelope_size;
4397
4398            // Zero reserved fields.
4399            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4400
4401            // Safety:
4402            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4403            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4404            //   envelope_size bytes, there is always sufficient room.
4405            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
4406                self.peer_sta_address
4407                    .as_ref()
4408                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
4409                encoder,
4410                offset + cur_offset,
4411                depth,
4412            )?;
4413
4414            _prev_end_offset = cur_offset + envelope_size;
4415            if 2 > max_ordinal {
4416                return Ok(());
4417            }
4418
4419            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4420            // are envelope_size bytes.
4421            let cur_offset: usize = (2 - 1) * envelope_size;
4422
4423            // Zero reserved fields.
4424            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4425
4426            // Safety:
4427            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4428            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4429            //   envelope_size bytes, there is always sufficient room.
4430            fidl::encoding::encode_in_envelope_optional::<WlanAuthResult, D>(
4431                self.result_code
4432                    .as_ref()
4433                    .map(<WlanAuthResult as fidl::encoding::ValueTypeMarker>::borrow),
4434                encoder,
4435                offset + cur_offset,
4436                depth,
4437            )?;
4438
4439            _prev_end_offset = cur_offset + envelope_size;
4440
4441            Ok(())
4442        }
4443    }
4444
4445    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4446        for WlanFullmacImplAuthRespRequest
4447    {
4448        #[inline(always)]
4449        fn new_empty() -> Self {
4450            Self::default()
4451        }
4452
4453        unsafe fn decode(
4454            &mut self,
4455            decoder: &mut fidl::encoding::Decoder<'_, D>,
4456            offset: usize,
4457            mut depth: fidl::encoding::Depth,
4458        ) -> fidl::Result<()> {
4459            decoder.debug_check_bounds::<Self>(offset);
4460            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4461                None => return Err(fidl::Error::NotNullable),
4462                Some(len) => len,
4463            };
4464            // Calling decoder.out_of_line_offset(0) is not allowed.
4465            if len == 0 {
4466                return Ok(());
4467            };
4468            depth.increment()?;
4469            let envelope_size = 8;
4470            let bytes_len = len * envelope_size;
4471            let offset = decoder.out_of_line_offset(bytes_len)?;
4472            // Decode the envelope for each type.
4473            let mut _next_ordinal_to_read = 0;
4474            let mut next_offset = offset;
4475            let end_offset = offset + bytes_len;
4476            _next_ordinal_to_read += 1;
4477            if next_offset >= end_offset {
4478                return Ok(());
4479            }
4480
4481            // Decode unknown envelopes for gaps in ordinals.
4482            while _next_ordinal_to_read < 1 {
4483                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4484                _next_ordinal_to_read += 1;
4485                next_offset += envelope_size;
4486            }
4487
4488            let next_out_of_line = decoder.next_out_of_line();
4489            let handles_before = decoder.remaining_handles();
4490            if let Some((inlined, num_bytes, num_handles)) =
4491                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4492            {
4493                let member_inline_size =
4494                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
4495                        decoder.context,
4496                    );
4497                if inlined != (member_inline_size <= 4) {
4498                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4499                }
4500                let inner_offset;
4501                let mut inner_depth = depth.clone();
4502                if inlined {
4503                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4504                    inner_offset = next_offset;
4505                } else {
4506                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4507                    inner_depth.increment()?;
4508                }
4509                let val_ref = self
4510                    .peer_sta_address
4511                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
4512                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
4513                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4514                {
4515                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4516                }
4517                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4518                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4519                }
4520            }
4521
4522            next_offset += envelope_size;
4523            _next_ordinal_to_read += 1;
4524            if next_offset >= end_offset {
4525                return Ok(());
4526            }
4527
4528            // Decode unknown envelopes for gaps in ordinals.
4529            while _next_ordinal_to_read < 2 {
4530                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4531                _next_ordinal_to_read += 1;
4532                next_offset += envelope_size;
4533            }
4534
4535            let next_out_of_line = decoder.next_out_of_line();
4536            let handles_before = decoder.remaining_handles();
4537            if let Some((inlined, num_bytes, num_handles)) =
4538                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4539            {
4540                let member_inline_size =
4541                    <WlanAuthResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4542                if inlined != (member_inline_size <= 4) {
4543                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4544                }
4545                let inner_offset;
4546                let mut inner_depth = depth.clone();
4547                if inlined {
4548                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4549                    inner_offset = next_offset;
4550                } else {
4551                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4552                    inner_depth.increment()?;
4553                }
4554                let val_ref =
4555                    self.result_code.get_or_insert_with(|| fidl::new_empty!(WlanAuthResult, D));
4556                fidl::decode!(WlanAuthResult, D, val_ref, decoder, inner_offset, inner_depth)?;
4557                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4558                {
4559                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4560                }
4561                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4562                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4563                }
4564            }
4565
4566            next_offset += envelope_size;
4567
4568            // Decode the remaining unknown envelopes.
4569            while next_offset < end_offset {
4570                _next_ordinal_to_read += 1;
4571                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4572                next_offset += envelope_size;
4573            }
4574
4575            Ok(())
4576        }
4577    }
4578
4579    impl WlanFullmacImplConnectRequest {
4580        #[inline(always)]
4581        fn max_ordinal_present(&self) -> u64 {
4582            if let Some(_) = self.wep_key_desc {
4583                return 7;
4584            }
4585            if let Some(_) = self.security_ie {
4586                return 6;
4587            }
4588            if let Some(_) = self.wep_key {
4589                return 5;
4590            }
4591            if let Some(_) = self.sae_password {
4592                return 4;
4593            }
4594            if let Some(_) = self.auth_type {
4595                return 3;
4596            }
4597            if let Some(_) = self.connect_failure_timeout {
4598                return 2;
4599            }
4600            if let Some(_) = self.selected_bss {
4601                return 1;
4602            }
4603            0
4604        }
4605    }
4606
4607    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplConnectRequest {
4608        type Borrowed<'a> = &'a Self;
4609        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4610            value
4611        }
4612    }
4613
4614    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplConnectRequest {
4615        type Owned = Self;
4616
4617        #[inline(always)]
4618        fn inline_align(_context: fidl::encoding::Context) -> usize {
4619            8
4620        }
4621
4622        #[inline(always)]
4623        fn inline_size(_context: fidl::encoding::Context) -> usize {
4624            16
4625        }
4626    }
4627
4628    unsafe impl<D: fidl::encoding::ResourceDialect>
4629        fidl::encoding::Encode<WlanFullmacImplConnectRequest, D>
4630        for &WlanFullmacImplConnectRequest
4631    {
4632        unsafe fn encode(
4633            self,
4634            encoder: &mut fidl::encoding::Encoder<'_, D>,
4635            offset: usize,
4636            mut depth: fidl::encoding::Depth,
4637        ) -> fidl::Result<()> {
4638            encoder.debug_check_bounds::<WlanFullmacImplConnectRequest>(offset);
4639            // Vector header
4640            let max_ordinal: u64 = self.max_ordinal_present();
4641            encoder.write_num(max_ordinal, offset);
4642            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4643            // Calling encoder.out_of_line_offset(0) is not allowed.
4644            if max_ordinal == 0 {
4645                return Ok(());
4646            }
4647            depth.increment()?;
4648            let envelope_size = 8;
4649            let bytes_len = max_ordinal as usize * envelope_size;
4650            #[allow(unused_variables)]
4651            let offset = encoder.out_of_line_offset(bytes_len);
4652            let mut _prev_end_offset: usize = 0;
4653            if 1 > max_ordinal {
4654                return Ok(());
4655            }
4656
4657            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4658            // are envelope_size bytes.
4659            let cur_offset: usize = (1 - 1) * envelope_size;
4660
4661            // Zero reserved fields.
4662            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4663
4664            // Safety:
4665            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4666            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4667            //   envelope_size bytes, there is always sufficient room.
4668            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
4669            self.selected_bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
4670            encoder, offset + cur_offset, depth
4671        )?;
4672
4673            _prev_end_offset = cur_offset + envelope_size;
4674            if 2 > max_ordinal {
4675                return Ok(());
4676            }
4677
4678            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4679            // are envelope_size bytes.
4680            let cur_offset: usize = (2 - 1) * envelope_size;
4681
4682            // Zero reserved fields.
4683            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4684
4685            // Safety:
4686            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4687            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4688            //   envelope_size bytes, there is always sufficient room.
4689            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4690                self.connect_failure_timeout
4691                    .as_ref()
4692                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4693                encoder,
4694                offset + cur_offset,
4695                depth,
4696            )?;
4697
4698            _prev_end_offset = cur_offset + envelope_size;
4699            if 3 > max_ordinal {
4700                return Ok(());
4701            }
4702
4703            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4704            // are envelope_size bytes.
4705            let cur_offset: usize = (3 - 1) * envelope_size;
4706
4707            // Zero reserved fields.
4708            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4709
4710            // Safety:
4711            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4712            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4713            //   envelope_size bytes, there is always sufficient room.
4714            fidl::encoding::encode_in_envelope_optional::<WlanAuthType, D>(
4715                self.auth_type
4716                    .as_ref()
4717                    .map(<WlanAuthType as fidl::encoding::ValueTypeMarker>::borrow),
4718                encoder,
4719                offset + cur_offset,
4720                depth,
4721            )?;
4722
4723            _prev_end_offset = cur_offset + envelope_size;
4724            if 4 > max_ordinal {
4725                return Ok(());
4726            }
4727
4728            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4729            // are envelope_size bytes.
4730            let cur_offset: usize = (4 - 1) * envelope_size;
4731
4732            // Zero reserved fields.
4733            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4734
4735            // Safety:
4736            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4737            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4738            //   envelope_size bytes, there is always sufficient room.
4739            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
4740            self.sae_password.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
4741            encoder, offset + cur_offset, depth
4742        )?;
4743
4744            _prev_end_offset = cur_offset + envelope_size;
4745            if 5 > max_ordinal {
4746                return Ok(());
4747            }
4748
4749            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4750            // are envelope_size bytes.
4751            let cur_offset: usize = (5 - 1) * envelope_size;
4752
4753            // Zero reserved fields.
4754            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4755
4756            // Safety:
4757            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4758            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4759            //   envelope_size bytes, there is always sufficient room.
4760            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::WlanKeyConfig, D>(
4761            self.wep_key.as_ref().map(<fidl_fuchsia_wlan_common__common::WlanKeyConfig as fidl::encoding::ValueTypeMarker>::borrow),
4762            encoder, offset + cur_offset, depth
4763        )?;
4764
4765            _prev_end_offset = cur_offset + envelope_size;
4766            if 6 > max_ordinal {
4767                return Ok(());
4768            }
4769
4770            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4771            // are envelope_size bytes.
4772            let cur_offset: usize = (6 - 1) * envelope_size;
4773
4774            // Zero reserved fields.
4775            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4776
4777            // Safety:
4778            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4779            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4780            //   envelope_size bytes, there is always sufficient room.
4781            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 257>, D>(
4782                self.security_ie.as_ref().map(
4783                    <fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow,
4784                ),
4785                encoder,
4786                offset + cur_offset,
4787                depth,
4788            )?;
4789
4790            _prev_end_offset = cur_offset + envelope_size;
4791            if 7 > max_ordinal {
4792                return Ok(());
4793            }
4794
4795            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4796            // are envelope_size bytes.
4797            let cur_offset: usize = (7 - 1) * envelope_size;
4798
4799            // Zero reserved fields.
4800            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4801
4802            // Safety:
4803            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4804            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4805            //   envelope_size bytes, there is always sufficient room.
4806            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, D>(
4807            self.wep_key_desc.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor as fidl::encoding::ValueTypeMarker>::borrow),
4808            encoder, offset + cur_offset, depth
4809        )?;
4810
4811            _prev_end_offset = cur_offset + envelope_size;
4812
4813            Ok(())
4814        }
4815    }
4816
4817    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4818        for WlanFullmacImplConnectRequest
4819    {
4820        #[inline(always)]
4821        fn new_empty() -> Self {
4822            Self::default()
4823        }
4824
4825        unsafe fn decode(
4826            &mut self,
4827            decoder: &mut fidl::encoding::Decoder<'_, D>,
4828            offset: usize,
4829            mut depth: fidl::encoding::Depth,
4830        ) -> fidl::Result<()> {
4831            decoder.debug_check_bounds::<Self>(offset);
4832            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4833                None => return Err(fidl::Error::NotNullable),
4834                Some(len) => len,
4835            };
4836            // Calling decoder.out_of_line_offset(0) is not allowed.
4837            if len == 0 {
4838                return Ok(());
4839            };
4840            depth.increment()?;
4841            let envelope_size = 8;
4842            let bytes_len = len * envelope_size;
4843            let offset = decoder.out_of_line_offset(bytes_len)?;
4844            // Decode the envelope for each type.
4845            let mut _next_ordinal_to_read = 0;
4846            let mut next_offset = offset;
4847            let end_offset = offset + bytes_len;
4848            _next_ordinal_to_read += 1;
4849            if next_offset >= end_offset {
4850                return Ok(());
4851            }
4852
4853            // Decode unknown envelopes for gaps in ordinals.
4854            while _next_ordinal_to_read < 1 {
4855                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4856                _next_ordinal_to_read += 1;
4857                next_offset += envelope_size;
4858            }
4859
4860            let next_out_of_line = decoder.next_out_of_line();
4861            let handles_before = decoder.remaining_handles();
4862            if let Some((inlined, num_bytes, num_handles)) =
4863                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4864            {
4865                let member_inline_size = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4866                if inlined != (member_inline_size <= 4) {
4867                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4868                }
4869                let inner_offset;
4870                let mut inner_depth = depth.clone();
4871                if inlined {
4872                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4873                    inner_offset = next_offset;
4874                } else {
4875                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4876                    inner_depth.increment()?;
4877                }
4878                let val_ref = self.selected_bss.get_or_insert_with(|| {
4879                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
4880                });
4881                fidl::decode!(
4882                    fidl_fuchsia_wlan_common__common::BssDescription,
4883                    D,
4884                    val_ref,
4885                    decoder,
4886                    inner_offset,
4887                    inner_depth
4888                )?;
4889                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4890                {
4891                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4892                }
4893                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4894                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4895                }
4896            }
4897
4898            next_offset += envelope_size;
4899            _next_ordinal_to_read += 1;
4900            if next_offset >= end_offset {
4901                return Ok(());
4902            }
4903
4904            // Decode unknown envelopes for gaps in ordinals.
4905            while _next_ordinal_to_read < 2 {
4906                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4907                _next_ordinal_to_read += 1;
4908                next_offset += envelope_size;
4909            }
4910
4911            let next_out_of_line = decoder.next_out_of_line();
4912            let handles_before = decoder.remaining_handles();
4913            if let Some((inlined, num_bytes, num_handles)) =
4914                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4915            {
4916                let member_inline_size =
4917                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4918                if inlined != (member_inline_size <= 4) {
4919                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4920                }
4921                let inner_offset;
4922                let mut inner_depth = depth.clone();
4923                if inlined {
4924                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4925                    inner_offset = next_offset;
4926                } else {
4927                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4928                    inner_depth.increment()?;
4929                }
4930                let val_ref =
4931                    self.connect_failure_timeout.get_or_insert_with(|| fidl::new_empty!(u32, D));
4932                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4933                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4934                {
4935                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4936                }
4937                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4938                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4939                }
4940            }
4941
4942            next_offset += envelope_size;
4943            _next_ordinal_to_read += 1;
4944            if next_offset >= end_offset {
4945                return Ok(());
4946            }
4947
4948            // Decode unknown envelopes for gaps in ordinals.
4949            while _next_ordinal_to_read < 3 {
4950                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4951                _next_ordinal_to_read += 1;
4952                next_offset += envelope_size;
4953            }
4954
4955            let next_out_of_line = decoder.next_out_of_line();
4956            let handles_before = decoder.remaining_handles();
4957            if let Some((inlined, num_bytes, num_handles)) =
4958                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4959            {
4960                let member_inline_size =
4961                    <WlanAuthType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4962                if inlined != (member_inline_size <= 4) {
4963                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4964                }
4965                let inner_offset;
4966                let mut inner_depth = depth.clone();
4967                if inlined {
4968                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4969                    inner_offset = next_offset;
4970                } else {
4971                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4972                    inner_depth.increment()?;
4973                }
4974                let val_ref =
4975                    self.auth_type.get_or_insert_with(|| fidl::new_empty!(WlanAuthType, D));
4976                fidl::decode!(WlanAuthType, D, val_ref, decoder, inner_offset, inner_depth)?;
4977                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4978                {
4979                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4980                }
4981                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4982                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4983                }
4984            }
4985
4986            next_offset += envelope_size;
4987            _next_ordinal_to_read += 1;
4988            if next_offset >= end_offset {
4989                return Ok(());
4990            }
4991
4992            // Decode unknown envelopes for gaps in ordinals.
4993            while _next_ordinal_to_read < 4 {
4994                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4995                _next_ordinal_to_read += 1;
4996                next_offset += envelope_size;
4997            }
4998
4999            let next_out_of_line = decoder.next_out_of_line();
5000            let handles_before = decoder.remaining_handles();
5001            if let Some((inlined, num_bytes, num_handles)) =
5002                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5003            {
5004                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5005                if inlined != (member_inline_size <= 4) {
5006                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5007                }
5008                let inner_offset;
5009                let mut inner_depth = depth.clone();
5010                if inlined {
5011                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5012                    inner_offset = next_offset;
5013                } else {
5014                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5015                    inner_depth.increment()?;
5016                }
5017                let val_ref = self.sae_password.get_or_insert_with(|| {
5018                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
5019                });
5020                fidl::decode!(
5021                    fidl::encoding::UnboundedVector<u8>,
5022                    D,
5023                    val_ref,
5024                    decoder,
5025                    inner_offset,
5026                    inner_depth
5027                )?;
5028                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5029                {
5030                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5031                }
5032                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5033                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5034                }
5035            }
5036
5037            next_offset += envelope_size;
5038            _next_ordinal_to_read += 1;
5039            if next_offset >= end_offset {
5040                return Ok(());
5041            }
5042
5043            // Decode unknown envelopes for gaps in ordinals.
5044            while _next_ordinal_to_read < 5 {
5045                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5046                _next_ordinal_to_read += 1;
5047                next_offset += envelope_size;
5048            }
5049
5050            let next_out_of_line = decoder.next_out_of_line();
5051            let handles_before = decoder.remaining_handles();
5052            if let Some((inlined, num_bytes, num_handles)) =
5053                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5054            {
5055                let member_inline_size = <fidl_fuchsia_wlan_common__common::WlanKeyConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5056                if inlined != (member_inline_size <= 4) {
5057                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5058                }
5059                let inner_offset;
5060                let mut inner_depth = depth.clone();
5061                if inlined {
5062                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5063                    inner_offset = next_offset;
5064                } else {
5065                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5066                    inner_depth.increment()?;
5067                }
5068                let val_ref = self.wep_key.get_or_insert_with(|| {
5069                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanKeyConfig, D)
5070                });
5071                fidl::decode!(
5072                    fidl_fuchsia_wlan_common__common::WlanKeyConfig,
5073                    D,
5074                    val_ref,
5075                    decoder,
5076                    inner_offset,
5077                    inner_depth
5078                )?;
5079                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5080                {
5081                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5082                }
5083                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5084                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5085                }
5086            }
5087
5088            next_offset += envelope_size;
5089            _next_ordinal_to_read += 1;
5090            if next_offset >= end_offset {
5091                return Ok(());
5092            }
5093
5094            // Decode unknown envelopes for gaps in ordinals.
5095            while _next_ordinal_to_read < 6 {
5096                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5097                _next_ordinal_to_read += 1;
5098                next_offset += envelope_size;
5099            }
5100
5101            let next_out_of_line = decoder.next_out_of_line();
5102            let handles_before = decoder.remaining_handles();
5103            if let Some((inlined, num_bytes, num_handles)) =
5104                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5105            {
5106                let member_inline_size =
5107                    <fidl::encoding::Vector<u8, 257> as fidl::encoding::TypeMarker>::inline_size(
5108                        decoder.context,
5109                    );
5110                if inlined != (member_inline_size <= 4) {
5111                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5112                }
5113                let inner_offset;
5114                let mut inner_depth = depth.clone();
5115                if inlined {
5116                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5117                    inner_offset = next_offset;
5118                } else {
5119                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5120                    inner_depth.increment()?;
5121                }
5122                let val_ref = self
5123                    .security_ie
5124                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 257>, D));
5125                fidl::decode!(fidl::encoding::Vector<u8, 257>, D, val_ref, decoder, inner_offset, inner_depth)?;
5126                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5127                {
5128                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5129                }
5130                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5131                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5132                }
5133            }
5134
5135            next_offset += envelope_size;
5136            _next_ordinal_to_read += 1;
5137            if next_offset >= end_offset {
5138                return Ok(());
5139            }
5140
5141            // Decode unknown envelopes for gaps in ordinals.
5142            while _next_ordinal_to_read < 7 {
5143                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5144                _next_ordinal_to_read += 1;
5145                next_offset += envelope_size;
5146            }
5147
5148            let next_out_of_line = decoder.next_out_of_line();
5149            let handles_before = decoder.remaining_handles();
5150            if let Some((inlined, num_bytes, num_handles)) =
5151                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5152            {
5153                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5154                if inlined != (member_inline_size <= 4) {
5155                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5156                }
5157                let inner_offset;
5158                let mut inner_depth = depth.clone();
5159                if inlined {
5160                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5161                    inner_offset = next_offset;
5162                } else {
5163                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5164                    inner_depth.increment()?;
5165                }
5166                let val_ref = self.wep_key_desc.get_or_insert_with(|| {
5167                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, D)
5168                });
5169                fidl::decode!(
5170                    fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor,
5171                    D,
5172                    val_ref,
5173                    decoder,
5174                    inner_offset,
5175                    inner_depth
5176                )?;
5177                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5178                {
5179                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5180                }
5181                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5182                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5183                }
5184            }
5185
5186            next_offset += envelope_size;
5187
5188            // Decode the remaining unknown envelopes.
5189            while next_offset < end_offset {
5190                _next_ordinal_to_read += 1;
5191                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5192                next_offset += envelope_size;
5193            }
5194
5195            Ok(())
5196        }
5197    }
5198
5199    impl WlanFullmacImplDeauthRequest {
5200        #[inline(always)]
5201        fn max_ordinal_present(&self) -> u64 {
5202            if let Some(_) = self.reason_code {
5203                return 2;
5204            }
5205            if let Some(_) = self.peer_sta_address {
5206                return 1;
5207            }
5208            0
5209        }
5210    }
5211
5212    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplDeauthRequest {
5213        type Borrowed<'a> = &'a Self;
5214        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5215            value
5216        }
5217    }
5218
5219    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplDeauthRequest {
5220        type Owned = Self;
5221
5222        #[inline(always)]
5223        fn inline_align(_context: fidl::encoding::Context) -> usize {
5224            8
5225        }
5226
5227        #[inline(always)]
5228        fn inline_size(_context: fidl::encoding::Context) -> usize {
5229            16
5230        }
5231    }
5232
5233    unsafe impl<D: fidl::encoding::ResourceDialect>
5234        fidl::encoding::Encode<WlanFullmacImplDeauthRequest, D> for &WlanFullmacImplDeauthRequest
5235    {
5236        unsafe fn encode(
5237            self,
5238            encoder: &mut fidl::encoding::Encoder<'_, D>,
5239            offset: usize,
5240            mut depth: fidl::encoding::Depth,
5241        ) -> fidl::Result<()> {
5242            encoder.debug_check_bounds::<WlanFullmacImplDeauthRequest>(offset);
5243            // Vector header
5244            let max_ordinal: u64 = self.max_ordinal_present();
5245            encoder.write_num(max_ordinal, offset);
5246            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5247            // Calling encoder.out_of_line_offset(0) is not allowed.
5248            if max_ordinal == 0 {
5249                return Ok(());
5250            }
5251            depth.increment()?;
5252            let envelope_size = 8;
5253            let bytes_len = max_ordinal as usize * envelope_size;
5254            #[allow(unused_variables)]
5255            let offset = encoder.out_of_line_offset(bytes_len);
5256            let mut _prev_end_offset: usize = 0;
5257            if 1 > max_ordinal {
5258                return Ok(());
5259            }
5260
5261            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5262            // are envelope_size bytes.
5263            let cur_offset: usize = (1 - 1) * envelope_size;
5264
5265            // Zero reserved fields.
5266            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5267
5268            // Safety:
5269            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5270            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5271            //   envelope_size bytes, there is always sufficient room.
5272            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5273                self.peer_sta_address
5274                    .as_ref()
5275                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5276                encoder,
5277                offset + cur_offset,
5278                depth,
5279            )?;
5280
5281            _prev_end_offset = cur_offset + envelope_size;
5282            if 2 > max_ordinal {
5283                return Ok(());
5284            }
5285
5286            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5287            // are envelope_size bytes.
5288            let cur_offset: usize = (2 - 1) * envelope_size;
5289
5290            // Zero reserved fields.
5291            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5292
5293            // Safety:
5294            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5295            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5296            //   envelope_size bytes, there is always sufficient room.
5297            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
5298            self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
5299            encoder, offset + cur_offset, depth
5300        )?;
5301
5302            _prev_end_offset = cur_offset + envelope_size;
5303
5304            Ok(())
5305        }
5306    }
5307
5308    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5309        for WlanFullmacImplDeauthRequest
5310    {
5311        #[inline(always)]
5312        fn new_empty() -> Self {
5313            Self::default()
5314        }
5315
5316        unsafe fn decode(
5317            &mut self,
5318            decoder: &mut fidl::encoding::Decoder<'_, D>,
5319            offset: usize,
5320            mut depth: fidl::encoding::Depth,
5321        ) -> fidl::Result<()> {
5322            decoder.debug_check_bounds::<Self>(offset);
5323            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5324                None => return Err(fidl::Error::NotNullable),
5325                Some(len) => len,
5326            };
5327            // Calling decoder.out_of_line_offset(0) is not allowed.
5328            if len == 0 {
5329                return Ok(());
5330            };
5331            depth.increment()?;
5332            let envelope_size = 8;
5333            let bytes_len = len * envelope_size;
5334            let offset = decoder.out_of_line_offset(bytes_len)?;
5335            // Decode the envelope for each type.
5336            let mut _next_ordinal_to_read = 0;
5337            let mut next_offset = offset;
5338            let end_offset = offset + bytes_len;
5339            _next_ordinal_to_read += 1;
5340            if next_offset >= end_offset {
5341                return Ok(());
5342            }
5343
5344            // Decode unknown envelopes for gaps in ordinals.
5345            while _next_ordinal_to_read < 1 {
5346                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5347                _next_ordinal_to_read += 1;
5348                next_offset += envelope_size;
5349            }
5350
5351            let next_out_of_line = decoder.next_out_of_line();
5352            let handles_before = decoder.remaining_handles();
5353            if let Some((inlined, num_bytes, num_handles)) =
5354                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5355            {
5356                let member_inline_size =
5357                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5358                        decoder.context,
5359                    );
5360                if inlined != (member_inline_size <= 4) {
5361                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5362                }
5363                let inner_offset;
5364                let mut inner_depth = depth.clone();
5365                if inlined {
5366                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5367                    inner_offset = next_offset;
5368                } else {
5369                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5370                    inner_depth.increment()?;
5371                }
5372                let val_ref = self
5373                    .peer_sta_address
5374                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5375                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
5376                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5377                {
5378                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5379                }
5380                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5381                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5382                }
5383            }
5384
5385            next_offset += envelope_size;
5386            _next_ordinal_to_read += 1;
5387            if next_offset >= end_offset {
5388                return Ok(());
5389            }
5390
5391            // Decode unknown envelopes for gaps in ordinals.
5392            while _next_ordinal_to_read < 2 {
5393                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5394                _next_ordinal_to_read += 1;
5395                next_offset += envelope_size;
5396            }
5397
5398            let next_out_of_line = decoder.next_out_of_line();
5399            let handles_before = decoder.remaining_handles();
5400            if let Some((inlined, num_bytes, num_handles)) =
5401                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5402            {
5403                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5404                if inlined != (member_inline_size <= 4) {
5405                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5406                }
5407                let inner_offset;
5408                let mut inner_depth = depth.clone();
5409                if inlined {
5410                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5411                    inner_offset = next_offset;
5412                } else {
5413                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5414                    inner_depth.increment()?;
5415                }
5416                let val_ref = self.reason_code.get_or_insert_with(|| {
5417                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
5418                });
5419                fidl::decode!(
5420                    fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
5421                    D,
5422                    val_ref,
5423                    decoder,
5424                    inner_offset,
5425                    inner_depth
5426                )?;
5427                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5428                {
5429                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5430                }
5431                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5432                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5433                }
5434            }
5435
5436            next_offset += envelope_size;
5437
5438            // Decode the remaining unknown envelopes.
5439            while next_offset < end_offset {
5440                _next_ordinal_to_read += 1;
5441                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5442                next_offset += envelope_size;
5443            }
5444
5445            Ok(())
5446        }
5447    }
5448
5449    impl WlanFullmacImplDisassocRequest {
5450        #[inline(always)]
5451        fn max_ordinal_present(&self) -> u64 {
5452            if let Some(_) = self.reason_code {
5453                return 2;
5454            }
5455            if let Some(_) = self.peer_sta_address {
5456                return 1;
5457            }
5458            0
5459        }
5460    }
5461
5462    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplDisassocRequest {
5463        type Borrowed<'a> = &'a Self;
5464        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5465            value
5466        }
5467    }
5468
5469    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplDisassocRequest {
5470        type Owned = Self;
5471
5472        #[inline(always)]
5473        fn inline_align(_context: fidl::encoding::Context) -> usize {
5474            8
5475        }
5476
5477        #[inline(always)]
5478        fn inline_size(_context: fidl::encoding::Context) -> usize {
5479            16
5480        }
5481    }
5482
5483    unsafe impl<D: fidl::encoding::ResourceDialect>
5484        fidl::encoding::Encode<WlanFullmacImplDisassocRequest, D>
5485        for &WlanFullmacImplDisassocRequest
5486    {
5487        unsafe fn encode(
5488            self,
5489            encoder: &mut fidl::encoding::Encoder<'_, D>,
5490            offset: usize,
5491            mut depth: fidl::encoding::Depth,
5492        ) -> fidl::Result<()> {
5493            encoder.debug_check_bounds::<WlanFullmacImplDisassocRequest>(offset);
5494            // Vector header
5495            let max_ordinal: u64 = self.max_ordinal_present();
5496            encoder.write_num(max_ordinal, offset);
5497            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5498            // Calling encoder.out_of_line_offset(0) is not allowed.
5499            if max_ordinal == 0 {
5500                return Ok(());
5501            }
5502            depth.increment()?;
5503            let envelope_size = 8;
5504            let bytes_len = max_ordinal as usize * envelope_size;
5505            #[allow(unused_variables)]
5506            let offset = encoder.out_of_line_offset(bytes_len);
5507            let mut _prev_end_offset: usize = 0;
5508            if 1 > max_ordinal {
5509                return Ok(());
5510            }
5511
5512            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5513            // are envelope_size bytes.
5514            let cur_offset: usize = (1 - 1) * envelope_size;
5515
5516            // Zero reserved fields.
5517            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5518
5519            // Safety:
5520            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5521            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5522            //   envelope_size bytes, there is always sufficient room.
5523            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5524                self.peer_sta_address
5525                    .as_ref()
5526                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5527                encoder,
5528                offset + cur_offset,
5529                depth,
5530            )?;
5531
5532            _prev_end_offset = cur_offset + envelope_size;
5533            if 2 > max_ordinal {
5534                return Ok(());
5535            }
5536
5537            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5538            // are envelope_size bytes.
5539            let cur_offset: usize = (2 - 1) * envelope_size;
5540
5541            // Zero reserved fields.
5542            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5543
5544            // Safety:
5545            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5546            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5547            //   envelope_size bytes, there is always sufficient room.
5548            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
5549            self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
5550            encoder, offset + cur_offset, depth
5551        )?;
5552
5553            _prev_end_offset = cur_offset + envelope_size;
5554
5555            Ok(())
5556        }
5557    }
5558
5559    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5560        for WlanFullmacImplDisassocRequest
5561    {
5562        #[inline(always)]
5563        fn new_empty() -> Self {
5564            Self::default()
5565        }
5566
5567        unsafe fn decode(
5568            &mut self,
5569            decoder: &mut fidl::encoding::Decoder<'_, D>,
5570            offset: usize,
5571            mut depth: fidl::encoding::Depth,
5572        ) -> fidl::Result<()> {
5573            decoder.debug_check_bounds::<Self>(offset);
5574            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5575                None => return Err(fidl::Error::NotNullable),
5576                Some(len) => len,
5577            };
5578            // Calling decoder.out_of_line_offset(0) is not allowed.
5579            if len == 0 {
5580                return Ok(());
5581            };
5582            depth.increment()?;
5583            let envelope_size = 8;
5584            let bytes_len = len * envelope_size;
5585            let offset = decoder.out_of_line_offset(bytes_len)?;
5586            // Decode the envelope for each type.
5587            let mut _next_ordinal_to_read = 0;
5588            let mut next_offset = offset;
5589            let end_offset = offset + bytes_len;
5590            _next_ordinal_to_read += 1;
5591            if next_offset >= end_offset {
5592                return Ok(());
5593            }
5594
5595            // Decode unknown envelopes for gaps in ordinals.
5596            while _next_ordinal_to_read < 1 {
5597                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5598                _next_ordinal_to_read += 1;
5599                next_offset += envelope_size;
5600            }
5601
5602            let next_out_of_line = decoder.next_out_of_line();
5603            let handles_before = decoder.remaining_handles();
5604            if let Some((inlined, num_bytes, num_handles)) =
5605                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5606            {
5607                let member_inline_size =
5608                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5609                        decoder.context,
5610                    );
5611                if inlined != (member_inline_size <= 4) {
5612                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5613                }
5614                let inner_offset;
5615                let mut inner_depth = depth.clone();
5616                if inlined {
5617                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5618                    inner_offset = next_offset;
5619                } else {
5620                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5621                    inner_depth.increment()?;
5622                }
5623                let val_ref = self
5624                    .peer_sta_address
5625                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5626                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
5627                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5628                {
5629                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5630                }
5631                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5632                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5633                }
5634            }
5635
5636            next_offset += envelope_size;
5637            _next_ordinal_to_read += 1;
5638            if next_offset >= end_offset {
5639                return Ok(());
5640            }
5641
5642            // Decode unknown envelopes for gaps in ordinals.
5643            while _next_ordinal_to_read < 2 {
5644                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5645                _next_ordinal_to_read += 1;
5646                next_offset += envelope_size;
5647            }
5648
5649            let next_out_of_line = decoder.next_out_of_line();
5650            let handles_before = decoder.remaining_handles();
5651            if let Some((inlined, num_bytes, num_handles)) =
5652                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5653            {
5654                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5655                if inlined != (member_inline_size <= 4) {
5656                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5657                }
5658                let inner_offset;
5659                let mut inner_depth = depth.clone();
5660                if inlined {
5661                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5662                    inner_offset = next_offset;
5663                } else {
5664                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5665                    inner_depth.increment()?;
5666                }
5667                let val_ref = self.reason_code.get_or_insert_with(|| {
5668                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
5669                });
5670                fidl::decode!(
5671                    fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
5672                    D,
5673                    val_ref,
5674                    decoder,
5675                    inner_offset,
5676                    inner_depth
5677                )?;
5678                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5679                {
5680                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5681                }
5682                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5683                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5684                }
5685            }
5686
5687            next_offset += envelope_size;
5688
5689            // Decode the remaining unknown envelopes.
5690            while next_offset < end_offset {
5691                _next_ordinal_to_read += 1;
5692                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5693                next_offset += envelope_size;
5694            }
5695
5696            Ok(())
5697        }
5698    }
5699
5700    impl WlanFullmacImplEapolTxRequest {
5701        #[inline(always)]
5702        fn max_ordinal_present(&self) -> u64 {
5703            if let Some(_) = self.data {
5704                return 3;
5705            }
5706            if let Some(_) = self.dst_addr {
5707                return 2;
5708            }
5709            if let Some(_) = self.src_addr {
5710                return 1;
5711            }
5712            0
5713        }
5714    }
5715
5716    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplEapolTxRequest {
5717        type Borrowed<'a> = &'a Self;
5718        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5719            value
5720        }
5721    }
5722
5723    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplEapolTxRequest {
5724        type Owned = Self;
5725
5726        #[inline(always)]
5727        fn inline_align(_context: fidl::encoding::Context) -> usize {
5728            8
5729        }
5730
5731        #[inline(always)]
5732        fn inline_size(_context: fidl::encoding::Context) -> usize {
5733            16
5734        }
5735    }
5736
5737    unsafe impl<D: fidl::encoding::ResourceDialect>
5738        fidl::encoding::Encode<WlanFullmacImplEapolTxRequest, D>
5739        for &WlanFullmacImplEapolTxRequest
5740    {
5741        unsafe fn encode(
5742            self,
5743            encoder: &mut fidl::encoding::Encoder<'_, D>,
5744            offset: usize,
5745            mut depth: fidl::encoding::Depth,
5746        ) -> fidl::Result<()> {
5747            encoder.debug_check_bounds::<WlanFullmacImplEapolTxRequest>(offset);
5748            // Vector header
5749            let max_ordinal: u64 = self.max_ordinal_present();
5750            encoder.write_num(max_ordinal, offset);
5751            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5752            // Calling encoder.out_of_line_offset(0) is not allowed.
5753            if max_ordinal == 0 {
5754                return Ok(());
5755            }
5756            depth.increment()?;
5757            let envelope_size = 8;
5758            let bytes_len = max_ordinal as usize * envelope_size;
5759            #[allow(unused_variables)]
5760            let offset = encoder.out_of_line_offset(bytes_len);
5761            let mut _prev_end_offset: usize = 0;
5762            if 1 > max_ordinal {
5763                return Ok(());
5764            }
5765
5766            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5767            // are envelope_size bytes.
5768            let cur_offset: usize = (1 - 1) * envelope_size;
5769
5770            // Zero reserved fields.
5771            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5772
5773            // Safety:
5774            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5775            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5776            //   envelope_size bytes, there is always sufficient room.
5777            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5778                self.src_addr
5779                    .as_ref()
5780                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5781                encoder,
5782                offset + cur_offset,
5783                depth,
5784            )?;
5785
5786            _prev_end_offset = cur_offset + envelope_size;
5787            if 2 > max_ordinal {
5788                return Ok(());
5789            }
5790
5791            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5792            // are envelope_size bytes.
5793            let cur_offset: usize = (2 - 1) * envelope_size;
5794
5795            // Zero reserved fields.
5796            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5797
5798            // Safety:
5799            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5800            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5801            //   envelope_size bytes, there is always sufficient room.
5802            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5803                self.dst_addr
5804                    .as_ref()
5805                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5806                encoder,
5807                offset + cur_offset,
5808                depth,
5809            )?;
5810
5811            _prev_end_offset = cur_offset + envelope_size;
5812            if 3 > max_ordinal {
5813                return Ok(());
5814            }
5815
5816            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5817            // are envelope_size bytes.
5818            let cur_offset: usize = (3 - 1) * envelope_size;
5819
5820            // Zero reserved fields.
5821            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5822
5823            // Safety:
5824            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5825            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5826            //   envelope_size bytes, there is always sufficient room.
5827            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
5828            self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
5829            encoder, offset + cur_offset, depth
5830        )?;
5831
5832            _prev_end_offset = cur_offset + envelope_size;
5833
5834            Ok(())
5835        }
5836    }
5837
5838    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5839        for WlanFullmacImplEapolTxRequest
5840    {
5841        #[inline(always)]
5842        fn new_empty() -> Self {
5843            Self::default()
5844        }
5845
5846        unsafe fn decode(
5847            &mut self,
5848            decoder: &mut fidl::encoding::Decoder<'_, D>,
5849            offset: usize,
5850            mut depth: fidl::encoding::Depth,
5851        ) -> fidl::Result<()> {
5852            decoder.debug_check_bounds::<Self>(offset);
5853            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5854                None => return Err(fidl::Error::NotNullable),
5855                Some(len) => len,
5856            };
5857            // Calling decoder.out_of_line_offset(0) is not allowed.
5858            if len == 0 {
5859                return Ok(());
5860            };
5861            depth.increment()?;
5862            let envelope_size = 8;
5863            let bytes_len = len * envelope_size;
5864            let offset = decoder.out_of_line_offset(bytes_len)?;
5865            // Decode the envelope for each type.
5866            let mut _next_ordinal_to_read = 0;
5867            let mut next_offset = offset;
5868            let end_offset = offset + bytes_len;
5869            _next_ordinal_to_read += 1;
5870            if next_offset >= end_offset {
5871                return Ok(());
5872            }
5873
5874            // Decode unknown envelopes for gaps in ordinals.
5875            while _next_ordinal_to_read < 1 {
5876                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5877                _next_ordinal_to_read += 1;
5878                next_offset += envelope_size;
5879            }
5880
5881            let next_out_of_line = decoder.next_out_of_line();
5882            let handles_before = decoder.remaining_handles();
5883            if let Some((inlined, num_bytes, num_handles)) =
5884                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5885            {
5886                let member_inline_size =
5887                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5888                        decoder.context,
5889                    );
5890                if inlined != (member_inline_size <= 4) {
5891                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5892                }
5893                let inner_offset;
5894                let mut inner_depth = depth.clone();
5895                if inlined {
5896                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5897                    inner_offset = next_offset;
5898                } else {
5899                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5900                    inner_depth.increment()?;
5901                }
5902                let val_ref = self
5903                    .src_addr
5904                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5905                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
5906                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5907                {
5908                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5909                }
5910                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5911                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5912                }
5913            }
5914
5915            next_offset += envelope_size;
5916            _next_ordinal_to_read += 1;
5917            if next_offset >= end_offset {
5918                return Ok(());
5919            }
5920
5921            // Decode unknown envelopes for gaps in ordinals.
5922            while _next_ordinal_to_read < 2 {
5923                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5924                _next_ordinal_to_read += 1;
5925                next_offset += envelope_size;
5926            }
5927
5928            let next_out_of_line = decoder.next_out_of_line();
5929            let handles_before = decoder.remaining_handles();
5930            if let Some((inlined, num_bytes, num_handles)) =
5931                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5932            {
5933                let member_inline_size =
5934                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5935                        decoder.context,
5936                    );
5937                if inlined != (member_inline_size <= 4) {
5938                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5939                }
5940                let inner_offset;
5941                let mut inner_depth = depth.clone();
5942                if inlined {
5943                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5944                    inner_offset = next_offset;
5945                } else {
5946                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5947                    inner_depth.increment()?;
5948                }
5949                let val_ref = self
5950                    .dst_addr
5951                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5952                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
5953                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5954                {
5955                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5956                }
5957                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5958                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5959                }
5960            }
5961
5962            next_offset += envelope_size;
5963            _next_ordinal_to_read += 1;
5964            if next_offset >= end_offset {
5965                return Ok(());
5966            }
5967
5968            // Decode unknown envelopes for gaps in ordinals.
5969            while _next_ordinal_to_read < 3 {
5970                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5971                _next_ordinal_to_read += 1;
5972                next_offset += envelope_size;
5973            }
5974
5975            let next_out_of_line = decoder.next_out_of_line();
5976            let handles_before = decoder.remaining_handles();
5977            if let Some((inlined, num_bytes, num_handles)) =
5978                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5979            {
5980                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5981                if inlined != (member_inline_size <= 4) {
5982                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5983                }
5984                let inner_offset;
5985                let mut inner_depth = depth.clone();
5986                if inlined {
5987                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5988                    inner_offset = next_offset;
5989                } else {
5990                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5991                    inner_depth.increment()?;
5992                }
5993                let val_ref = self.data.get_or_insert_with(|| {
5994                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
5995                });
5996                fidl::decode!(
5997                    fidl::encoding::UnboundedVector<u8>,
5998                    D,
5999                    val_ref,
6000                    decoder,
6001                    inner_offset,
6002                    inner_depth
6003                )?;
6004                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6005                {
6006                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6007                }
6008                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6009                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6010                }
6011            }
6012
6013            next_offset += envelope_size;
6014
6015            // Decode the remaining unknown envelopes.
6016            while next_offset < end_offset {
6017                _next_ordinal_to_read += 1;
6018                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6019                next_offset += envelope_size;
6020            }
6021
6022            Ok(())
6023        }
6024    }
6025
6026    impl WlanFullmacImplIfcAssocIndRequest {
6027        #[inline(always)]
6028        fn max_ordinal_present(&self) -> u64 {
6029            if let Some(_) = self.vendor_ie {
6030                return 5;
6031            }
6032            if let Some(_) = self.rsne {
6033                return 4;
6034            }
6035            if let Some(_) = self.ssid {
6036                return 3;
6037            }
6038            if let Some(_) = self.listen_interval {
6039                return 2;
6040            }
6041            if let Some(_) = self.peer_sta_address {
6042                return 1;
6043            }
6044            0
6045        }
6046    }
6047
6048    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcAssocIndRequest {
6049        type Borrowed<'a> = &'a Self;
6050        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6051            value
6052        }
6053    }
6054
6055    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcAssocIndRequest {
6056        type Owned = Self;
6057
6058        #[inline(always)]
6059        fn inline_align(_context: fidl::encoding::Context) -> usize {
6060            8
6061        }
6062
6063        #[inline(always)]
6064        fn inline_size(_context: fidl::encoding::Context) -> usize {
6065            16
6066        }
6067    }
6068
6069    unsafe impl<D: fidl::encoding::ResourceDialect>
6070        fidl::encoding::Encode<WlanFullmacImplIfcAssocIndRequest, D>
6071        for &WlanFullmacImplIfcAssocIndRequest
6072    {
6073        unsafe fn encode(
6074            self,
6075            encoder: &mut fidl::encoding::Encoder<'_, D>,
6076            offset: usize,
6077            mut depth: fidl::encoding::Depth,
6078        ) -> fidl::Result<()> {
6079            encoder.debug_check_bounds::<WlanFullmacImplIfcAssocIndRequest>(offset);
6080            // Vector header
6081            let max_ordinal: u64 = self.max_ordinal_present();
6082            encoder.write_num(max_ordinal, offset);
6083            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6084            // Calling encoder.out_of_line_offset(0) is not allowed.
6085            if max_ordinal == 0 {
6086                return Ok(());
6087            }
6088            depth.increment()?;
6089            let envelope_size = 8;
6090            let bytes_len = max_ordinal as usize * envelope_size;
6091            #[allow(unused_variables)]
6092            let offset = encoder.out_of_line_offset(bytes_len);
6093            let mut _prev_end_offset: usize = 0;
6094            if 1 > max_ordinal {
6095                return Ok(());
6096            }
6097
6098            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6099            // are envelope_size bytes.
6100            let cur_offset: usize = (1 - 1) * envelope_size;
6101
6102            // Zero reserved fields.
6103            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6104
6105            // Safety:
6106            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6107            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6108            //   envelope_size bytes, there is always sufficient room.
6109            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
6110                self.peer_sta_address
6111                    .as_ref()
6112                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
6113                encoder,
6114                offset + cur_offset,
6115                depth,
6116            )?;
6117
6118            _prev_end_offset = cur_offset + envelope_size;
6119            if 2 > max_ordinal {
6120                return Ok(());
6121            }
6122
6123            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6124            // are envelope_size bytes.
6125            let cur_offset: usize = (2 - 1) * envelope_size;
6126
6127            // Zero reserved fields.
6128            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6129
6130            // Safety:
6131            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6132            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6133            //   envelope_size bytes, there is always sufficient room.
6134            fidl::encoding::encode_in_envelope_optional::<u16, D>(
6135                self.listen_interval.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6136                encoder,
6137                offset + cur_offset,
6138                depth,
6139            )?;
6140
6141            _prev_end_offset = cur_offset + envelope_size;
6142            if 3 > max_ordinal {
6143                return Ok(());
6144            }
6145
6146            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6147            // are envelope_size bytes.
6148            let cur_offset: usize = (3 - 1) * envelope_size;
6149
6150            // Zero reserved fields.
6151            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6152
6153            // Safety:
6154            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6155            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6156            //   envelope_size bytes, there is always sufficient room.
6157            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
6158                self.ssid.as_ref().map(
6159                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
6160                ),
6161                encoder,
6162                offset + cur_offset,
6163                depth,
6164            )?;
6165
6166            _prev_end_offset = cur_offset + envelope_size;
6167            if 4 > max_ordinal {
6168                return Ok(());
6169            }
6170
6171            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6172            // are envelope_size bytes.
6173            let cur_offset: usize = (4 - 1) * envelope_size;
6174
6175            // Zero reserved fields.
6176            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6177
6178            // Safety:
6179            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6180            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6181            //   envelope_size bytes, there is always sufficient room.
6182            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 257>, D>(
6183                self.rsne.as_ref().map(
6184                    <fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow,
6185                ),
6186                encoder,
6187                offset + cur_offset,
6188                depth,
6189            )?;
6190
6191            _prev_end_offset = cur_offset + envelope_size;
6192            if 5 > max_ordinal {
6193                return Ok(());
6194            }
6195
6196            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6197            // are envelope_size bytes.
6198            let cur_offset: usize = (5 - 1) * envelope_size;
6199
6200            // Zero reserved fields.
6201            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6202
6203            // Safety:
6204            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6205            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6206            //   envelope_size bytes, there is always sufficient room.
6207            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 514>, D>(
6208                self.vendor_ie.as_ref().map(
6209                    <fidl::encoding::Vector<u8, 514> as fidl::encoding::ValueTypeMarker>::borrow,
6210                ),
6211                encoder,
6212                offset + cur_offset,
6213                depth,
6214            )?;
6215
6216            _prev_end_offset = cur_offset + envelope_size;
6217
6218            Ok(())
6219        }
6220    }
6221
6222    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6223        for WlanFullmacImplIfcAssocIndRequest
6224    {
6225        #[inline(always)]
6226        fn new_empty() -> Self {
6227            Self::default()
6228        }
6229
6230        unsafe fn decode(
6231            &mut self,
6232            decoder: &mut fidl::encoding::Decoder<'_, D>,
6233            offset: usize,
6234            mut depth: fidl::encoding::Depth,
6235        ) -> fidl::Result<()> {
6236            decoder.debug_check_bounds::<Self>(offset);
6237            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6238                None => return Err(fidl::Error::NotNullable),
6239                Some(len) => len,
6240            };
6241            // Calling decoder.out_of_line_offset(0) is not allowed.
6242            if len == 0 {
6243                return Ok(());
6244            };
6245            depth.increment()?;
6246            let envelope_size = 8;
6247            let bytes_len = len * envelope_size;
6248            let offset = decoder.out_of_line_offset(bytes_len)?;
6249            // Decode the envelope for each type.
6250            let mut _next_ordinal_to_read = 0;
6251            let mut next_offset = offset;
6252            let end_offset = offset + bytes_len;
6253            _next_ordinal_to_read += 1;
6254            if next_offset >= end_offset {
6255                return Ok(());
6256            }
6257
6258            // Decode unknown envelopes for gaps in ordinals.
6259            while _next_ordinal_to_read < 1 {
6260                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6261                _next_ordinal_to_read += 1;
6262                next_offset += envelope_size;
6263            }
6264
6265            let next_out_of_line = decoder.next_out_of_line();
6266            let handles_before = decoder.remaining_handles();
6267            if let Some((inlined, num_bytes, num_handles)) =
6268                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6269            {
6270                let member_inline_size =
6271                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
6272                        decoder.context,
6273                    );
6274                if inlined != (member_inline_size <= 4) {
6275                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6276                }
6277                let inner_offset;
6278                let mut inner_depth = depth.clone();
6279                if inlined {
6280                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6281                    inner_offset = next_offset;
6282                } else {
6283                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6284                    inner_depth.increment()?;
6285                }
6286                let val_ref = self
6287                    .peer_sta_address
6288                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
6289                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
6290                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6291                {
6292                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6293                }
6294                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6295                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6296                }
6297            }
6298
6299            next_offset += envelope_size;
6300            _next_ordinal_to_read += 1;
6301            if next_offset >= end_offset {
6302                return Ok(());
6303            }
6304
6305            // Decode unknown envelopes for gaps in ordinals.
6306            while _next_ordinal_to_read < 2 {
6307                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6308                _next_ordinal_to_read += 1;
6309                next_offset += envelope_size;
6310            }
6311
6312            let next_out_of_line = decoder.next_out_of_line();
6313            let handles_before = decoder.remaining_handles();
6314            if let Some((inlined, num_bytes, num_handles)) =
6315                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6316            {
6317                let member_inline_size =
6318                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6319                if inlined != (member_inline_size <= 4) {
6320                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6321                }
6322                let inner_offset;
6323                let mut inner_depth = depth.clone();
6324                if inlined {
6325                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6326                    inner_offset = next_offset;
6327                } else {
6328                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6329                    inner_depth.increment()?;
6330                }
6331                let val_ref = self.listen_interval.get_or_insert_with(|| fidl::new_empty!(u16, D));
6332                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6333                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6334                {
6335                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6336                }
6337                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6338                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6339                }
6340            }
6341
6342            next_offset += envelope_size;
6343            _next_ordinal_to_read += 1;
6344            if next_offset >= end_offset {
6345                return Ok(());
6346            }
6347
6348            // Decode unknown envelopes for gaps in ordinals.
6349            while _next_ordinal_to_read < 3 {
6350                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6351                _next_ordinal_to_read += 1;
6352                next_offset += envelope_size;
6353            }
6354
6355            let next_out_of_line = decoder.next_out_of_line();
6356            let handles_before = decoder.remaining_handles();
6357            if let Some((inlined, num_bytes, num_handles)) =
6358                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6359            {
6360                let member_inline_size =
6361                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
6362                        decoder.context,
6363                    );
6364                if inlined != (member_inline_size <= 4) {
6365                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6366                }
6367                let inner_offset;
6368                let mut inner_depth = depth.clone();
6369                if inlined {
6370                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6371                    inner_offset = next_offset;
6372                } else {
6373                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6374                    inner_depth.increment()?;
6375                }
6376                let val_ref = self
6377                    .ssid
6378                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
6379                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
6380                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6381                {
6382                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6383                }
6384                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6385                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6386                }
6387            }
6388
6389            next_offset += envelope_size;
6390            _next_ordinal_to_read += 1;
6391            if next_offset >= end_offset {
6392                return Ok(());
6393            }
6394
6395            // Decode unknown envelopes for gaps in ordinals.
6396            while _next_ordinal_to_read < 4 {
6397                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6398                _next_ordinal_to_read += 1;
6399                next_offset += envelope_size;
6400            }
6401
6402            let next_out_of_line = decoder.next_out_of_line();
6403            let handles_before = decoder.remaining_handles();
6404            if let Some((inlined, num_bytes, num_handles)) =
6405                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6406            {
6407                let member_inline_size =
6408                    <fidl::encoding::Vector<u8, 257> as fidl::encoding::TypeMarker>::inline_size(
6409                        decoder.context,
6410                    );
6411                if inlined != (member_inline_size <= 4) {
6412                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6413                }
6414                let inner_offset;
6415                let mut inner_depth = depth.clone();
6416                if inlined {
6417                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6418                    inner_offset = next_offset;
6419                } else {
6420                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6421                    inner_depth.increment()?;
6422                }
6423                let val_ref = self
6424                    .rsne
6425                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 257>, D));
6426                fidl::decode!(fidl::encoding::Vector<u8, 257>, D, val_ref, decoder, inner_offset, inner_depth)?;
6427                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6428                {
6429                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6430                }
6431                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6432                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6433                }
6434            }
6435
6436            next_offset += envelope_size;
6437            _next_ordinal_to_read += 1;
6438            if next_offset >= end_offset {
6439                return Ok(());
6440            }
6441
6442            // Decode unknown envelopes for gaps in ordinals.
6443            while _next_ordinal_to_read < 5 {
6444                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6445                _next_ordinal_to_read += 1;
6446                next_offset += envelope_size;
6447            }
6448
6449            let next_out_of_line = decoder.next_out_of_line();
6450            let handles_before = decoder.remaining_handles();
6451            if let Some((inlined, num_bytes, num_handles)) =
6452                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6453            {
6454                let member_inline_size =
6455                    <fidl::encoding::Vector<u8, 514> as fidl::encoding::TypeMarker>::inline_size(
6456                        decoder.context,
6457                    );
6458                if inlined != (member_inline_size <= 4) {
6459                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6460                }
6461                let inner_offset;
6462                let mut inner_depth = depth.clone();
6463                if inlined {
6464                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6465                    inner_offset = next_offset;
6466                } else {
6467                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6468                    inner_depth.increment()?;
6469                }
6470                let val_ref = self
6471                    .vendor_ie
6472                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 514>, D));
6473                fidl::decode!(fidl::encoding::Vector<u8, 514>, D, val_ref, decoder, inner_offset, inner_depth)?;
6474                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6475                {
6476                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6477                }
6478                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6479                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6480                }
6481            }
6482
6483            next_offset += envelope_size;
6484
6485            // Decode the remaining unknown envelopes.
6486            while next_offset < end_offset {
6487                _next_ordinal_to_read += 1;
6488                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6489                next_offset += envelope_size;
6490            }
6491
6492            Ok(())
6493        }
6494    }
6495
6496    impl WlanFullmacImplIfcAuthIndRequest {
6497        #[inline(always)]
6498        fn max_ordinal_present(&self) -> u64 {
6499            if let Some(_) = self.auth_type {
6500                return 2;
6501            }
6502            if let Some(_) = self.peer_sta_address {
6503                return 1;
6504            }
6505            0
6506        }
6507    }
6508
6509    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcAuthIndRequest {
6510        type Borrowed<'a> = &'a Self;
6511        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6512            value
6513        }
6514    }
6515
6516    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcAuthIndRequest {
6517        type Owned = Self;
6518
6519        #[inline(always)]
6520        fn inline_align(_context: fidl::encoding::Context) -> usize {
6521            8
6522        }
6523
6524        #[inline(always)]
6525        fn inline_size(_context: fidl::encoding::Context) -> usize {
6526            16
6527        }
6528    }
6529
6530    unsafe impl<D: fidl::encoding::ResourceDialect>
6531        fidl::encoding::Encode<WlanFullmacImplIfcAuthIndRequest, D>
6532        for &WlanFullmacImplIfcAuthIndRequest
6533    {
6534        unsafe fn encode(
6535            self,
6536            encoder: &mut fidl::encoding::Encoder<'_, D>,
6537            offset: usize,
6538            mut depth: fidl::encoding::Depth,
6539        ) -> fidl::Result<()> {
6540            encoder.debug_check_bounds::<WlanFullmacImplIfcAuthIndRequest>(offset);
6541            // Vector header
6542            let max_ordinal: u64 = self.max_ordinal_present();
6543            encoder.write_num(max_ordinal, offset);
6544            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6545            // Calling encoder.out_of_line_offset(0) is not allowed.
6546            if max_ordinal == 0 {
6547                return Ok(());
6548            }
6549            depth.increment()?;
6550            let envelope_size = 8;
6551            let bytes_len = max_ordinal as usize * envelope_size;
6552            #[allow(unused_variables)]
6553            let offset = encoder.out_of_line_offset(bytes_len);
6554            let mut _prev_end_offset: usize = 0;
6555            if 1 > max_ordinal {
6556                return Ok(());
6557            }
6558
6559            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6560            // are envelope_size bytes.
6561            let cur_offset: usize = (1 - 1) * envelope_size;
6562
6563            // Zero reserved fields.
6564            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6565
6566            // Safety:
6567            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6568            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6569            //   envelope_size bytes, there is always sufficient room.
6570            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
6571                self.peer_sta_address
6572                    .as_ref()
6573                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
6574                encoder,
6575                offset + cur_offset,
6576                depth,
6577            )?;
6578
6579            _prev_end_offset = cur_offset + envelope_size;
6580            if 2 > max_ordinal {
6581                return Ok(());
6582            }
6583
6584            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6585            // are envelope_size bytes.
6586            let cur_offset: usize = (2 - 1) * envelope_size;
6587
6588            // Zero reserved fields.
6589            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6590
6591            // Safety:
6592            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6593            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6594            //   envelope_size bytes, there is always sufficient room.
6595            fidl::encoding::encode_in_envelope_optional::<WlanAuthType, D>(
6596                self.auth_type
6597                    .as_ref()
6598                    .map(<WlanAuthType as fidl::encoding::ValueTypeMarker>::borrow),
6599                encoder,
6600                offset + cur_offset,
6601                depth,
6602            )?;
6603
6604            _prev_end_offset = cur_offset + envelope_size;
6605
6606            Ok(())
6607        }
6608    }
6609
6610    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6611        for WlanFullmacImplIfcAuthIndRequest
6612    {
6613        #[inline(always)]
6614        fn new_empty() -> Self {
6615            Self::default()
6616        }
6617
6618        unsafe fn decode(
6619            &mut self,
6620            decoder: &mut fidl::encoding::Decoder<'_, D>,
6621            offset: usize,
6622            mut depth: fidl::encoding::Depth,
6623        ) -> fidl::Result<()> {
6624            decoder.debug_check_bounds::<Self>(offset);
6625            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6626                None => return Err(fidl::Error::NotNullable),
6627                Some(len) => len,
6628            };
6629            // Calling decoder.out_of_line_offset(0) is not allowed.
6630            if len == 0 {
6631                return Ok(());
6632            };
6633            depth.increment()?;
6634            let envelope_size = 8;
6635            let bytes_len = len * envelope_size;
6636            let offset = decoder.out_of_line_offset(bytes_len)?;
6637            // Decode the envelope for each type.
6638            let mut _next_ordinal_to_read = 0;
6639            let mut next_offset = offset;
6640            let end_offset = offset + bytes_len;
6641            _next_ordinal_to_read += 1;
6642            if next_offset >= end_offset {
6643                return Ok(());
6644            }
6645
6646            // Decode unknown envelopes for gaps in ordinals.
6647            while _next_ordinal_to_read < 1 {
6648                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6649                _next_ordinal_to_read += 1;
6650                next_offset += envelope_size;
6651            }
6652
6653            let next_out_of_line = decoder.next_out_of_line();
6654            let handles_before = decoder.remaining_handles();
6655            if let Some((inlined, num_bytes, num_handles)) =
6656                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6657            {
6658                let member_inline_size =
6659                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
6660                        decoder.context,
6661                    );
6662                if inlined != (member_inline_size <= 4) {
6663                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6664                }
6665                let inner_offset;
6666                let mut inner_depth = depth.clone();
6667                if inlined {
6668                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6669                    inner_offset = next_offset;
6670                } else {
6671                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6672                    inner_depth.increment()?;
6673                }
6674                let val_ref = self
6675                    .peer_sta_address
6676                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
6677                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
6678                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6679                {
6680                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6681                }
6682                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6683                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6684                }
6685            }
6686
6687            next_offset += envelope_size;
6688            _next_ordinal_to_read += 1;
6689            if next_offset >= end_offset {
6690                return Ok(());
6691            }
6692
6693            // Decode unknown envelopes for gaps in ordinals.
6694            while _next_ordinal_to_read < 2 {
6695                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6696                _next_ordinal_to_read += 1;
6697                next_offset += envelope_size;
6698            }
6699
6700            let next_out_of_line = decoder.next_out_of_line();
6701            let handles_before = decoder.remaining_handles();
6702            if let Some((inlined, num_bytes, num_handles)) =
6703                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6704            {
6705                let member_inline_size =
6706                    <WlanAuthType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6707                if inlined != (member_inline_size <= 4) {
6708                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6709                }
6710                let inner_offset;
6711                let mut inner_depth = depth.clone();
6712                if inlined {
6713                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6714                    inner_offset = next_offset;
6715                } else {
6716                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6717                    inner_depth.increment()?;
6718                }
6719                let val_ref =
6720                    self.auth_type.get_or_insert_with(|| fidl::new_empty!(WlanAuthType, D));
6721                fidl::decode!(WlanAuthType, D, val_ref, decoder, inner_offset, inner_depth)?;
6722                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6723                {
6724                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6725                }
6726                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6727                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6728                }
6729            }
6730
6731            next_offset += envelope_size;
6732
6733            // Decode the remaining unknown envelopes.
6734            while next_offset < end_offset {
6735                _next_ordinal_to_read += 1;
6736                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6737                next_offset += envelope_size;
6738            }
6739
6740            Ok(())
6741        }
6742    }
6743
6744    impl WlanFullmacImplIfcConnectConfRequest {
6745        #[inline(always)]
6746        fn max_ordinal_present(&self) -> u64 {
6747            if let Some(_) = self.association_ies {
6748                return 4;
6749            }
6750            if let Some(_) = self.association_id {
6751                return 3;
6752            }
6753            if let Some(_) = self.result_code {
6754                return 2;
6755            }
6756            if let Some(_) = self.peer_sta_address {
6757                return 1;
6758            }
6759            0
6760        }
6761    }
6762
6763    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcConnectConfRequest {
6764        type Borrowed<'a> = &'a Self;
6765        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6766            value
6767        }
6768    }
6769
6770    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcConnectConfRequest {
6771        type Owned = Self;
6772
6773        #[inline(always)]
6774        fn inline_align(_context: fidl::encoding::Context) -> usize {
6775            8
6776        }
6777
6778        #[inline(always)]
6779        fn inline_size(_context: fidl::encoding::Context) -> usize {
6780            16
6781        }
6782    }
6783
6784    unsafe impl<D: fidl::encoding::ResourceDialect>
6785        fidl::encoding::Encode<WlanFullmacImplIfcConnectConfRequest, D>
6786        for &WlanFullmacImplIfcConnectConfRequest
6787    {
6788        unsafe fn encode(
6789            self,
6790            encoder: &mut fidl::encoding::Encoder<'_, D>,
6791            offset: usize,
6792            mut depth: fidl::encoding::Depth,
6793        ) -> fidl::Result<()> {
6794            encoder.debug_check_bounds::<WlanFullmacImplIfcConnectConfRequest>(offset);
6795            // Vector header
6796            let max_ordinal: u64 = self.max_ordinal_present();
6797            encoder.write_num(max_ordinal, offset);
6798            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6799            // Calling encoder.out_of_line_offset(0) is not allowed.
6800            if max_ordinal == 0 {
6801                return Ok(());
6802            }
6803            depth.increment()?;
6804            let envelope_size = 8;
6805            let bytes_len = max_ordinal as usize * envelope_size;
6806            #[allow(unused_variables)]
6807            let offset = encoder.out_of_line_offset(bytes_len);
6808            let mut _prev_end_offset: usize = 0;
6809            if 1 > max_ordinal {
6810                return Ok(());
6811            }
6812
6813            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6814            // are envelope_size bytes.
6815            let cur_offset: usize = (1 - 1) * envelope_size;
6816
6817            // Zero reserved fields.
6818            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6819
6820            // Safety:
6821            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6822            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6823            //   envelope_size bytes, there is always sufficient room.
6824            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
6825                self.peer_sta_address
6826                    .as_ref()
6827                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
6828                encoder,
6829                offset + cur_offset,
6830                depth,
6831            )?;
6832
6833            _prev_end_offset = cur_offset + envelope_size;
6834            if 2 > max_ordinal {
6835                return Ok(());
6836            }
6837
6838            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6839            // are envelope_size bytes.
6840            let cur_offset: usize = (2 - 1) * envelope_size;
6841
6842            // Zero reserved fields.
6843            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6844
6845            // Safety:
6846            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6847            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6848            //   envelope_size bytes, there is always sufficient room.
6849            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
6850            self.result_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
6851            encoder, offset + cur_offset, depth
6852        )?;
6853
6854            _prev_end_offset = cur_offset + envelope_size;
6855            if 3 > max_ordinal {
6856                return Ok(());
6857            }
6858
6859            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6860            // are envelope_size bytes.
6861            let cur_offset: usize = (3 - 1) * envelope_size;
6862
6863            // Zero reserved fields.
6864            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6865
6866            // Safety:
6867            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6868            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6869            //   envelope_size bytes, there is always sufficient room.
6870            fidl::encoding::encode_in_envelope_optional::<u16, D>(
6871                self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6872                encoder,
6873                offset + cur_offset,
6874                depth,
6875            )?;
6876
6877            _prev_end_offset = cur_offset + envelope_size;
6878            if 4 > max_ordinal {
6879                return Ok(());
6880            }
6881
6882            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6883            // are envelope_size bytes.
6884            let cur_offset: usize = (4 - 1) * envelope_size;
6885
6886            // Zero reserved fields.
6887            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6888
6889            // Safety:
6890            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6891            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6892            //   envelope_size bytes, there is always sufficient room.
6893            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
6894            self.association_ies.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
6895            encoder, offset + cur_offset, depth
6896        )?;
6897
6898            _prev_end_offset = cur_offset + envelope_size;
6899
6900            Ok(())
6901        }
6902    }
6903
6904    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6905        for WlanFullmacImplIfcConnectConfRequest
6906    {
6907        #[inline(always)]
6908        fn new_empty() -> Self {
6909            Self::default()
6910        }
6911
6912        unsafe fn decode(
6913            &mut self,
6914            decoder: &mut fidl::encoding::Decoder<'_, D>,
6915            offset: usize,
6916            mut depth: fidl::encoding::Depth,
6917        ) -> fidl::Result<()> {
6918            decoder.debug_check_bounds::<Self>(offset);
6919            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6920                None => return Err(fidl::Error::NotNullable),
6921                Some(len) => len,
6922            };
6923            // Calling decoder.out_of_line_offset(0) is not allowed.
6924            if len == 0 {
6925                return Ok(());
6926            };
6927            depth.increment()?;
6928            let envelope_size = 8;
6929            let bytes_len = len * envelope_size;
6930            let offset = decoder.out_of_line_offset(bytes_len)?;
6931            // Decode the envelope for each type.
6932            let mut _next_ordinal_to_read = 0;
6933            let mut next_offset = offset;
6934            let end_offset = offset + bytes_len;
6935            _next_ordinal_to_read += 1;
6936            if next_offset >= end_offset {
6937                return Ok(());
6938            }
6939
6940            // Decode unknown envelopes for gaps in ordinals.
6941            while _next_ordinal_to_read < 1 {
6942                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6943                _next_ordinal_to_read += 1;
6944                next_offset += envelope_size;
6945            }
6946
6947            let next_out_of_line = decoder.next_out_of_line();
6948            let handles_before = decoder.remaining_handles();
6949            if let Some((inlined, num_bytes, num_handles)) =
6950                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6951            {
6952                let member_inline_size =
6953                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
6954                        decoder.context,
6955                    );
6956                if inlined != (member_inline_size <= 4) {
6957                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6958                }
6959                let inner_offset;
6960                let mut inner_depth = depth.clone();
6961                if inlined {
6962                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6963                    inner_offset = next_offset;
6964                } else {
6965                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6966                    inner_depth.increment()?;
6967                }
6968                let val_ref = self
6969                    .peer_sta_address
6970                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
6971                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
6972                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6973                {
6974                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6975                }
6976                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6977                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6978                }
6979            }
6980
6981            next_offset += envelope_size;
6982            _next_ordinal_to_read += 1;
6983            if next_offset >= end_offset {
6984                return Ok(());
6985            }
6986
6987            // Decode unknown envelopes for gaps in ordinals.
6988            while _next_ordinal_to_read < 2 {
6989                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6990                _next_ordinal_to_read += 1;
6991                next_offset += envelope_size;
6992            }
6993
6994            let next_out_of_line = decoder.next_out_of_line();
6995            let handles_before = decoder.remaining_handles();
6996            if let Some((inlined, num_bytes, num_handles)) =
6997                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6998            {
6999                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7000                if inlined != (member_inline_size <= 4) {
7001                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7002                }
7003                let inner_offset;
7004                let mut inner_depth = depth.clone();
7005                if inlined {
7006                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7007                    inner_offset = next_offset;
7008                } else {
7009                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7010                    inner_depth.increment()?;
7011                }
7012                let val_ref = self.result_code.get_or_insert_with(|| {
7013                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
7014                });
7015                fidl::decode!(
7016                    fidl_fuchsia_wlan_ieee80211__common::StatusCode,
7017                    D,
7018                    val_ref,
7019                    decoder,
7020                    inner_offset,
7021                    inner_depth
7022                )?;
7023                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7024                {
7025                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7026                }
7027                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7028                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7029                }
7030            }
7031
7032            next_offset += envelope_size;
7033            _next_ordinal_to_read += 1;
7034            if next_offset >= end_offset {
7035                return Ok(());
7036            }
7037
7038            // Decode unknown envelopes for gaps in ordinals.
7039            while _next_ordinal_to_read < 3 {
7040                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7041                _next_ordinal_to_read += 1;
7042                next_offset += envelope_size;
7043            }
7044
7045            let next_out_of_line = decoder.next_out_of_line();
7046            let handles_before = decoder.remaining_handles();
7047            if let Some((inlined, num_bytes, num_handles)) =
7048                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7049            {
7050                let member_inline_size =
7051                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7052                if inlined != (member_inline_size <= 4) {
7053                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7054                }
7055                let inner_offset;
7056                let mut inner_depth = depth.clone();
7057                if inlined {
7058                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7059                    inner_offset = next_offset;
7060                } else {
7061                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7062                    inner_depth.increment()?;
7063                }
7064                let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
7065                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
7066                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7067                {
7068                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7069                }
7070                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7071                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7072                }
7073            }
7074
7075            next_offset += envelope_size;
7076            _next_ordinal_to_read += 1;
7077            if next_offset >= end_offset {
7078                return Ok(());
7079            }
7080
7081            // Decode unknown envelopes for gaps in ordinals.
7082            while _next_ordinal_to_read < 4 {
7083                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7084                _next_ordinal_to_read += 1;
7085                next_offset += envelope_size;
7086            }
7087
7088            let next_out_of_line = decoder.next_out_of_line();
7089            let handles_before = decoder.remaining_handles();
7090            if let Some((inlined, num_bytes, num_handles)) =
7091                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7092            {
7093                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7094                if inlined != (member_inline_size <= 4) {
7095                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7096                }
7097                let inner_offset;
7098                let mut inner_depth = depth.clone();
7099                if inlined {
7100                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7101                    inner_offset = next_offset;
7102                } else {
7103                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7104                    inner_depth.increment()?;
7105                }
7106                let val_ref = self.association_ies.get_or_insert_with(|| {
7107                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
7108                });
7109                fidl::decode!(
7110                    fidl::encoding::UnboundedVector<u8>,
7111                    D,
7112                    val_ref,
7113                    decoder,
7114                    inner_offset,
7115                    inner_depth
7116                )?;
7117                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7118                {
7119                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7120                }
7121                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7122                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7123                }
7124            }
7125
7126            next_offset += envelope_size;
7127
7128            // Decode the remaining unknown envelopes.
7129            while next_offset < end_offset {
7130                _next_ordinal_to_read += 1;
7131                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7132                next_offset += envelope_size;
7133            }
7134
7135            Ok(())
7136        }
7137    }
7138
7139    impl WlanFullmacImplIfcDeauthConfRequest {
7140        #[inline(always)]
7141        fn max_ordinal_present(&self) -> u64 {
7142            if let Some(_) = self.peer_sta_address {
7143                return 1;
7144            }
7145            0
7146        }
7147    }
7148
7149    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDeauthConfRequest {
7150        type Borrowed<'a> = &'a Self;
7151        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7152            value
7153        }
7154    }
7155
7156    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDeauthConfRequest {
7157        type Owned = Self;
7158
7159        #[inline(always)]
7160        fn inline_align(_context: fidl::encoding::Context) -> usize {
7161            8
7162        }
7163
7164        #[inline(always)]
7165        fn inline_size(_context: fidl::encoding::Context) -> usize {
7166            16
7167        }
7168    }
7169
7170    unsafe impl<D: fidl::encoding::ResourceDialect>
7171        fidl::encoding::Encode<WlanFullmacImplIfcDeauthConfRequest, D>
7172        for &WlanFullmacImplIfcDeauthConfRequest
7173    {
7174        unsafe fn encode(
7175            self,
7176            encoder: &mut fidl::encoding::Encoder<'_, D>,
7177            offset: usize,
7178            mut depth: fidl::encoding::Depth,
7179        ) -> fidl::Result<()> {
7180            encoder.debug_check_bounds::<WlanFullmacImplIfcDeauthConfRequest>(offset);
7181            // Vector header
7182            let max_ordinal: u64 = self.max_ordinal_present();
7183            encoder.write_num(max_ordinal, offset);
7184            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7185            // Calling encoder.out_of_line_offset(0) is not allowed.
7186            if max_ordinal == 0 {
7187                return Ok(());
7188            }
7189            depth.increment()?;
7190            let envelope_size = 8;
7191            let bytes_len = max_ordinal as usize * envelope_size;
7192            #[allow(unused_variables)]
7193            let offset = encoder.out_of_line_offset(bytes_len);
7194            let mut _prev_end_offset: usize = 0;
7195            if 1 > max_ordinal {
7196                return Ok(());
7197            }
7198
7199            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7200            // are envelope_size bytes.
7201            let cur_offset: usize = (1 - 1) * envelope_size;
7202
7203            // Zero reserved fields.
7204            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7205
7206            // Safety:
7207            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7208            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7209            //   envelope_size bytes, there is always sufficient room.
7210            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
7211                self.peer_sta_address
7212                    .as_ref()
7213                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
7214                encoder,
7215                offset + cur_offset,
7216                depth,
7217            )?;
7218
7219            _prev_end_offset = cur_offset + envelope_size;
7220
7221            Ok(())
7222        }
7223    }
7224
7225    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7226        for WlanFullmacImplIfcDeauthConfRequest
7227    {
7228        #[inline(always)]
7229        fn new_empty() -> Self {
7230            Self::default()
7231        }
7232
7233        unsafe fn decode(
7234            &mut self,
7235            decoder: &mut fidl::encoding::Decoder<'_, D>,
7236            offset: usize,
7237            mut depth: fidl::encoding::Depth,
7238        ) -> fidl::Result<()> {
7239            decoder.debug_check_bounds::<Self>(offset);
7240            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7241                None => return Err(fidl::Error::NotNullable),
7242                Some(len) => len,
7243            };
7244            // Calling decoder.out_of_line_offset(0) is not allowed.
7245            if len == 0 {
7246                return Ok(());
7247            };
7248            depth.increment()?;
7249            let envelope_size = 8;
7250            let bytes_len = len * envelope_size;
7251            let offset = decoder.out_of_line_offset(bytes_len)?;
7252            // Decode the envelope for each type.
7253            let mut _next_ordinal_to_read = 0;
7254            let mut next_offset = offset;
7255            let end_offset = offset + bytes_len;
7256            _next_ordinal_to_read += 1;
7257            if next_offset >= end_offset {
7258                return Ok(());
7259            }
7260
7261            // Decode unknown envelopes for gaps in ordinals.
7262            while _next_ordinal_to_read < 1 {
7263                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7264                _next_ordinal_to_read += 1;
7265                next_offset += envelope_size;
7266            }
7267
7268            let next_out_of_line = decoder.next_out_of_line();
7269            let handles_before = decoder.remaining_handles();
7270            if let Some((inlined, num_bytes, num_handles)) =
7271                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7272            {
7273                let member_inline_size =
7274                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
7275                        decoder.context,
7276                    );
7277                if inlined != (member_inline_size <= 4) {
7278                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7279                }
7280                let inner_offset;
7281                let mut inner_depth = depth.clone();
7282                if inlined {
7283                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7284                    inner_offset = next_offset;
7285                } else {
7286                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7287                    inner_depth.increment()?;
7288                }
7289                let val_ref = self
7290                    .peer_sta_address
7291                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
7292                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
7293                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7294                {
7295                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7296                }
7297                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7298                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7299                }
7300            }
7301
7302            next_offset += envelope_size;
7303
7304            // Decode the remaining unknown envelopes.
7305            while next_offset < end_offset {
7306                _next_ordinal_to_read += 1;
7307                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7308                next_offset += envelope_size;
7309            }
7310
7311            Ok(())
7312        }
7313    }
7314
7315    impl WlanFullmacImplIfcDeauthIndRequest {
7316        #[inline(always)]
7317        fn max_ordinal_present(&self) -> u64 {
7318            if let Some(_) = self.locally_initiated {
7319                return 3;
7320            }
7321            if let Some(_) = self.reason_code {
7322                return 2;
7323            }
7324            if let Some(_) = self.peer_sta_address {
7325                return 1;
7326            }
7327            0
7328        }
7329    }
7330
7331    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDeauthIndRequest {
7332        type Borrowed<'a> = &'a Self;
7333        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7334            value
7335        }
7336    }
7337
7338    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDeauthIndRequest {
7339        type Owned = Self;
7340
7341        #[inline(always)]
7342        fn inline_align(_context: fidl::encoding::Context) -> usize {
7343            8
7344        }
7345
7346        #[inline(always)]
7347        fn inline_size(_context: fidl::encoding::Context) -> usize {
7348            16
7349        }
7350    }
7351
7352    unsafe impl<D: fidl::encoding::ResourceDialect>
7353        fidl::encoding::Encode<WlanFullmacImplIfcDeauthIndRequest, D>
7354        for &WlanFullmacImplIfcDeauthIndRequest
7355    {
7356        unsafe fn encode(
7357            self,
7358            encoder: &mut fidl::encoding::Encoder<'_, D>,
7359            offset: usize,
7360            mut depth: fidl::encoding::Depth,
7361        ) -> fidl::Result<()> {
7362            encoder.debug_check_bounds::<WlanFullmacImplIfcDeauthIndRequest>(offset);
7363            // Vector header
7364            let max_ordinal: u64 = self.max_ordinal_present();
7365            encoder.write_num(max_ordinal, offset);
7366            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7367            // Calling encoder.out_of_line_offset(0) is not allowed.
7368            if max_ordinal == 0 {
7369                return Ok(());
7370            }
7371            depth.increment()?;
7372            let envelope_size = 8;
7373            let bytes_len = max_ordinal as usize * envelope_size;
7374            #[allow(unused_variables)]
7375            let offset = encoder.out_of_line_offset(bytes_len);
7376            let mut _prev_end_offset: usize = 0;
7377            if 1 > max_ordinal {
7378                return Ok(());
7379            }
7380
7381            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7382            // are envelope_size bytes.
7383            let cur_offset: usize = (1 - 1) * envelope_size;
7384
7385            // Zero reserved fields.
7386            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7387
7388            // Safety:
7389            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7390            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7391            //   envelope_size bytes, there is always sufficient room.
7392            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
7393                self.peer_sta_address
7394                    .as_ref()
7395                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
7396                encoder,
7397                offset + cur_offset,
7398                depth,
7399            )?;
7400
7401            _prev_end_offset = cur_offset + envelope_size;
7402            if 2 > max_ordinal {
7403                return Ok(());
7404            }
7405
7406            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7407            // are envelope_size bytes.
7408            let cur_offset: usize = (2 - 1) * envelope_size;
7409
7410            // Zero reserved fields.
7411            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7412
7413            // Safety:
7414            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7415            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7416            //   envelope_size bytes, there is always sufficient room.
7417            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
7418            self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
7419            encoder, offset + cur_offset, depth
7420        )?;
7421
7422            _prev_end_offset = cur_offset + envelope_size;
7423            if 3 > max_ordinal {
7424                return Ok(());
7425            }
7426
7427            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7428            // are envelope_size bytes.
7429            let cur_offset: usize = (3 - 1) * envelope_size;
7430
7431            // Zero reserved fields.
7432            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7433
7434            // Safety:
7435            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7436            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7437            //   envelope_size bytes, there is always sufficient room.
7438            fidl::encoding::encode_in_envelope_optional::<bool, D>(
7439                self.locally_initiated
7440                    .as_ref()
7441                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7442                encoder,
7443                offset + cur_offset,
7444                depth,
7445            )?;
7446
7447            _prev_end_offset = cur_offset + envelope_size;
7448
7449            Ok(())
7450        }
7451    }
7452
7453    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7454        for WlanFullmacImplIfcDeauthIndRequest
7455    {
7456        #[inline(always)]
7457        fn new_empty() -> Self {
7458            Self::default()
7459        }
7460
7461        unsafe fn decode(
7462            &mut self,
7463            decoder: &mut fidl::encoding::Decoder<'_, D>,
7464            offset: usize,
7465            mut depth: fidl::encoding::Depth,
7466        ) -> fidl::Result<()> {
7467            decoder.debug_check_bounds::<Self>(offset);
7468            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7469                None => return Err(fidl::Error::NotNullable),
7470                Some(len) => len,
7471            };
7472            // Calling decoder.out_of_line_offset(0) is not allowed.
7473            if len == 0 {
7474                return Ok(());
7475            };
7476            depth.increment()?;
7477            let envelope_size = 8;
7478            let bytes_len = len * envelope_size;
7479            let offset = decoder.out_of_line_offset(bytes_len)?;
7480            // Decode the envelope for each type.
7481            let mut _next_ordinal_to_read = 0;
7482            let mut next_offset = offset;
7483            let end_offset = offset + bytes_len;
7484            _next_ordinal_to_read += 1;
7485            if next_offset >= end_offset {
7486                return Ok(());
7487            }
7488
7489            // Decode unknown envelopes for gaps in ordinals.
7490            while _next_ordinal_to_read < 1 {
7491                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7492                _next_ordinal_to_read += 1;
7493                next_offset += envelope_size;
7494            }
7495
7496            let next_out_of_line = decoder.next_out_of_line();
7497            let handles_before = decoder.remaining_handles();
7498            if let Some((inlined, num_bytes, num_handles)) =
7499                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7500            {
7501                let member_inline_size =
7502                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
7503                        decoder.context,
7504                    );
7505                if inlined != (member_inline_size <= 4) {
7506                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7507                }
7508                let inner_offset;
7509                let mut inner_depth = depth.clone();
7510                if inlined {
7511                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7512                    inner_offset = next_offset;
7513                } else {
7514                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7515                    inner_depth.increment()?;
7516                }
7517                let val_ref = self
7518                    .peer_sta_address
7519                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
7520                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
7521                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7522                {
7523                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7524                }
7525                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7526                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7527                }
7528            }
7529
7530            next_offset += envelope_size;
7531            _next_ordinal_to_read += 1;
7532            if next_offset >= end_offset {
7533                return Ok(());
7534            }
7535
7536            // Decode unknown envelopes for gaps in ordinals.
7537            while _next_ordinal_to_read < 2 {
7538                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7539                _next_ordinal_to_read += 1;
7540                next_offset += envelope_size;
7541            }
7542
7543            let next_out_of_line = decoder.next_out_of_line();
7544            let handles_before = decoder.remaining_handles();
7545            if let Some((inlined, num_bytes, num_handles)) =
7546                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7547            {
7548                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7549                if inlined != (member_inline_size <= 4) {
7550                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7551                }
7552                let inner_offset;
7553                let mut inner_depth = depth.clone();
7554                if inlined {
7555                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7556                    inner_offset = next_offset;
7557                } else {
7558                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7559                    inner_depth.increment()?;
7560                }
7561                let val_ref = self.reason_code.get_or_insert_with(|| {
7562                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
7563                });
7564                fidl::decode!(
7565                    fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
7566                    D,
7567                    val_ref,
7568                    decoder,
7569                    inner_offset,
7570                    inner_depth
7571                )?;
7572                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7573                {
7574                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7575                }
7576                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7577                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7578                }
7579            }
7580
7581            next_offset += envelope_size;
7582            _next_ordinal_to_read += 1;
7583            if next_offset >= end_offset {
7584                return Ok(());
7585            }
7586
7587            // Decode unknown envelopes for gaps in ordinals.
7588            while _next_ordinal_to_read < 3 {
7589                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7590                _next_ordinal_to_read += 1;
7591                next_offset += envelope_size;
7592            }
7593
7594            let next_out_of_line = decoder.next_out_of_line();
7595            let handles_before = decoder.remaining_handles();
7596            if let Some((inlined, num_bytes, num_handles)) =
7597                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7598            {
7599                let member_inline_size =
7600                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7601                if inlined != (member_inline_size <= 4) {
7602                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7603                }
7604                let inner_offset;
7605                let mut inner_depth = depth.clone();
7606                if inlined {
7607                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7608                    inner_offset = next_offset;
7609                } else {
7610                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7611                    inner_depth.increment()?;
7612                }
7613                let val_ref =
7614                    self.locally_initiated.get_or_insert_with(|| fidl::new_empty!(bool, D));
7615                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7616                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7617                {
7618                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7619                }
7620                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7621                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7622                }
7623            }
7624
7625            next_offset += envelope_size;
7626
7627            // Decode the remaining unknown envelopes.
7628            while next_offset < end_offset {
7629                _next_ordinal_to_read += 1;
7630                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7631                next_offset += envelope_size;
7632            }
7633
7634            Ok(())
7635        }
7636    }
7637
7638    impl WlanFullmacImplIfcDisassocConfRequest {
7639        #[inline(always)]
7640        fn max_ordinal_present(&self) -> u64 {
7641            if let Some(_) = self.status {
7642                return 1;
7643            }
7644            0
7645        }
7646    }
7647
7648    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDisassocConfRequest {
7649        type Borrowed<'a> = &'a Self;
7650        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7651            value
7652        }
7653    }
7654
7655    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDisassocConfRequest {
7656        type Owned = Self;
7657
7658        #[inline(always)]
7659        fn inline_align(_context: fidl::encoding::Context) -> usize {
7660            8
7661        }
7662
7663        #[inline(always)]
7664        fn inline_size(_context: fidl::encoding::Context) -> usize {
7665            16
7666        }
7667    }
7668
7669    unsafe impl<D: fidl::encoding::ResourceDialect>
7670        fidl::encoding::Encode<WlanFullmacImplIfcDisassocConfRequest, D>
7671        for &WlanFullmacImplIfcDisassocConfRequest
7672    {
7673        unsafe fn encode(
7674            self,
7675            encoder: &mut fidl::encoding::Encoder<'_, D>,
7676            offset: usize,
7677            mut depth: fidl::encoding::Depth,
7678        ) -> fidl::Result<()> {
7679            encoder.debug_check_bounds::<WlanFullmacImplIfcDisassocConfRequest>(offset);
7680            // Vector header
7681            let max_ordinal: u64 = self.max_ordinal_present();
7682            encoder.write_num(max_ordinal, offset);
7683            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7684            // Calling encoder.out_of_line_offset(0) is not allowed.
7685            if max_ordinal == 0 {
7686                return Ok(());
7687            }
7688            depth.increment()?;
7689            let envelope_size = 8;
7690            let bytes_len = max_ordinal as usize * envelope_size;
7691            #[allow(unused_variables)]
7692            let offset = encoder.out_of_line_offset(bytes_len);
7693            let mut _prev_end_offset: usize = 0;
7694            if 1 > max_ordinal {
7695                return Ok(());
7696            }
7697
7698            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7699            // are envelope_size bytes.
7700            let cur_offset: usize = (1 - 1) * envelope_size;
7701
7702            // Zero reserved fields.
7703            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7704
7705            // Safety:
7706            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7707            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7708            //   envelope_size bytes, there is always sufficient room.
7709            fidl::encoding::encode_in_envelope_optional::<i32, D>(
7710                self.status.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
7711                encoder,
7712                offset + cur_offset,
7713                depth,
7714            )?;
7715
7716            _prev_end_offset = cur_offset + envelope_size;
7717
7718            Ok(())
7719        }
7720    }
7721
7722    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7723        for WlanFullmacImplIfcDisassocConfRequest
7724    {
7725        #[inline(always)]
7726        fn new_empty() -> Self {
7727            Self::default()
7728        }
7729
7730        unsafe fn decode(
7731            &mut self,
7732            decoder: &mut fidl::encoding::Decoder<'_, D>,
7733            offset: usize,
7734            mut depth: fidl::encoding::Depth,
7735        ) -> fidl::Result<()> {
7736            decoder.debug_check_bounds::<Self>(offset);
7737            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7738                None => return Err(fidl::Error::NotNullable),
7739                Some(len) => len,
7740            };
7741            // Calling decoder.out_of_line_offset(0) is not allowed.
7742            if len == 0 {
7743                return Ok(());
7744            };
7745            depth.increment()?;
7746            let envelope_size = 8;
7747            let bytes_len = len * envelope_size;
7748            let offset = decoder.out_of_line_offset(bytes_len)?;
7749            // Decode the envelope for each type.
7750            let mut _next_ordinal_to_read = 0;
7751            let mut next_offset = offset;
7752            let end_offset = offset + bytes_len;
7753            _next_ordinal_to_read += 1;
7754            if next_offset >= end_offset {
7755                return Ok(());
7756            }
7757
7758            // Decode unknown envelopes for gaps in ordinals.
7759            while _next_ordinal_to_read < 1 {
7760                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7761                _next_ordinal_to_read += 1;
7762                next_offset += envelope_size;
7763            }
7764
7765            let next_out_of_line = decoder.next_out_of_line();
7766            let handles_before = decoder.remaining_handles();
7767            if let Some((inlined, num_bytes, num_handles)) =
7768                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7769            {
7770                let member_inline_size =
7771                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7772                if inlined != (member_inline_size <= 4) {
7773                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7774                }
7775                let inner_offset;
7776                let mut inner_depth = depth.clone();
7777                if inlined {
7778                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7779                    inner_offset = next_offset;
7780                } else {
7781                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7782                    inner_depth.increment()?;
7783                }
7784                let val_ref = self.status.get_or_insert_with(|| fidl::new_empty!(i32, D));
7785                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
7786                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7787                {
7788                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7789                }
7790                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7791                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7792                }
7793            }
7794
7795            next_offset += envelope_size;
7796
7797            // Decode the remaining unknown envelopes.
7798            while next_offset < end_offset {
7799                _next_ordinal_to_read += 1;
7800                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7801                next_offset += envelope_size;
7802            }
7803
7804            Ok(())
7805        }
7806    }
7807
7808    impl WlanFullmacImplIfcDisassocIndRequest {
7809        #[inline(always)]
7810        fn max_ordinal_present(&self) -> u64 {
7811            if let Some(_) = self.locally_initiated {
7812                return 3;
7813            }
7814            if let Some(_) = self.reason_code {
7815                return 2;
7816            }
7817            if let Some(_) = self.peer_sta_address {
7818                return 1;
7819            }
7820            0
7821        }
7822    }
7823
7824    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDisassocIndRequest {
7825        type Borrowed<'a> = &'a Self;
7826        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7827            value
7828        }
7829    }
7830
7831    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDisassocIndRequest {
7832        type Owned = Self;
7833
7834        #[inline(always)]
7835        fn inline_align(_context: fidl::encoding::Context) -> usize {
7836            8
7837        }
7838
7839        #[inline(always)]
7840        fn inline_size(_context: fidl::encoding::Context) -> usize {
7841            16
7842        }
7843    }
7844
7845    unsafe impl<D: fidl::encoding::ResourceDialect>
7846        fidl::encoding::Encode<WlanFullmacImplIfcDisassocIndRequest, D>
7847        for &WlanFullmacImplIfcDisassocIndRequest
7848    {
7849        unsafe fn encode(
7850            self,
7851            encoder: &mut fidl::encoding::Encoder<'_, D>,
7852            offset: usize,
7853            mut depth: fidl::encoding::Depth,
7854        ) -> fidl::Result<()> {
7855            encoder.debug_check_bounds::<WlanFullmacImplIfcDisassocIndRequest>(offset);
7856            // Vector header
7857            let max_ordinal: u64 = self.max_ordinal_present();
7858            encoder.write_num(max_ordinal, offset);
7859            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7860            // Calling encoder.out_of_line_offset(0) is not allowed.
7861            if max_ordinal == 0 {
7862                return Ok(());
7863            }
7864            depth.increment()?;
7865            let envelope_size = 8;
7866            let bytes_len = max_ordinal as usize * envelope_size;
7867            #[allow(unused_variables)]
7868            let offset = encoder.out_of_line_offset(bytes_len);
7869            let mut _prev_end_offset: usize = 0;
7870            if 1 > max_ordinal {
7871                return Ok(());
7872            }
7873
7874            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7875            // are envelope_size bytes.
7876            let cur_offset: usize = (1 - 1) * envelope_size;
7877
7878            // Zero reserved fields.
7879            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7880
7881            // Safety:
7882            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7883            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7884            //   envelope_size bytes, there is always sufficient room.
7885            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
7886                self.peer_sta_address
7887                    .as_ref()
7888                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
7889                encoder,
7890                offset + cur_offset,
7891                depth,
7892            )?;
7893
7894            _prev_end_offset = cur_offset + envelope_size;
7895            if 2 > max_ordinal {
7896                return Ok(());
7897            }
7898
7899            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7900            // are envelope_size bytes.
7901            let cur_offset: usize = (2 - 1) * envelope_size;
7902
7903            // Zero reserved fields.
7904            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7905
7906            // Safety:
7907            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7908            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7909            //   envelope_size bytes, there is always sufficient room.
7910            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
7911            self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
7912            encoder, offset + cur_offset, depth
7913        )?;
7914
7915            _prev_end_offset = cur_offset + envelope_size;
7916            if 3 > max_ordinal {
7917                return Ok(());
7918            }
7919
7920            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7921            // are envelope_size bytes.
7922            let cur_offset: usize = (3 - 1) * envelope_size;
7923
7924            // Zero reserved fields.
7925            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7926
7927            // Safety:
7928            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7929            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7930            //   envelope_size bytes, there is always sufficient room.
7931            fidl::encoding::encode_in_envelope_optional::<bool, D>(
7932                self.locally_initiated
7933                    .as_ref()
7934                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7935                encoder,
7936                offset + cur_offset,
7937                depth,
7938            )?;
7939
7940            _prev_end_offset = cur_offset + envelope_size;
7941
7942            Ok(())
7943        }
7944    }
7945
7946    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7947        for WlanFullmacImplIfcDisassocIndRequest
7948    {
7949        #[inline(always)]
7950        fn new_empty() -> Self {
7951            Self::default()
7952        }
7953
7954        unsafe fn decode(
7955            &mut self,
7956            decoder: &mut fidl::encoding::Decoder<'_, D>,
7957            offset: usize,
7958            mut depth: fidl::encoding::Depth,
7959        ) -> fidl::Result<()> {
7960            decoder.debug_check_bounds::<Self>(offset);
7961            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7962                None => return Err(fidl::Error::NotNullable),
7963                Some(len) => len,
7964            };
7965            // Calling decoder.out_of_line_offset(0) is not allowed.
7966            if len == 0 {
7967                return Ok(());
7968            };
7969            depth.increment()?;
7970            let envelope_size = 8;
7971            let bytes_len = len * envelope_size;
7972            let offset = decoder.out_of_line_offset(bytes_len)?;
7973            // Decode the envelope for each type.
7974            let mut _next_ordinal_to_read = 0;
7975            let mut next_offset = offset;
7976            let end_offset = offset + bytes_len;
7977            _next_ordinal_to_read += 1;
7978            if next_offset >= end_offset {
7979                return Ok(());
7980            }
7981
7982            // Decode unknown envelopes for gaps in ordinals.
7983            while _next_ordinal_to_read < 1 {
7984                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7985                _next_ordinal_to_read += 1;
7986                next_offset += envelope_size;
7987            }
7988
7989            let next_out_of_line = decoder.next_out_of_line();
7990            let handles_before = decoder.remaining_handles();
7991            if let Some((inlined, num_bytes, num_handles)) =
7992                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7993            {
7994                let member_inline_size =
7995                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
7996                        decoder.context,
7997                    );
7998                if inlined != (member_inline_size <= 4) {
7999                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8000                }
8001                let inner_offset;
8002                let mut inner_depth = depth.clone();
8003                if inlined {
8004                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8005                    inner_offset = next_offset;
8006                } else {
8007                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8008                    inner_depth.increment()?;
8009                }
8010                let val_ref = self
8011                    .peer_sta_address
8012                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8013                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
8014                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8015                {
8016                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8017                }
8018                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8019                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8020                }
8021            }
8022
8023            next_offset += envelope_size;
8024            _next_ordinal_to_read += 1;
8025            if next_offset >= end_offset {
8026                return Ok(());
8027            }
8028
8029            // Decode unknown envelopes for gaps in ordinals.
8030            while _next_ordinal_to_read < 2 {
8031                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8032                _next_ordinal_to_read += 1;
8033                next_offset += envelope_size;
8034            }
8035
8036            let next_out_of_line = decoder.next_out_of_line();
8037            let handles_before = decoder.remaining_handles();
8038            if let Some((inlined, num_bytes, num_handles)) =
8039                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8040            {
8041                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8042                if inlined != (member_inline_size <= 4) {
8043                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8044                }
8045                let inner_offset;
8046                let mut inner_depth = depth.clone();
8047                if inlined {
8048                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8049                    inner_offset = next_offset;
8050                } else {
8051                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8052                    inner_depth.increment()?;
8053                }
8054                let val_ref = self.reason_code.get_or_insert_with(|| {
8055                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
8056                });
8057                fidl::decode!(
8058                    fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
8059                    D,
8060                    val_ref,
8061                    decoder,
8062                    inner_offset,
8063                    inner_depth
8064                )?;
8065                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8066                {
8067                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8068                }
8069                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8070                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8071                }
8072            }
8073
8074            next_offset += envelope_size;
8075            _next_ordinal_to_read += 1;
8076            if next_offset >= end_offset {
8077                return Ok(());
8078            }
8079
8080            // Decode unknown envelopes for gaps in ordinals.
8081            while _next_ordinal_to_read < 3 {
8082                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8083                _next_ordinal_to_read += 1;
8084                next_offset += envelope_size;
8085            }
8086
8087            let next_out_of_line = decoder.next_out_of_line();
8088            let handles_before = decoder.remaining_handles();
8089            if let Some((inlined, num_bytes, num_handles)) =
8090                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8091            {
8092                let member_inline_size =
8093                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8094                if inlined != (member_inline_size <= 4) {
8095                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8096                }
8097                let inner_offset;
8098                let mut inner_depth = depth.clone();
8099                if inlined {
8100                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8101                    inner_offset = next_offset;
8102                } else {
8103                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8104                    inner_depth.increment()?;
8105                }
8106                let val_ref =
8107                    self.locally_initiated.get_or_insert_with(|| fidl::new_empty!(bool, D));
8108                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8109                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8110                {
8111                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8112                }
8113                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8114                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8115                }
8116            }
8117
8118            next_offset += envelope_size;
8119
8120            // Decode the remaining unknown envelopes.
8121            while next_offset < end_offset {
8122                _next_ordinal_to_read += 1;
8123                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8124                next_offset += envelope_size;
8125            }
8126
8127            Ok(())
8128        }
8129    }
8130
8131    impl WlanFullmacImplIfcEapolConfRequest {
8132        #[inline(always)]
8133        fn max_ordinal_present(&self) -> u64 {
8134            if let Some(_) = self.dst_addr {
8135                return 2;
8136            }
8137            if let Some(_) = self.result_code {
8138                return 1;
8139            }
8140            0
8141        }
8142    }
8143
8144    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcEapolConfRequest {
8145        type Borrowed<'a> = &'a Self;
8146        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8147            value
8148        }
8149    }
8150
8151    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcEapolConfRequest {
8152        type Owned = Self;
8153
8154        #[inline(always)]
8155        fn inline_align(_context: fidl::encoding::Context) -> usize {
8156            8
8157        }
8158
8159        #[inline(always)]
8160        fn inline_size(_context: fidl::encoding::Context) -> usize {
8161            16
8162        }
8163    }
8164
8165    unsafe impl<D: fidl::encoding::ResourceDialect>
8166        fidl::encoding::Encode<WlanFullmacImplIfcEapolConfRequest, D>
8167        for &WlanFullmacImplIfcEapolConfRequest
8168    {
8169        unsafe fn encode(
8170            self,
8171            encoder: &mut fidl::encoding::Encoder<'_, D>,
8172            offset: usize,
8173            mut depth: fidl::encoding::Depth,
8174        ) -> fidl::Result<()> {
8175            encoder.debug_check_bounds::<WlanFullmacImplIfcEapolConfRequest>(offset);
8176            // Vector header
8177            let max_ordinal: u64 = self.max_ordinal_present();
8178            encoder.write_num(max_ordinal, offset);
8179            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8180            // Calling encoder.out_of_line_offset(0) is not allowed.
8181            if max_ordinal == 0 {
8182                return Ok(());
8183            }
8184            depth.increment()?;
8185            let envelope_size = 8;
8186            let bytes_len = max_ordinal as usize * envelope_size;
8187            #[allow(unused_variables)]
8188            let offset = encoder.out_of_line_offset(bytes_len);
8189            let mut _prev_end_offset: usize = 0;
8190            if 1 > max_ordinal {
8191                return Ok(());
8192            }
8193
8194            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8195            // are envelope_size bytes.
8196            let cur_offset: usize = (1 - 1) * envelope_size;
8197
8198            // Zero reserved fields.
8199            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8200
8201            // Safety:
8202            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8203            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8204            //   envelope_size bytes, there is always sufficient room.
8205            fidl::encoding::encode_in_envelope_optional::<EapolTxResult, D>(
8206                self.result_code
8207                    .as_ref()
8208                    .map(<EapolTxResult as fidl::encoding::ValueTypeMarker>::borrow),
8209                encoder,
8210                offset + cur_offset,
8211                depth,
8212            )?;
8213
8214            _prev_end_offset = cur_offset + envelope_size;
8215            if 2 > max_ordinal {
8216                return Ok(());
8217            }
8218
8219            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8220            // are envelope_size bytes.
8221            let cur_offset: usize = (2 - 1) * envelope_size;
8222
8223            // Zero reserved fields.
8224            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8225
8226            // Safety:
8227            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8228            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8229            //   envelope_size bytes, there is always sufficient room.
8230            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
8231                self.dst_addr
8232                    .as_ref()
8233                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
8234                encoder,
8235                offset + cur_offset,
8236                depth,
8237            )?;
8238
8239            _prev_end_offset = cur_offset + envelope_size;
8240
8241            Ok(())
8242        }
8243    }
8244
8245    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8246        for WlanFullmacImplIfcEapolConfRequest
8247    {
8248        #[inline(always)]
8249        fn new_empty() -> Self {
8250            Self::default()
8251        }
8252
8253        unsafe fn decode(
8254            &mut self,
8255            decoder: &mut fidl::encoding::Decoder<'_, D>,
8256            offset: usize,
8257            mut depth: fidl::encoding::Depth,
8258        ) -> fidl::Result<()> {
8259            decoder.debug_check_bounds::<Self>(offset);
8260            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8261                None => return Err(fidl::Error::NotNullable),
8262                Some(len) => len,
8263            };
8264            // Calling decoder.out_of_line_offset(0) is not allowed.
8265            if len == 0 {
8266                return Ok(());
8267            };
8268            depth.increment()?;
8269            let envelope_size = 8;
8270            let bytes_len = len * envelope_size;
8271            let offset = decoder.out_of_line_offset(bytes_len)?;
8272            // Decode the envelope for each type.
8273            let mut _next_ordinal_to_read = 0;
8274            let mut next_offset = offset;
8275            let end_offset = offset + bytes_len;
8276            _next_ordinal_to_read += 1;
8277            if next_offset >= end_offset {
8278                return Ok(());
8279            }
8280
8281            // Decode unknown envelopes for gaps in ordinals.
8282            while _next_ordinal_to_read < 1 {
8283                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8284                _next_ordinal_to_read += 1;
8285                next_offset += envelope_size;
8286            }
8287
8288            let next_out_of_line = decoder.next_out_of_line();
8289            let handles_before = decoder.remaining_handles();
8290            if let Some((inlined, num_bytes, num_handles)) =
8291                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8292            {
8293                let member_inline_size =
8294                    <EapolTxResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8295                if inlined != (member_inline_size <= 4) {
8296                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8297                }
8298                let inner_offset;
8299                let mut inner_depth = depth.clone();
8300                if inlined {
8301                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8302                    inner_offset = next_offset;
8303                } else {
8304                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8305                    inner_depth.increment()?;
8306                }
8307                let val_ref =
8308                    self.result_code.get_or_insert_with(|| fidl::new_empty!(EapolTxResult, D));
8309                fidl::decode!(EapolTxResult, D, val_ref, decoder, inner_offset, inner_depth)?;
8310                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8311                {
8312                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8313                }
8314                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8315                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8316                }
8317            }
8318
8319            next_offset += envelope_size;
8320            _next_ordinal_to_read += 1;
8321            if next_offset >= end_offset {
8322                return Ok(());
8323            }
8324
8325            // Decode unknown envelopes for gaps in ordinals.
8326            while _next_ordinal_to_read < 2 {
8327                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8328                _next_ordinal_to_read += 1;
8329                next_offset += envelope_size;
8330            }
8331
8332            let next_out_of_line = decoder.next_out_of_line();
8333            let handles_before = decoder.remaining_handles();
8334            if let Some((inlined, num_bytes, num_handles)) =
8335                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8336            {
8337                let member_inline_size =
8338                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
8339                        decoder.context,
8340                    );
8341                if inlined != (member_inline_size <= 4) {
8342                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8343                }
8344                let inner_offset;
8345                let mut inner_depth = depth.clone();
8346                if inlined {
8347                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8348                    inner_offset = next_offset;
8349                } else {
8350                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8351                    inner_depth.increment()?;
8352                }
8353                let val_ref = self
8354                    .dst_addr
8355                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8356                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
8357                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8358                {
8359                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8360                }
8361                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8362                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8363                }
8364            }
8365
8366            next_offset += envelope_size;
8367
8368            // Decode the remaining unknown envelopes.
8369            while next_offset < end_offset {
8370                _next_ordinal_to_read += 1;
8371                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8372                next_offset += envelope_size;
8373            }
8374
8375            Ok(())
8376        }
8377    }
8378
8379    impl WlanFullmacImplIfcEapolIndRequest {
8380        #[inline(always)]
8381        fn max_ordinal_present(&self) -> u64 {
8382            if let Some(_) = self.data {
8383                return 3;
8384            }
8385            if let Some(_) = self.dst_addr {
8386                return 2;
8387            }
8388            if let Some(_) = self.src_addr {
8389                return 1;
8390            }
8391            0
8392        }
8393    }
8394
8395    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcEapolIndRequest {
8396        type Borrowed<'a> = &'a Self;
8397        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8398            value
8399        }
8400    }
8401
8402    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcEapolIndRequest {
8403        type Owned = Self;
8404
8405        #[inline(always)]
8406        fn inline_align(_context: fidl::encoding::Context) -> usize {
8407            8
8408        }
8409
8410        #[inline(always)]
8411        fn inline_size(_context: fidl::encoding::Context) -> usize {
8412            16
8413        }
8414    }
8415
8416    unsafe impl<D: fidl::encoding::ResourceDialect>
8417        fidl::encoding::Encode<WlanFullmacImplIfcEapolIndRequest, D>
8418        for &WlanFullmacImplIfcEapolIndRequest
8419    {
8420        unsafe fn encode(
8421            self,
8422            encoder: &mut fidl::encoding::Encoder<'_, D>,
8423            offset: usize,
8424            mut depth: fidl::encoding::Depth,
8425        ) -> fidl::Result<()> {
8426            encoder.debug_check_bounds::<WlanFullmacImplIfcEapolIndRequest>(offset);
8427            // Vector header
8428            let max_ordinal: u64 = self.max_ordinal_present();
8429            encoder.write_num(max_ordinal, offset);
8430            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8431            // Calling encoder.out_of_line_offset(0) is not allowed.
8432            if max_ordinal == 0 {
8433                return Ok(());
8434            }
8435            depth.increment()?;
8436            let envelope_size = 8;
8437            let bytes_len = max_ordinal as usize * envelope_size;
8438            #[allow(unused_variables)]
8439            let offset = encoder.out_of_line_offset(bytes_len);
8440            let mut _prev_end_offset: usize = 0;
8441            if 1 > max_ordinal {
8442                return Ok(());
8443            }
8444
8445            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8446            // are envelope_size bytes.
8447            let cur_offset: usize = (1 - 1) * envelope_size;
8448
8449            // Zero reserved fields.
8450            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8451
8452            // Safety:
8453            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8454            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8455            //   envelope_size bytes, there is always sufficient room.
8456            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
8457                self.src_addr
8458                    .as_ref()
8459                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
8460                encoder,
8461                offset + cur_offset,
8462                depth,
8463            )?;
8464
8465            _prev_end_offset = cur_offset + envelope_size;
8466            if 2 > max_ordinal {
8467                return Ok(());
8468            }
8469
8470            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8471            // are envelope_size bytes.
8472            let cur_offset: usize = (2 - 1) * envelope_size;
8473
8474            // Zero reserved fields.
8475            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8476
8477            // Safety:
8478            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8479            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8480            //   envelope_size bytes, there is always sufficient room.
8481            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
8482                self.dst_addr
8483                    .as_ref()
8484                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
8485                encoder,
8486                offset + cur_offset,
8487                depth,
8488            )?;
8489
8490            _prev_end_offset = cur_offset + envelope_size;
8491            if 3 > max_ordinal {
8492                return Ok(());
8493            }
8494
8495            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8496            // are envelope_size bytes.
8497            let cur_offset: usize = (3 - 1) * envelope_size;
8498
8499            // Zero reserved fields.
8500            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8501
8502            // Safety:
8503            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8504            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8505            //   envelope_size bytes, there is always sufficient room.
8506            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8507            self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8508            encoder, offset + cur_offset, depth
8509        )?;
8510
8511            _prev_end_offset = cur_offset + envelope_size;
8512
8513            Ok(())
8514        }
8515    }
8516
8517    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8518        for WlanFullmacImplIfcEapolIndRequest
8519    {
8520        #[inline(always)]
8521        fn new_empty() -> Self {
8522            Self::default()
8523        }
8524
8525        unsafe fn decode(
8526            &mut self,
8527            decoder: &mut fidl::encoding::Decoder<'_, D>,
8528            offset: usize,
8529            mut depth: fidl::encoding::Depth,
8530        ) -> fidl::Result<()> {
8531            decoder.debug_check_bounds::<Self>(offset);
8532            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8533                None => return Err(fidl::Error::NotNullable),
8534                Some(len) => len,
8535            };
8536            // Calling decoder.out_of_line_offset(0) is not allowed.
8537            if len == 0 {
8538                return Ok(());
8539            };
8540            depth.increment()?;
8541            let envelope_size = 8;
8542            let bytes_len = len * envelope_size;
8543            let offset = decoder.out_of_line_offset(bytes_len)?;
8544            // Decode the envelope for each type.
8545            let mut _next_ordinal_to_read = 0;
8546            let mut next_offset = offset;
8547            let end_offset = offset + bytes_len;
8548            _next_ordinal_to_read += 1;
8549            if next_offset >= end_offset {
8550                return Ok(());
8551            }
8552
8553            // Decode unknown envelopes for gaps in ordinals.
8554            while _next_ordinal_to_read < 1 {
8555                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8556                _next_ordinal_to_read += 1;
8557                next_offset += envelope_size;
8558            }
8559
8560            let next_out_of_line = decoder.next_out_of_line();
8561            let handles_before = decoder.remaining_handles();
8562            if let Some((inlined, num_bytes, num_handles)) =
8563                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8564            {
8565                let member_inline_size =
8566                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
8567                        decoder.context,
8568                    );
8569                if inlined != (member_inline_size <= 4) {
8570                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8571                }
8572                let inner_offset;
8573                let mut inner_depth = depth.clone();
8574                if inlined {
8575                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8576                    inner_offset = next_offset;
8577                } else {
8578                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8579                    inner_depth.increment()?;
8580                }
8581                let val_ref = self
8582                    .src_addr
8583                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8584                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
8585                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8586                {
8587                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8588                }
8589                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8590                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8591                }
8592            }
8593
8594            next_offset += envelope_size;
8595            _next_ordinal_to_read += 1;
8596            if next_offset >= end_offset {
8597                return Ok(());
8598            }
8599
8600            // Decode unknown envelopes for gaps in ordinals.
8601            while _next_ordinal_to_read < 2 {
8602                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8603                _next_ordinal_to_read += 1;
8604                next_offset += envelope_size;
8605            }
8606
8607            let next_out_of_line = decoder.next_out_of_line();
8608            let handles_before = decoder.remaining_handles();
8609            if let Some((inlined, num_bytes, num_handles)) =
8610                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8611            {
8612                let member_inline_size =
8613                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
8614                        decoder.context,
8615                    );
8616                if inlined != (member_inline_size <= 4) {
8617                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8618                }
8619                let inner_offset;
8620                let mut inner_depth = depth.clone();
8621                if inlined {
8622                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8623                    inner_offset = next_offset;
8624                } else {
8625                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8626                    inner_depth.increment()?;
8627                }
8628                let val_ref = self
8629                    .dst_addr
8630                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8631                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
8632                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8633                {
8634                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8635                }
8636                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8637                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8638                }
8639            }
8640
8641            next_offset += envelope_size;
8642            _next_ordinal_to_read += 1;
8643            if next_offset >= end_offset {
8644                return Ok(());
8645            }
8646
8647            // Decode unknown envelopes for gaps in ordinals.
8648            while _next_ordinal_to_read < 3 {
8649                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8650                _next_ordinal_to_read += 1;
8651                next_offset += envelope_size;
8652            }
8653
8654            let next_out_of_line = decoder.next_out_of_line();
8655            let handles_before = decoder.remaining_handles();
8656            if let Some((inlined, num_bytes, num_handles)) =
8657                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8658            {
8659                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8660                if inlined != (member_inline_size <= 4) {
8661                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8662                }
8663                let inner_offset;
8664                let mut inner_depth = depth.clone();
8665                if inlined {
8666                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8667                    inner_offset = next_offset;
8668                } else {
8669                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8670                    inner_depth.increment()?;
8671                }
8672                let val_ref = self.data.get_or_insert_with(|| {
8673                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
8674                });
8675                fidl::decode!(
8676                    fidl::encoding::UnboundedVector<u8>,
8677                    D,
8678                    val_ref,
8679                    decoder,
8680                    inner_offset,
8681                    inner_depth
8682                )?;
8683                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8684                {
8685                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8686                }
8687                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8688                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8689                }
8690            }
8691
8692            next_offset += envelope_size;
8693
8694            // Decode the remaining unknown envelopes.
8695            while next_offset < end_offset {
8696                _next_ordinal_to_read += 1;
8697                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8698                next_offset += envelope_size;
8699            }
8700
8701            Ok(())
8702        }
8703    }
8704
8705    impl WlanFullmacImplIfcOnPmkAvailableRequest {
8706        #[inline(always)]
8707        fn max_ordinal_present(&self) -> u64 {
8708            if let Some(_) = self.pmkid {
8709                return 2;
8710            }
8711            if let Some(_) = self.pmk {
8712                return 1;
8713            }
8714            0
8715        }
8716    }
8717
8718    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnPmkAvailableRequest {
8719        type Borrowed<'a> = &'a Self;
8720        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8721            value
8722        }
8723    }
8724
8725    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnPmkAvailableRequest {
8726        type Owned = Self;
8727
8728        #[inline(always)]
8729        fn inline_align(_context: fidl::encoding::Context) -> usize {
8730            8
8731        }
8732
8733        #[inline(always)]
8734        fn inline_size(_context: fidl::encoding::Context) -> usize {
8735            16
8736        }
8737    }
8738
8739    unsafe impl<D: fidl::encoding::ResourceDialect>
8740        fidl::encoding::Encode<WlanFullmacImplIfcOnPmkAvailableRequest, D>
8741        for &WlanFullmacImplIfcOnPmkAvailableRequest
8742    {
8743        unsafe fn encode(
8744            self,
8745            encoder: &mut fidl::encoding::Encoder<'_, D>,
8746            offset: usize,
8747            mut depth: fidl::encoding::Depth,
8748        ) -> fidl::Result<()> {
8749            encoder.debug_check_bounds::<WlanFullmacImplIfcOnPmkAvailableRequest>(offset);
8750            // Vector header
8751            let max_ordinal: u64 = self.max_ordinal_present();
8752            encoder.write_num(max_ordinal, offset);
8753            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8754            // Calling encoder.out_of_line_offset(0) is not allowed.
8755            if max_ordinal == 0 {
8756                return Ok(());
8757            }
8758            depth.increment()?;
8759            let envelope_size = 8;
8760            let bytes_len = max_ordinal as usize * envelope_size;
8761            #[allow(unused_variables)]
8762            let offset = encoder.out_of_line_offset(bytes_len);
8763            let mut _prev_end_offset: usize = 0;
8764            if 1 > max_ordinal {
8765                return Ok(());
8766            }
8767
8768            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8769            // are envelope_size bytes.
8770            let cur_offset: usize = (1 - 1) * envelope_size;
8771
8772            // Zero reserved fields.
8773            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8774
8775            // Safety:
8776            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8777            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8778            //   envelope_size bytes, there is always sufficient room.
8779            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8780            self.pmk.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8781            encoder, offset + cur_offset, depth
8782        )?;
8783
8784            _prev_end_offset = cur_offset + envelope_size;
8785            if 2 > max_ordinal {
8786                return Ok(());
8787            }
8788
8789            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8790            // are envelope_size bytes.
8791            let cur_offset: usize = (2 - 1) * envelope_size;
8792
8793            // Zero reserved fields.
8794            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8795
8796            // Safety:
8797            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8798            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8799            //   envelope_size bytes, there is always sufficient room.
8800            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8801            self.pmkid.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8802            encoder, offset + cur_offset, depth
8803        )?;
8804
8805            _prev_end_offset = cur_offset + envelope_size;
8806
8807            Ok(())
8808        }
8809    }
8810
8811    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8812        for WlanFullmacImplIfcOnPmkAvailableRequest
8813    {
8814        #[inline(always)]
8815        fn new_empty() -> Self {
8816            Self::default()
8817        }
8818
8819        unsafe fn decode(
8820            &mut self,
8821            decoder: &mut fidl::encoding::Decoder<'_, D>,
8822            offset: usize,
8823            mut depth: fidl::encoding::Depth,
8824        ) -> fidl::Result<()> {
8825            decoder.debug_check_bounds::<Self>(offset);
8826            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8827                None => return Err(fidl::Error::NotNullable),
8828                Some(len) => len,
8829            };
8830            // Calling decoder.out_of_line_offset(0) is not allowed.
8831            if len == 0 {
8832                return Ok(());
8833            };
8834            depth.increment()?;
8835            let envelope_size = 8;
8836            let bytes_len = len * envelope_size;
8837            let offset = decoder.out_of_line_offset(bytes_len)?;
8838            // Decode the envelope for each type.
8839            let mut _next_ordinal_to_read = 0;
8840            let mut next_offset = offset;
8841            let end_offset = offset + bytes_len;
8842            _next_ordinal_to_read += 1;
8843            if next_offset >= end_offset {
8844                return Ok(());
8845            }
8846
8847            // Decode unknown envelopes for gaps in ordinals.
8848            while _next_ordinal_to_read < 1 {
8849                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8850                _next_ordinal_to_read += 1;
8851                next_offset += envelope_size;
8852            }
8853
8854            let next_out_of_line = decoder.next_out_of_line();
8855            let handles_before = decoder.remaining_handles();
8856            if let Some((inlined, num_bytes, num_handles)) =
8857                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8858            {
8859                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8860                if inlined != (member_inline_size <= 4) {
8861                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8862                }
8863                let inner_offset;
8864                let mut inner_depth = depth.clone();
8865                if inlined {
8866                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8867                    inner_offset = next_offset;
8868                } else {
8869                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8870                    inner_depth.increment()?;
8871                }
8872                let val_ref = self.pmk.get_or_insert_with(|| {
8873                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
8874                });
8875                fidl::decode!(
8876                    fidl::encoding::UnboundedVector<u8>,
8877                    D,
8878                    val_ref,
8879                    decoder,
8880                    inner_offset,
8881                    inner_depth
8882                )?;
8883                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8884                {
8885                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8886                }
8887                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8888                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8889                }
8890            }
8891
8892            next_offset += envelope_size;
8893            _next_ordinal_to_read += 1;
8894            if next_offset >= end_offset {
8895                return Ok(());
8896            }
8897
8898            // Decode unknown envelopes for gaps in ordinals.
8899            while _next_ordinal_to_read < 2 {
8900                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8901                _next_ordinal_to_read += 1;
8902                next_offset += envelope_size;
8903            }
8904
8905            let next_out_of_line = decoder.next_out_of_line();
8906            let handles_before = decoder.remaining_handles();
8907            if let Some((inlined, num_bytes, num_handles)) =
8908                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8909            {
8910                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8911                if inlined != (member_inline_size <= 4) {
8912                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8913                }
8914                let inner_offset;
8915                let mut inner_depth = depth.clone();
8916                if inlined {
8917                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8918                    inner_offset = next_offset;
8919                } else {
8920                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8921                    inner_depth.increment()?;
8922                }
8923                let val_ref = self.pmkid.get_or_insert_with(|| {
8924                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
8925                });
8926                fidl::decode!(
8927                    fidl::encoding::UnboundedVector<u8>,
8928                    D,
8929                    val_ref,
8930                    decoder,
8931                    inner_offset,
8932                    inner_depth
8933                )?;
8934                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8935                {
8936                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8937                }
8938                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8939                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8940                }
8941            }
8942
8943            next_offset += envelope_size;
8944
8945            // Decode the remaining unknown envelopes.
8946            while next_offset < end_offset {
8947                _next_ordinal_to_read += 1;
8948                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8949                next_offset += envelope_size;
8950            }
8951
8952            Ok(())
8953        }
8954    }
8955
8956    impl WlanFullmacImplIfcOnScanEndRequest {
8957        #[inline(always)]
8958        fn max_ordinal_present(&self) -> u64 {
8959            if let Some(_) = self.code {
8960                return 2;
8961            }
8962            if let Some(_) = self.txn_id {
8963                return 1;
8964            }
8965            0
8966        }
8967    }
8968
8969    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnScanEndRequest {
8970        type Borrowed<'a> = &'a Self;
8971        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8972            value
8973        }
8974    }
8975
8976    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnScanEndRequest {
8977        type Owned = Self;
8978
8979        #[inline(always)]
8980        fn inline_align(_context: fidl::encoding::Context) -> usize {
8981            8
8982        }
8983
8984        #[inline(always)]
8985        fn inline_size(_context: fidl::encoding::Context) -> usize {
8986            16
8987        }
8988    }
8989
8990    unsafe impl<D: fidl::encoding::ResourceDialect>
8991        fidl::encoding::Encode<WlanFullmacImplIfcOnScanEndRequest, D>
8992        for &WlanFullmacImplIfcOnScanEndRequest
8993    {
8994        unsafe fn encode(
8995            self,
8996            encoder: &mut fidl::encoding::Encoder<'_, D>,
8997            offset: usize,
8998            mut depth: fidl::encoding::Depth,
8999        ) -> fidl::Result<()> {
9000            encoder.debug_check_bounds::<WlanFullmacImplIfcOnScanEndRequest>(offset);
9001            // Vector header
9002            let max_ordinal: u64 = self.max_ordinal_present();
9003            encoder.write_num(max_ordinal, offset);
9004            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9005            // Calling encoder.out_of_line_offset(0) is not allowed.
9006            if max_ordinal == 0 {
9007                return Ok(());
9008            }
9009            depth.increment()?;
9010            let envelope_size = 8;
9011            let bytes_len = max_ordinal as usize * envelope_size;
9012            #[allow(unused_variables)]
9013            let offset = encoder.out_of_line_offset(bytes_len);
9014            let mut _prev_end_offset: usize = 0;
9015            if 1 > max_ordinal {
9016                return Ok(());
9017            }
9018
9019            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9020            // are envelope_size bytes.
9021            let cur_offset: usize = (1 - 1) * envelope_size;
9022
9023            // Zero reserved fields.
9024            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9025
9026            // Safety:
9027            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9028            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9029            //   envelope_size bytes, there is always sufficient room.
9030            fidl::encoding::encode_in_envelope_optional::<u64, D>(
9031                self.txn_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9032                encoder,
9033                offset + cur_offset,
9034                depth,
9035            )?;
9036
9037            _prev_end_offset = cur_offset + envelope_size;
9038            if 2 > max_ordinal {
9039                return Ok(());
9040            }
9041
9042            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9043            // are envelope_size bytes.
9044            let cur_offset: usize = (2 - 1) * envelope_size;
9045
9046            // Zero reserved fields.
9047            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9048
9049            // Safety:
9050            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9051            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9052            //   envelope_size bytes, there is always sufficient room.
9053            fidl::encoding::encode_in_envelope_optional::<WlanScanResult, D>(
9054                self.code.as_ref().map(<WlanScanResult as fidl::encoding::ValueTypeMarker>::borrow),
9055                encoder,
9056                offset + cur_offset,
9057                depth,
9058            )?;
9059
9060            _prev_end_offset = cur_offset + envelope_size;
9061
9062            Ok(())
9063        }
9064    }
9065
9066    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9067        for WlanFullmacImplIfcOnScanEndRequest
9068    {
9069        #[inline(always)]
9070        fn new_empty() -> Self {
9071            Self::default()
9072        }
9073
9074        unsafe fn decode(
9075            &mut self,
9076            decoder: &mut fidl::encoding::Decoder<'_, D>,
9077            offset: usize,
9078            mut depth: fidl::encoding::Depth,
9079        ) -> fidl::Result<()> {
9080            decoder.debug_check_bounds::<Self>(offset);
9081            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9082                None => return Err(fidl::Error::NotNullable),
9083                Some(len) => len,
9084            };
9085            // Calling decoder.out_of_line_offset(0) is not allowed.
9086            if len == 0 {
9087                return Ok(());
9088            };
9089            depth.increment()?;
9090            let envelope_size = 8;
9091            let bytes_len = len * envelope_size;
9092            let offset = decoder.out_of_line_offset(bytes_len)?;
9093            // Decode the envelope for each type.
9094            let mut _next_ordinal_to_read = 0;
9095            let mut next_offset = offset;
9096            let end_offset = offset + bytes_len;
9097            _next_ordinal_to_read += 1;
9098            if next_offset >= end_offset {
9099                return Ok(());
9100            }
9101
9102            // Decode unknown envelopes for gaps in ordinals.
9103            while _next_ordinal_to_read < 1 {
9104                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9105                _next_ordinal_to_read += 1;
9106                next_offset += envelope_size;
9107            }
9108
9109            let next_out_of_line = decoder.next_out_of_line();
9110            let handles_before = decoder.remaining_handles();
9111            if let Some((inlined, num_bytes, num_handles)) =
9112                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9113            {
9114                let member_inline_size =
9115                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9116                if inlined != (member_inline_size <= 4) {
9117                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9118                }
9119                let inner_offset;
9120                let mut inner_depth = depth.clone();
9121                if inlined {
9122                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9123                    inner_offset = next_offset;
9124                } else {
9125                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9126                    inner_depth.increment()?;
9127                }
9128                let val_ref = self.txn_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
9129                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9130                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9131                {
9132                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9133                }
9134                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9135                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9136                }
9137            }
9138
9139            next_offset += envelope_size;
9140            _next_ordinal_to_read += 1;
9141            if next_offset >= end_offset {
9142                return Ok(());
9143            }
9144
9145            // Decode unknown envelopes for gaps in ordinals.
9146            while _next_ordinal_to_read < 2 {
9147                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9148                _next_ordinal_to_read += 1;
9149                next_offset += envelope_size;
9150            }
9151
9152            let next_out_of_line = decoder.next_out_of_line();
9153            let handles_before = decoder.remaining_handles();
9154            if let Some((inlined, num_bytes, num_handles)) =
9155                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9156            {
9157                let member_inline_size =
9158                    <WlanScanResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9159                if inlined != (member_inline_size <= 4) {
9160                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9161                }
9162                let inner_offset;
9163                let mut inner_depth = depth.clone();
9164                if inlined {
9165                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9166                    inner_offset = next_offset;
9167                } else {
9168                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9169                    inner_depth.increment()?;
9170                }
9171                let val_ref = self.code.get_or_insert_with(|| fidl::new_empty!(WlanScanResult, D));
9172                fidl::decode!(WlanScanResult, D, val_ref, decoder, inner_offset, inner_depth)?;
9173                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9174                {
9175                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9176                }
9177                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9178                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9179                }
9180            }
9181
9182            next_offset += envelope_size;
9183
9184            // Decode the remaining unknown envelopes.
9185            while next_offset < end_offset {
9186                _next_ordinal_to_read += 1;
9187                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9188                next_offset += envelope_size;
9189            }
9190
9191            Ok(())
9192        }
9193    }
9194
9195    impl WlanFullmacImplIfcOnScanResultRequest {
9196        #[inline(always)]
9197        fn max_ordinal_present(&self) -> u64 {
9198            if let Some(_) = self.bss {
9199                return 3;
9200            }
9201            if let Some(_) = self.timestamp_nanos {
9202                return 2;
9203            }
9204            if let Some(_) = self.txn_id {
9205                return 1;
9206            }
9207            0
9208        }
9209    }
9210
9211    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnScanResultRequest {
9212        type Borrowed<'a> = &'a Self;
9213        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9214            value
9215        }
9216    }
9217
9218    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnScanResultRequest {
9219        type Owned = Self;
9220
9221        #[inline(always)]
9222        fn inline_align(_context: fidl::encoding::Context) -> usize {
9223            8
9224        }
9225
9226        #[inline(always)]
9227        fn inline_size(_context: fidl::encoding::Context) -> usize {
9228            16
9229        }
9230    }
9231
9232    unsafe impl<D: fidl::encoding::ResourceDialect>
9233        fidl::encoding::Encode<WlanFullmacImplIfcOnScanResultRequest, D>
9234        for &WlanFullmacImplIfcOnScanResultRequest
9235    {
9236        unsafe fn encode(
9237            self,
9238            encoder: &mut fidl::encoding::Encoder<'_, D>,
9239            offset: usize,
9240            mut depth: fidl::encoding::Depth,
9241        ) -> fidl::Result<()> {
9242            encoder.debug_check_bounds::<WlanFullmacImplIfcOnScanResultRequest>(offset);
9243            // Vector header
9244            let max_ordinal: u64 = self.max_ordinal_present();
9245            encoder.write_num(max_ordinal, offset);
9246            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9247            // Calling encoder.out_of_line_offset(0) is not allowed.
9248            if max_ordinal == 0 {
9249                return Ok(());
9250            }
9251            depth.increment()?;
9252            let envelope_size = 8;
9253            let bytes_len = max_ordinal as usize * envelope_size;
9254            #[allow(unused_variables)]
9255            let offset = encoder.out_of_line_offset(bytes_len);
9256            let mut _prev_end_offset: usize = 0;
9257            if 1 > max_ordinal {
9258                return Ok(());
9259            }
9260
9261            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9262            // are envelope_size bytes.
9263            let cur_offset: usize = (1 - 1) * envelope_size;
9264
9265            // Zero reserved fields.
9266            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9267
9268            // Safety:
9269            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9270            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9271            //   envelope_size bytes, there is always sufficient room.
9272            fidl::encoding::encode_in_envelope_optional::<u64, D>(
9273                self.txn_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9274                encoder,
9275                offset + cur_offset,
9276                depth,
9277            )?;
9278
9279            _prev_end_offset = cur_offset + envelope_size;
9280            if 2 > max_ordinal {
9281                return Ok(());
9282            }
9283
9284            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9285            // are envelope_size bytes.
9286            let cur_offset: usize = (2 - 1) * envelope_size;
9287
9288            // Zero reserved fields.
9289            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9290
9291            // Safety:
9292            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9293            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9294            //   envelope_size bytes, there is always sufficient room.
9295            fidl::encoding::encode_in_envelope_optional::<i64, D>(
9296                self.timestamp_nanos.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
9297                encoder,
9298                offset + cur_offset,
9299                depth,
9300            )?;
9301
9302            _prev_end_offset = cur_offset + envelope_size;
9303            if 3 > max_ordinal {
9304                return Ok(());
9305            }
9306
9307            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9308            // are envelope_size bytes.
9309            let cur_offset: usize = (3 - 1) * envelope_size;
9310
9311            // Zero reserved fields.
9312            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9313
9314            // Safety:
9315            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9316            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9317            //   envelope_size bytes, there is always sufficient room.
9318            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
9319            self.bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
9320            encoder, offset + cur_offset, depth
9321        )?;
9322
9323            _prev_end_offset = cur_offset + envelope_size;
9324
9325            Ok(())
9326        }
9327    }
9328
9329    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9330        for WlanFullmacImplIfcOnScanResultRequest
9331    {
9332        #[inline(always)]
9333        fn new_empty() -> Self {
9334            Self::default()
9335        }
9336
9337        unsafe fn decode(
9338            &mut self,
9339            decoder: &mut fidl::encoding::Decoder<'_, D>,
9340            offset: usize,
9341            mut depth: fidl::encoding::Depth,
9342        ) -> fidl::Result<()> {
9343            decoder.debug_check_bounds::<Self>(offset);
9344            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9345                None => return Err(fidl::Error::NotNullable),
9346                Some(len) => len,
9347            };
9348            // Calling decoder.out_of_line_offset(0) is not allowed.
9349            if len == 0 {
9350                return Ok(());
9351            };
9352            depth.increment()?;
9353            let envelope_size = 8;
9354            let bytes_len = len * envelope_size;
9355            let offset = decoder.out_of_line_offset(bytes_len)?;
9356            // Decode the envelope for each type.
9357            let mut _next_ordinal_to_read = 0;
9358            let mut next_offset = offset;
9359            let end_offset = offset + bytes_len;
9360            _next_ordinal_to_read += 1;
9361            if next_offset >= end_offset {
9362                return Ok(());
9363            }
9364
9365            // Decode unknown envelopes for gaps in ordinals.
9366            while _next_ordinal_to_read < 1 {
9367                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9368                _next_ordinal_to_read += 1;
9369                next_offset += envelope_size;
9370            }
9371
9372            let next_out_of_line = decoder.next_out_of_line();
9373            let handles_before = decoder.remaining_handles();
9374            if let Some((inlined, num_bytes, num_handles)) =
9375                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9376            {
9377                let member_inline_size =
9378                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9379                if inlined != (member_inline_size <= 4) {
9380                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9381                }
9382                let inner_offset;
9383                let mut inner_depth = depth.clone();
9384                if inlined {
9385                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9386                    inner_offset = next_offset;
9387                } else {
9388                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9389                    inner_depth.increment()?;
9390                }
9391                let val_ref = self.txn_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
9392                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9393                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9394                {
9395                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9396                }
9397                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9398                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9399                }
9400            }
9401
9402            next_offset += envelope_size;
9403            _next_ordinal_to_read += 1;
9404            if next_offset >= end_offset {
9405                return Ok(());
9406            }
9407
9408            // Decode unknown envelopes for gaps in ordinals.
9409            while _next_ordinal_to_read < 2 {
9410                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9411                _next_ordinal_to_read += 1;
9412                next_offset += envelope_size;
9413            }
9414
9415            let next_out_of_line = decoder.next_out_of_line();
9416            let handles_before = decoder.remaining_handles();
9417            if let Some((inlined, num_bytes, num_handles)) =
9418                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9419            {
9420                let member_inline_size =
9421                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9422                if inlined != (member_inline_size <= 4) {
9423                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9424                }
9425                let inner_offset;
9426                let mut inner_depth = depth.clone();
9427                if inlined {
9428                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9429                    inner_offset = next_offset;
9430                } else {
9431                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9432                    inner_depth.increment()?;
9433                }
9434                let val_ref = self.timestamp_nanos.get_or_insert_with(|| fidl::new_empty!(i64, D));
9435                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
9436                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9437                {
9438                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9439                }
9440                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9441                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9442                }
9443            }
9444
9445            next_offset += envelope_size;
9446            _next_ordinal_to_read += 1;
9447            if next_offset >= end_offset {
9448                return Ok(());
9449            }
9450
9451            // Decode unknown envelopes for gaps in ordinals.
9452            while _next_ordinal_to_read < 3 {
9453                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9454                _next_ordinal_to_read += 1;
9455                next_offset += envelope_size;
9456            }
9457
9458            let next_out_of_line = decoder.next_out_of_line();
9459            let handles_before = decoder.remaining_handles();
9460            if let Some((inlined, num_bytes, num_handles)) =
9461                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9462            {
9463                let member_inline_size = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9464                if inlined != (member_inline_size <= 4) {
9465                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9466                }
9467                let inner_offset;
9468                let mut inner_depth = depth.clone();
9469                if inlined {
9470                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9471                    inner_offset = next_offset;
9472                } else {
9473                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9474                    inner_depth.increment()?;
9475                }
9476                let val_ref = self.bss.get_or_insert_with(|| {
9477                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
9478                });
9479                fidl::decode!(
9480                    fidl_fuchsia_wlan_common__common::BssDescription,
9481                    D,
9482                    val_ref,
9483                    decoder,
9484                    inner_offset,
9485                    inner_depth
9486                )?;
9487                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9488                {
9489                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9490                }
9491                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9492                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9493                }
9494            }
9495
9496            next_offset += envelope_size;
9497
9498            // Decode the remaining unknown envelopes.
9499            while next_offset < end_offset {
9500                _next_ordinal_to_read += 1;
9501                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9502                next_offset += envelope_size;
9503            }
9504
9505            Ok(())
9506        }
9507    }
9508
9509    impl WlanFullmacImplIfcRoamConfRequest {
9510        #[inline(always)]
9511        fn max_ordinal_present(&self) -> u64 {
9512            if let Some(_) = self.association_ies {
9513                return 6;
9514            }
9515            if let Some(_) = self.association_id {
9516                return 5;
9517            }
9518            if let Some(_) = self.target_bss_authenticated {
9519                return 4;
9520            }
9521            if let Some(_) = self.original_association_maintained {
9522                return 3;
9523            }
9524            if let Some(_) = self.status_code {
9525                return 2;
9526            }
9527            if let Some(_) = self.selected_bssid {
9528                return 1;
9529            }
9530            0
9531        }
9532    }
9533
9534    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcRoamConfRequest {
9535        type Borrowed<'a> = &'a Self;
9536        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9537            value
9538        }
9539    }
9540
9541    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcRoamConfRequest {
9542        type Owned = Self;
9543
9544        #[inline(always)]
9545        fn inline_align(_context: fidl::encoding::Context) -> usize {
9546            8
9547        }
9548
9549        #[inline(always)]
9550        fn inline_size(_context: fidl::encoding::Context) -> usize {
9551            16
9552        }
9553    }
9554
9555    unsafe impl<D: fidl::encoding::ResourceDialect>
9556        fidl::encoding::Encode<WlanFullmacImplIfcRoamConfRequest, D>
9557        for &WlanFullmacImplIfcRoamConfRequest
9558    {
9559        unsafe fn encode(
9560            self,
9561            encoder: &mut fidl::encoding::Encoder<'_, D>,
9562            offset: usize,
9563            mut depth: fidl::encoding::Depth,
9564        ) -> fidl::Result<()> {
9565            encoder.debug_check_bounds::<WlanFullmacImplIfcRoamConfRequest>(offset);
9566            // Vector header
9567            let max_ordinal: u64 = self.max_ordinal_present();
9568            encoder.write_num(max_ordinal, offset);
9569            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9570            // Calling encoder.out_of_line_offset(0) is not allowed.
9571            if max_ordinal == 0 {
9572                return Ok(());
9573            }
9574            depth.increment()?;
9575            let envelope_size = 8;
9576            let bytes_len = max_ordinal as usize * envelope_size;
9577            #[allow(unused_variables)]
9578            let offset = encoder.out_of_line_offset(bytes_len);
9579            let mut _prev_end_offset: usize = 0;
9580            if 1 > max_ordinal {
9581                return Ok(());
9582            }
9583
9584            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9585            // are envelope_size bytes.
9586            let cur_offset: usize = (1 - 1) * envelope_size;
9587
9588            // Zero reserved fields.
9589            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9590
9591            // Safety:
9592            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9593            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9594            //   envelope_size bytes, there is always sufficient room.
9595            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
9596                self.selected_bssid
9597                    .as_ref()
9598                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
9599                encoder,
9600                offset + cur_offset,
9601                depth,
9602            )?;
9603
9604            _prev_end_offset = cur_offset + envelope_size;
9605            if 2 > max_ordinal {
9606                return Ok(());
9607            }
9608
9609            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9610            // are envelope_size bytes.
9611            let cur_offset: usize = (2 - 1) * envelope_size;
9612
9613            // Zero reserved fields.
9614            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9615
9616            // Safety:
9617            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9618            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9619            //   envelope_size bytes, there is always sufficient room.
9620            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
9621            self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
9622            encoder, offset + cur_offset, depth
9623        )?;
9624
9625            _prev_end_offset = cur_offset + envelope_size;
9626            if 3 > max_ordinal {
9627                return Ok(());
9628            }
9629
9630            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9631            // are envelope_size bytes.
9632            let cur_offset: usize = (3 - 1) * envelope_size;
9633
9634            // Zero reserved fields.
9635            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9636
9637            // Safety:
9638            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9639            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9640            //   envelope_size bytes, there is always sufficient room.
9641            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9642                self.original_association_maintained
9643                    .as_ref()
9644                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9645                encoder,
9646                offset + cur_offset,
9647                depth,
9648            )?;
9649
9650            _prev_end_offset = cur_offset + envelope_size;
9651            if 4 > max_ordinal {
9652                return Ok(());
9653            }
9654
9655            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9656            // are envelope_size bytes.
9657            let cur_offset: usize = (4 - 1) * envelope_size;
9658
9659            // Zero reserved fields.
9660            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9661
9662            // Safety:
9663            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9664            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9665            //   envelope_size bytes, there is always sufficient room.
9666            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9667                self.target_bss_authenticated
9668                    .as_ref()
9669                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9670                encoder,
9671                offset + cur_offset,
9672                depth,
9673            )?;
9674
9675            _prev_end_offset = cur_offset + envelope_size;
9676            if 5 > max_ordinal {
9677                return Ok(());
9678            }
9679
9680            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9681            // are envelope_size bytes.
9682            let cur_offset: usize = (5 - 1) * envelope_size;
9683
9684            // Zero reserved fields.
9685            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9686
9687            // Safety:
9688            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9689            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9690            //   envelope_size bytes, there is always sufficient room.
9691            fidl::encoding::encode_in_envelope_optional::<u16, D>(
9692                self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
9693                encoder,
9694                offset + cur_offset,
9695                depth,
9696            )?;
9697
9698            _prev_end_offset = cur_offset + envelope_size;
9699            if 6 > max_ordinal {
9700                return Ok(());
9701            }
9702
9703            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9704            // are envelope_size bytes.
9705            let cur_offset: usize = (6 - 1) * envelope_size;
9706
9707            // Zero reserved fields.
9708            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9709
9710            // Safety:
9711            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9712            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9713            //   envelope_size bytes, there is always sufficient room.
9714            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
9715            self.association_ies.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
9716            encoder, offset + cur_offset, depth
9717        )?;
9718
9719            _prev_end_offset = cur_offset + envelope_size;
9720
9721            Ok(())
9722        }
9723    }
9724
9725    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9726        for WlanFullmacImplIfcRoamConfRequest
9727    {
9728        #[inline(always)]
9729        fn new_empty() -> Self {
9730            Self::default()
9731        }
9732
9733        unsafe fn decode(
9734            &mut self,
9735            decoder: &mut fidl::encoding::Decoder<'_, D>,
9736            offset: usize,
9737            mut depth: fidl::encoding::Depth,
9738        ) -> fidl::Result<()> {
9739            decoder.debug_check_bounds::<Self>(offset);
9740            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9741                None => return Err(fidl::Error::NotNullable),
9742                Some(len) => len,
9743            };
9744            // Calling decoder.out_of_line_offset(0) is not allowed.
9745            if len == 0 {
9746                return Ok(());
9747            };
9748            depth.increment()?;
9749            let envelope_size = 8;
9750            let bytes_len = len * envelope_size;
9751            let offset = decoder.out_of_line_offset(bytes_len)?;
9752            // Decode the envelope for each type.
9753            let mut _next_ordinal_to_read = 0;
9754            let mut next_offset = offset;
9755            let end_offset = offset + bytes_len;
9756            _next_ordinal_to_read += 1;
9757            if next_offset >= end_offset {
9758                return Ok(());
9759            }
9760
9761            // Decode unknown envelopes for gaps in ordinals.
9762            while _next_ordinal_to_read < 1 {
9763                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9764                _next_ordinal_to_read += 1;
9765                next_offset += envelope_size;
9766            }
9767
9768            let next_out_of_line = decoder.next_out_of_line();
9769            let handles_before = decoder.remaining_handles();
9770            if let Some((inlined, num_bytes, num_handles)) =
9771                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9772            {
9773                let member_inline_size =
9774                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
9775                        decoder.context,
9776                    );
9777                if inlined != (member_inline_size <= 4) {
9778                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9779                }
9780                let inner_offset;
9781                let mut inner_depth = depth.clone();
9782                if inlined {
9783                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9784                    inner_offset = next_offset;
9785                } else {
9786                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9787                    inner_depth.increment()?;
9788                }
9789                let val_ref = self
9790                    .selected_bssid
9791                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
9792                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
9793                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9794                {
9795                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9796                }
9797                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9798                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9799                }
9800            }
9801
9802            next_offset += envelope_size;
9803            _next_ordinal_to_read += 1;
9804            if next_offset >= end_offset {
9805                return Ok(());
9806            }
9807
9808            // Decode unknown envelopes for gaps in ordinals.
9809            while _next_ordinal_to_read < 2 {
9810                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9811                _next_ordinal_to_read += 1;
9812                next_offset += envelope_size;
9813            }
9814
9815            let next_out_of_line = decoder.next_out_of_line();
9816            let handles_before = decoder.remaining_handles();
9817            if let Some((inlined, num_bytes, num_handles)) =
9818                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9819            {
9820                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9821                if inlined != (member_inline_size <= 4) {
9822                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9823                }
9824                let inner_offset;
9825                let mut inner_depth = depth.clone();
9826                if inlined {
9827                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9828                    inner_offset = next_offset;
9829                } else {
9830                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9831                    inner_depth.increment()?;
9832                }
9833                let val_ref = self.status_code.get_or_insert_with(|| {
9834                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
9835                });
9836                fidl::decode!(
9837                    fidl_fuchsia_wlan_ieee80211__common::StatusCode,
9838                    D,
9839                    val_ref,
9840                    decoder,
9841                    inner_offset,
9842                    inner_depth
9843                )?;
9844                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9845                {
9846                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9847                }
9848                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9849                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9850                }
9851            }
9852
9853            next_offset += envelope_size;
9854            _next_ordinal_to_read += 1;
9855            if next_offset >= end_offset {
9856                return Ok(());
9857            }
9858
9859            // Decode unknown envelopes for gaps in ordinals.
9860            while _next_ordinal_to_read < 3 {
9861                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9862                _next_ordinal_to_read += 1;
9863                next_offset += envelope_size;
9864            }
9865
9866            let next_out_of_line = decoder.next_out_of_line();
9867            let handles_before = decoder.remaining_handles();
9868            if let Some((inlined, num_bytes, num_handles)) =
9869                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9870            {
9871                let member_inline_size =
9872                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9873                if inlined != (member_inline_size <= 4) {
9874                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9875                }
9876                let inner_offset;
9877                let mut inner_depth = depth.clone();
9878                if inlined {
9879                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9880                    inner_offset = next_offset;
9881                } else {
9882                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9883                    inner_depth.increment()?;
9884                }
9885                let val_ref = self
9886                    .original_association_maintained
9887                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
9888                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9889                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9890                {
9891                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9892                }
9893                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9894                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9895                }
9896            }
9897
9898            next_offset += envelope_size;
9899            _next_ordinal_to_read += 1;
9900            if next_offset >= end_offset {
9901                return Ok(());
9902            }
9903
9904            // Decode unknown envelopes for gaps in ordinals.
9905            while _next_ordinal_to_read < 4 {
9906                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9907                _next_ordinal_to_read += 1;
9908                next_offset += envelope_size;
9909            }
9910
9911            let next_out_of_line = decoder.next_out_of_line();
9912            let handles_before = decoder.remaining_handles();
9913            if let Some((inlined, num_bytes, num_handles)) =
9914                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9915            {
9916                let member_inline_size =
9917                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9918                if inlined != (member_inline_size <= 4) {
9919                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9920                }
9921                let inner_offset;
9922                let mut inner_depth = depth.clone();
9923                if inlined {
9924                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9925                    inner_offset = next_offset;
9926                } else {
9927                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9928                    inner_depth.increment()?;
9929                }
9930                let val_ref =
9931                    self.target_bss_authenticated.get_or_insert_with(|| fidl::new_empty!(bool, D));
9932                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9933                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9934                {
9935                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9936                }
9937                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9938                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9939                }
9940            }
9941
9942            next_offset += envelope_size;
9943            _next_ordinal_to_read += 1;
9944            if next_offset >= end_offset {
9945                return Ok(());
9946            }
9947
9948            // Decode unknown envelopes for gaps in ordinals.
9949            while _next_ordinal_to_read < 5 {
9950                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9951                _next_ordinal_to_read += 1;
9952                next_offset += envelope_size;
9953            }
9954
9955            let next_out_of_line = decoder.next_out_of_line();
9956            let handles_before = decoder.remaining_handles();
9957            if let Some((inlined, num_bytes, num_handles)) =
9958                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9959            {
9960                let member_inline_size =
9961                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9962                if inlined != (member_inline_size <= 4) {
9963                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9964                }
9965                let inner_offset;
9966                let mut inner_depth = depth.clone();
9967                if inlined {
9968                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9969                    inner_offset = next_offset;
9970                } else {
9971                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9972                    inner_depth.increment()?;
9973                }
9974                let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
9975                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
9976                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9977                {
9978                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9979                }
9980                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9981                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9982                }
9983            }
9984
9985            next_offset += envelope_size;
9986            _next_ordinal_to_read += 1;
9987            if next_offset >= end_offset {
9988                return Ok(());
9989            }
9990
9991            // Decode unknown envelopes for gaps in ordinals.
9992            while _next_ordinal_to_read < 6 {
9993                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9994                _next_ordinal_to_read += 1;
9995                next_offset += envelope_size;
9996            }
9997
9998            let next_out_of_line = decoder.next_out_of_line();
9999            let handles_before = decoder.remaining_handles();
10000            if let Some((inlined, num_bytes, num_handles)) =
10001                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10002            {
10003                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10004                if inlined != (member_inline_size <= 4) {
10005                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10006                }
10007                let inner_offset;
10008                let mut inner_depth = depth.clone();
10009                if inlined {
10010                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10011                    inner_offset = next_offset;
10012                } else {
10013                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10014                    inner_depth.increment()?;
10015                }
10016                let val_ref = self.association_ies.get_or_insert_with(|| {
10017                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
10018                });
10019                fidl::decode!(
10020                    fidl::encoding::UnboundedVector<u8>,
10021                    D,
10022                    val_ref,
10023                    decoder,
10024                    inner_offset,
10025                    inner_depth
10026                )?;
10027                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10028                {
10029                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10030                }
10031                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10032                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10033                }
10034            }
10035
10036            next_offset += envelope_size;
10037
10038            // Decode the remaining unknown envelopes.
10039            while next_offset < end_offset {
10040                _next_ordinal_to_read += 1;
10041                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10042                next_offset += envelope_size;
10043            }
10044
10045            Ok(())
10046        }
10047    }
10048
10049    impl WlanFullmacImplIfcRoamResultIndRequest {
10050        #[inline(always)]
10051        fn max_ordinal_present(&self) -> u64 {
10052            if let Some(_) = self.association_ies {
10053                return 6;
10054            }
10055            if let Some(_) = self.association_id {
10056                return 5;
10057            }
10058            if let Some(_) = self.target_bss_authenticated {
10059                return 4;
10060            }
10061            if let Some(_) = self.original_association_maintained {
10062                return 3;
10063            }
10064            if let Some(_) = self.status_code {
10065                return 2;
10066            }
10067            if let Some(_) = self.selected_bssid {
10068                return 1;
10069            }
10070            0
10071        }
10072    }
10073
10074    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcRoamResultIndRequest {
10075        type Borrowed<'a> = &'a Self;
10076        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10077            value
10078        }
10079    }
10080
10081    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcRoamResultIndRequest {
10082        type Owned = Self;
10083
10084        #[inline(always)]
10085        fn inline_align(_context: fidl::encoding::Context) -> usize {
10086            8
10087        }
10088
10089        #[inline(always)]
10090        fn inline_size(_context: fidl::encoding::Context) -> usize {
10091            16
10092        }
10093    }
10094
10095    unsafe impl<D: fidl::encoding::ResourceDialect>
10096        fidl::encoding::Encode<WlanFullmacImplIfcRoamResultIndRequest, D>
10097        for &WlanFullmacImplIfcRoamResultIndRequest
10098    {
10099        unsafe fn encode(
10100            self,
10101            encoder: &mut fidl::encoding::Encoder<'_, D>,
10102            offset: usize,
10103            mut depth: fidl::encoding::Depth,
10104        ) -> fidl::Result<()> {
10105            encoder.debug_check_bounds::<WlanFullmacImplIfcRoamResultIndRequest>(offset);
10106            // Vector header
10107            let max_ordinal: u64 = self.max_ordinal_present();
10108            encoder.write_num(max_ordinal, offset);
10109            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10110            // Calling encoder.out_of_line_offset(0) is not allowed.
10111            if max_ordinal == 0 {
10112                return Ok(());
10113            }
10114            depth.increment()?;
10115            let envelope_size = 8;
10116            let bytes_len = max_ordinal as usize * envelope_size;
10117            #[allow(unused_variables)]
10118            let offset = encoder.out_of_line_offset(bytes_len);
10119            let mut _prev_end_offset: usize = 0;
10120            if 1 > max_ordinal {
10121                return Ok(());
10122            }
10123
10124            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10125            // are envelope_size bytes.
10126            let cur_offset: usize = (1 - 1) * envelope_size;
10127
10128            // Zero reserved fields.
10129            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10130
10131            // Safety:
10132            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10133            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10134            //   envelope_size bytes, there is always sufficient room.
10135            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
10136                self.selected_bssid
10137                    .as_ref()
10138                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
10139                encoder,
10140                offset + cur_offset,
10141                depth,
10142            )?;
10143
10144            _prev_end_offset = cur_offset + envelope_size;
10145            if 2 > max_ordinal {
10146                return Ok(());
10147            }
10148
10149            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10150            // are envelope_size bytes.
10151            let cur_offset: usize = (2 - 1) * envelope_size;
10152
10153            // Zero reserved fields.
10154            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10155
10156            // Safety:
10157            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10158            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10159            //   envelope_size bytes, there is always sufficient room.
10160            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
10161            self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
10162            encoder, offset + cur_offset, depth
10163        )?;
10164
10165            _prev_end_offset = cur_offset + envelope_size;
10166            if 3 > max_ordinal {
10167                return Ok(());
10168            }
10169
10170            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10171            // are envelope_size bytes.
10172            let cur_offset: usize = (3 - 1) * envelope_size;
10173
10174            // Zero reserved fields.
10175            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10176
10177            // Safety:
10178            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10179            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10180            //   envelope_size bytes, there is always sufficient room.
10181            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10182                self.original_association_maintained
10183                    .as_ref()
10184                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10185                encoder,
10186                offset + cur_offset,
10187                depth,
10188            )?;
10189
10190            _prev_end_offset = cur_offset + envelope_size;
10191            if 4 > max_ordinal {
10192                return Ok(());
10193            }
10194
10195            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10196            // are envelope_size bytes.
10197            let cur_offset: usize = (4 - 1) * envelope_size;
10198
10199            // Zero reserved fields.
10200            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10201
10202            // Safety:
10203            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10204            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10205            //   envelope_size bytes, there is always sufficient room.
10206            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10207                self.target_bss_authenticated
10208                    .as_ref()
10209                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10210                encoder,
10211                offset + cur_offset,
10212                depth,
10213            )?;
10214
10215            _prev_end_offset = cur_offset + envelope_size;
10216            if 5 > max_ordinal {
10217                return Ok(());
10218            }
10219
10220            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10221            // are envelope_size bytes.
10222            let cur_offset: usize = (5 - 1) * envelope_size;
10223
10224            // Zero reserved fields.
10225            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10226
10227            // Safety:
10228            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10229            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10230            //   envelope_size bytes, there is always sufficient room.
10231            fidl::encoding::encode_in_envelope_optional::<u16, D>(
10232                self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
10233                encoder,
10234                offset + cur_offset,
10235                depth,
10236            )?;
10237
10238            _prev_end_offset = cur_offset + envelope_size;
10239            if 6 > max_ordinal {
10240                return Ok(());
10241            }
10242
10243            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10244            // are envelope_size bytes.
10245            let cur_offset: usize = (6 - 1) * envelope_size;
10246
10247            // Zero reserved fields.
10248            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10249
10250            // Safety:
10251            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10252            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10253            //   envelope_size bytes, there is always sufficient room.
10254            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
10255            self.association_ies.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
10256            encoder, offset + cur_offset, depth
10257        )?;
10258
10259            _prev_end_offset = cur_offset + envelope_size;
10260
10261            Ok(())
10262        }
10263    }
10264
10265    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10266        for WlanFullmacImplIfcRoamResultIndRequest
10267    {
10268        #[inline(always)]
10269        fn new_empty() -> Self {
10270            Self::default()
10271        }
10272
10273        unsafe fn decode(
10274            &mut self,
10275            decoder: &mut fidl::encoding::Decoder<'_, D>,
10276            offset: usize,
10277            mut depth: fidl::encoding::Depth,
10278        ) -> fidl::Result<()> {
10279            decoder.debug_check_bounds::<Self>(offset);
10280            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10281                None => return Err(fidl::Error::NotNullable),
10282                Some(len) => len,
10283            };
10284            // Calling decoder.out_of_line_offset(0) is not allowed.
10285            if len == 0 {
10286                return Ok(());
10287            };
10288            depth.increment()?;
10289            let envelope_size = 8;
10290            let bytes_len = len * envelope_size;
10291            let offset = decoder.out_of_line_offset(bytes_len)?;
10292            // Decode the envelope for each type.
10293            let mut _next_ordinal_to_read = 0;
10294            let mut next_offset = offset;
10295            let end_offset = offset + bytes_len;
10296            _next_ordinal_to_read += 1;
10297            if next_offset >= end_offset {
10298                return Ok(());
10299            }
10300
10301            // Decode unknown envelopes for gaps in ordinals.
10302            while _next_ordinal_to_read < 1 {
10303                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10304                _next_ordinal_to_read += 1;
10305                next_offset += envelope_size;
10306            }
10307
10308            let next_out_of_line = decoder.next_out_of_line();
10309            let handles_before = decoder.remaining_handles();
10310            if let Some((inlined, num_bytes, num_handles)) =
10311                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10312            {
10313                let member_inline_size =
10314                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
10315                        decoder.context,
10316                    );
10317                if inlined != (member_inline_size <= 4) {
10318                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10319                }
10320                let inner_offset;
10321                let mut inner_depth = depth.clone();
10322                if inlined {
10323                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10324                    inner_offset = next_offset;
10325                } else {
10326                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10327                    inner_depth.increment()?;
10328                }
10329                let val_ref = self
10330                    .selected_bssid
10331                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
10332                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
10333                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10334                {
10335                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10336                }
10337                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10338                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10339                }
10340            }
10341
10342            next_offset += envelope_size;
10343            _next_ordinal_to_read += 1;
10344            if next_offset >= end_offset {
10345                return Ok(());
10346            }
10347
10348            // Decode unknown envelopes for gaps in ordinals.
10349            while _next_ordinal_to_read < 2 {
10350                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10351                _next_ordinal_to_read += 1;
10352                next_offset += envelope_size;
10353            }
10354
10355            let next_out_of_line = decoder.next_out_of_line();
10356            let handles_before = decoder.remaining_handles();
10357            if let Some((inlined, num_bytes, num_handles)) =
10358                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10359            {
10360                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10361                if inlined != (member_inline_size <= 4) {
10362                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10363                }
10364                let inner_offset;
10365                let mut inner_depth = depth.clone();
10366                if inlined {
10367                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10368                    inner_offset = next_offset;
10369                } else {
10370                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10371                    inner_depth.increment()?;
10372                }
10373                let val_ref = self.status_code.get_or_insert_with(|| {
10374                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
10375                });
10376                fidl::decode!(
10377                    fidl_fuchsia_wlan_ieee80211__common::StatusCode,
10378                    D,
10379                    val_ref,
10380                    decoder,
10381                    inner_offset,
10382                    inner_depth
10383                )?;
10384                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10385                {
10386                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10387                }
10388                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10389                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10390                }
10391            }
10392
10393            next_offset += envelope_size;
10394            _next_ordinal_to_read += 1;
10395            if next_offset >= end_offset {
10396                return Ok(());
10397            }
10398
10399            // Decode unknown envelopes for gaps in ordinals.
10400            while _next_ordinal_to_read < 3 {
10401                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10402                _next_ordinal_to_read += 1;
10403                next_offset += envelope_size;
10404            }
10405
10406            let next_out_of_line = decoder.next_out_of_line();
10407            let handles_before = decoder.remaining_handles();
10408            if let Some((inlined, num_bytes, num_handles)) =
10409                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10410            {
10411                let member_inline_size =
10412                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10413                if inlined != (member_inline_size <= 4) {
10414                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10415                }
10416                let inner_offset;
10417                let mut inner_depth = depth.clone();
10418                if inlined {
10419                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10420                    inner_offset = next_offset;
10421                } else {
10422                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10423                    inner_depth.increment()?;
10424                }
10425                let val_ref = self
10426                    .original_association_maintained
10427                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
10428                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10429                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10430                {
10431                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10432                }
10433                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10434                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10435                }
10436            }
10437
10438            next_offset += envelope_size;
10439            _next_ordinal_to_read += 1;
10440            if next_offset >= end_offset {
10441                return Ok(());
10442            }
10443
10444            // Decode unknown envelopes for gaps in ordinals.
10445            while _next_ordinal_to_read < 4 {
10446                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10447                _next_ordinal_to_read += 1;
10448                next_offset += envelope_size;
10449            }
10450
10451            let next_out_of_line = decoder.next_out_of_line();
10452            let handles_before = decoder.remaining_handles();
10453            if let Some((inlined, num_bytes, num_handles)) =
10454                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10455            {
10456                let member_inline_size =
10457                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10458                if inlined != (member_inline_size <= 4) {
10459                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10460                }
10461                let inner_offset;
10462                let mut inner_depth = depth.clone();
10463                if inlined {
10464                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10465                    inner_offset = next_offset;
10466                } else {
10467                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10468                    inner_depth.increment()?;
10469                }
10470                let val_ref =
10471                    self.target_bss_authenticated.get_or_insert_with(|| fidl::new_empty!(bool, D));
10472                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10473                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10474                {
10475                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10476                }
10477                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10478                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10479                }
10480            }
10481
10482            next_offset += envelope_size;
10483            _next_ordinal_to_read += 1;
10484            if next_offset >= end_offset {
10485                return Ok(());
10486            }
10487
10488            // Decode unknown envelopes for gaps in ordinals.
10489            while _next_ordinal_to_read < 5 {
10490                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10491                _next_ordinal_to_read += 1;
10492                next_offset += envelope_size;
10493            }
10494
10495            let next_out_of_line = decoder.next_out_of_line();
10496            let handles_before = decoder.remaining_handles();
10497            if let Some((inlined, num_bytes, num_handles)) =
10498                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10499            {
10500                let member_inline_size =
10501                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10502                if inlined != (member_inline_size <= 4) {
10503                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10504                }
10505                let inner_offset;
10506                let mut inner_depth = depth.clone();
10507                if inlined {
10508                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10509                    inner_offset = next_offset;
10510                } else {
10511                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10512                    inner_depth.increment()?;
10513                }
10514                let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
10515                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
10516                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10517                {
10518                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10519                }
10520                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10521                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10522                }
10523            }
10524
10525            next_offset += envelope_size;
10526            _next_ordinal_to_read += 1;
10527            if next_offset >= end_offset {
10528                return Ok(());
10529            }
10530
10531            // Decode unknown envelopes for gaps in ordinals.
10532            while _next_ordinal_to_read < 6 {
10533                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10534                _next_ordinal_to_read += 1;
10535                next_offset += envelope_size;
10536            }
10537
10538            let next_out_of_line = decoder.next_out_of_line();
10539            let handles_before = decoder.remaining_handles();
10540            if let Some((inlined, num_bytes, num_handles)) =
10541                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10542            {
10543                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10544                if inlined != (member_inline_size <= 4) {
10545                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10546                }
10547                let inner_offset;
10548                let mut inner_depth = depth.clone();
10549                if inlined {
10550                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10551                    inner_offset = next_offset;
10552                } else {
10553                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10554                    inner_depth.increment()?;
10555                }
10556                let val_ref = self.association_ies.get_or_insert_with(|| {
10557                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
10558                });
10559                fidl::decode!(
10560                    fidl::encoding::UnboundedVector<u8>,
10561                    D,
10562                    val_ref,
10563                    decoder,
10564                    inner_offset,
10565                    inner_depth
10566                )?;
10567                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10568                {
10569                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10570                }
10571                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10572                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10573                }
10574            }
10575
10576            next_offset += envelope_size;
10577
10578            // Decode the remaining unknown envelopes.
10579            while next_offset < end_offset {
10580                _next_ordinal_to_read += 1;
10581                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10582                next_offset += envelope_size;
10583            }
10584
10585            Ok(())
10586        }
10587    }
10588
10589    impl WlanFullmacImplIfcRoamStartIndRequest {
10590        #[inline(always)]
10591        fn max_ordinal_present(&self) -> u64 {
10592            if let Some(_) = self.original_association_maintained {
10593                return 3;
10594            }
10595            if let Some(_) = self.selected_bss {
10596                return 2;
10597            }
10598            if let Some(_) = self.selected_bssid {
10599                return 1;
10600            }
10601            0
10602        }
10603    }
10604
10605    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcRoamStartIndRequest {
10606        type Borrowed<'a> = &'a Self;
10607        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10608            value
10609        }
10610    }
10611
10612    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcRoamStartIndRequest {
10613        type Owned = Self;
10614
10615        #[inline(always)]
10616        fn inline_align(_context: fidl::encoding::Context) -> usize {
10617            8
10618        }
10619
10620        #[inline(always)]
10621        fn inline_size(_context: fidl::encoding::Context) -> usize {
10622            16
10623        }
10624    }
10625
10626    unsafe impl<D: fidl::encoding::ResourceDialect>
10627        fidl::encoding::Encode<WlanFullmacImplIfcRoamStartIndRequest, D>
10628        for &WlanFullmacImplIfcRoamStartIndRequest
10629    {
10630        unsafe fn encode(
10631            self,
10632            encoder: &mut fidl::encoding::Encoder<'_, D>,
10633            offset: usize,
10634            mut depth: fidl::encoding::Depth,
10635        ) -> fidl::Result<()> {
10636            encoder.debug_check_bounds::<WlanFullmacImplIfcRoamStartIndRequest>(offset);
10637            // Vector header
10638            let max_ordinal: u64 = self.max_ordinal_present();
10639            encoder.write_num(max_ordinal, offset);
10640            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10641            // Calling encoder.out_of_line_offset(0) is not allowed.
10642            if max_ordinal == 0 {
10643                return Ok(());
10644            }
10645            depth.increment()?;
10646            let envelope_size = 8;
10647            let bytes_len = max_ordinal as usize * envelope_size;
10648            #[allow(unused_variables)]
10649            let offset = encoder.out_of_line_offset(bytes_len);
10650            let mut _prev_end_offset: usize = 0;
10651            if 1 > max_ordinal {
10652                return Ok(());
10653            }
10654
10655            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10656            // are envelope_size bytes.
10657            let cur_offset: usize = (1 - 1) * envelope_size;
10658
10659            // Zero reserved fields.
10660            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10661
10662            // Safety:
10663            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10664            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10665            //   envelope_size bytes, there is always sufficient room.
10666            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
10667                self.selected_bssid
10668                    .as_ref()
10669                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
10670                encoder,
10671                offset + cur_offset,
10672                depth,
10673            )?;
10674
10675            _prev_end_offset = cur_offset + envelope_size;
10676            if 2 > max_ordinal {
10677                return Ok(());
10678            }
10679
10680            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10681            // are envelope_size bytes.
10682            let cur_offset: usize = (2 - 1) * envelope_size;
10683
10684            // Zero reserved fields.
10685            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10686
10687            // Safety:
10688            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10689            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10690            //   envelope_size bytes, there is always sufficient room.
10691            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
10692            self.selected_bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
10693            encoder, offset + cur_offset, depth
10694        )?;
10695
10696            _prev_end_offset = cur_offset + envelope_size;
10697            if 3 > max_ordinal {
10698                return Ok(());
10699            }
10700
10701            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10702            // are envelope_size bytes.
10703            let cur_offset: usize = (3 - 1) * envelope_size;
10704
10705            // Zero reserved fields.
10706            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10707
10708            // Safety:
10709            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10710            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10711            //   envelope_size bytes, there is always sufficient room.
10712            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10713                self.original_association_maintained
10714                    .as_ref()
10715                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10716                encoder,
10717                offset + cur_offset,
10718                depth,
10719            )?;
10720
10721            _prev_end_offset = cur_offset + envelope_size;
10722
10723            Ok(())
10724        }
10725    }
10726
10727    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10728        for WlanFullmacImplIfcRoamStartIndRequest
10729    {
10730        #[inline(always)]
10731        fn new_empty() -> Self {
10732            Self::default()
10733        }
10734
10735        unsafe fn decode(
10736            &mut self,
10737            decoder: &mut fidl::encoding::Decoder<'_, D>,
10738            offset: usize,
10739            mut depth: fidl::encoding::Depth,
10740        ) -> fidl::Result<()> {
10741            decoder.debug_check_bounds::<Self>(offset);
10742            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10743                None => return Err(fidl::Error::NotNullable),
10744                Some(len) => len,
10745            };
10746            // Calling decoder.out_of_line_offset(0) is not allowed.
10747            if len == 0 {
10748                return Ok(());
10749            };
10750            depth.increment()?;
10751            let envelope_size = 8;
10752            let bytes_len = len * envelope_size;
10753            let offset = decoder.out_of_line_offset(bytes_len)?;
10754            // Decode the envelope for each type.
10755            let mut _next_ordinal_to_read = 0;
10756            let mut next_offset = offset;
10757            let end_offset = offset + bytes_len;
10758            _next_ordinal_to_read += 1;
10759            if next_offset >= end_offset {
10760                return Ok(());
10761            }
10762
10763            // Decode unknown envelopes for gaps in ordinals.
10764            while _next_ordinal_to_read < 1 {
10765                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10766                _next_ordinal_to_read += 1;
10767                next_offset += envelope_size;
10768            }
10769
10770            let next_out_of_line = decoder.next_out_of_line();
10771            let handles_before = decoder.remaining_handles();
10772            if let Some((inlined, num_bytes, num_handles)) =
10773                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10774            {
10775                let member_inline_size =
10776                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
10777                        decoder.context,
10778                    );
10779                if inlined != (member_inline_size <= 4) {
10780                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10781                }
10782                let inner_offset;
10783                let mut inner_depth = depth.clone();
10784                if inlined {
10785                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10786                    inner_offset = next_offset;
10787                } else {
10788                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10789                    inner_depth.increment()?;
10790                }
10791                let val_ref = self
10792                    .selected_bssid
10793                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
10794                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
10795                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10796                {
10797                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10798                }
10799                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10800                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10801                }
10802            }
10803
10804            next_offset += envelope_size;
10805            _next_ordinal_to_read += 1;
10806            if next_offset >= end_offset {
10807                return Ok(());
10808            }
10809
10810            // Decode unknown envelopes for gaps in ordinals.
10811            while _next_ordinal_to_read < 2 {
10812                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10813                _next_ordinal_to_read += 1;
10814                next_offset += envelope_size;
10815            }
10816
10817            let next_out_of_line = decoder.next_out_of_line();
10818            let handles_before = decoder.remaining_handles();
10819            if let Some((inlined, num_bytes, num_handles)) =
10820                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10821            {
10822                let member_inline_size = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10823                if inlined != (member_inline_size <= 4) {
10824                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10825                }
10826                let inner_offset;
10827                let mut inner_depth = depth.clone();
10828                if inlined {
10829                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10830                    inner_offset = next_offset;
10831                } else {
10832                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10833                    inner_depth.increment()?;
10834                }
10835                let val_ref = self.selected_bss.get_or_insert_with(|| {
10836                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
10837                });
10838                fidl::decode!(
10839                    fidl_fuchsia_wlan_common__common::BssDescription,
10840                    D,
10841                    val_ref,
10842                    decoder,
10843                    inner_offset,
10844                    inner_depth
10845                )?;
10846                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10847                {
10848                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10849                }
10850                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10851                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10852                }
10853            }
10854
10855            next_offset += envelope_size;
10856            _next_ordinal_to_read += 1;
10857            if next_offset >= end_offset {
10858                return Ok(());
10859            }
10860
10861            // Decode unknown envelopes for gaps in ordinals.
10862            while _next_ordinal_to_read < 3 {
10863                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10864                _next_ordinal_to_read += 1;
10865                next_offset += envelope_size;
10866            }
10867
10868            let next_out_of_line = decoder.next_out_of_line();
10869            let handles_before = decoder.remaining_handles();
10870            if let Some((inlined, num_bytes, num_handles)) =
10871                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10872            {
10873                let member_inline_size =
10874                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10875                if inlined != (member_inline_size <= 4) {
10876                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10877                }
10878                let inner_offset;
10879                let mut inner_depth = depth.clone();
10880                if inlined {
10881                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10882                    inner_offset = next_offset;
10883                } else {
10884                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10885                    inner_depth.increment()?;
10886                }
10887                let val_ref = self
10888                    .original_association_maintained
10889                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
10890                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10891                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10892                {
10893                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10894                }
10895                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10896                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10897                }
10898            }
10899
10900            next_offset += envelope_size;
10901
10902            // Decode the remaining unknown envelopes.
10903            while next_offset < end_offset {
10904                _next_ordinal_to_read += 1;
10905                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10906                next_offset += envelope_size;
10907            }
10908
10909            Ok(())
10910        }
10911    }
10912
10913    impl WlanFullmacImplIfcSaeHandshakeIndRequest {
10914        #[inline(always)]
10915        fn max_ordinal_present(&self) -> u64 {
10916            if let Some(_) = self.peer_sta_address {
10917                return 1;
10918            }
10919            0
10920        }
10921    }
10922
10923    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcSaeHandshakeIndRequest {
10924        type Borrowed<'a> = &'a Self;
10925        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10926            value
10927        }
10928    }
10929
10930    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcSaeHandshakeIndRequest {
10931        type Owned = Self;
10932
10933        #[inline(always)]
10934        fn inline_align(_context: fidl::encoding::Context) -> usize {
10935            8
10936        }
10937
10938        #[inline(always)]
10939        fn inline_size(_context: fidl::encoding::Context) -> usize {
10940            16
10941        }
10942    }
10943
10944    unsafe impl<D: fidl::encoding::ResourceDialect>
10945        fidl::encoding::Encode<WlanFullmacImplIfcSaeHandshakeIndRequest, D>
10946        for &WlanFullmacImplIfcSaeHandshakeIndRequest
10947    {
10948        unsafe fn encode(
10949            self,
10950            encoder: &mut fidl::encoding::Encoder<'_, D>,
10951            offset: usize,
10952            mut depth: fidl::encoding::Depth,
10953        ) -> fidl::Result<()> {
10954            encoder.debug_check_bounds::<WlanFullmacImplIfcSaeHandshakeIndRequest>(offset);
10955            // Vector header
10956            let max_ordinal: u64 = self.max_ordinal_present();
10957            encoder.write_num(max_ordinal, offset);
10958            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10959            // Calling encoder.out_of_line_offset(0) is not allowed.
10960            if max_ordinal == 0 {
10961                return Ok(());
10962            }
10963            depth.increment()?;
10964            let envelope_size = 8;
10965            let bytes_len = max_ordinal as usize * envelope_size;
10966            #[allow(unused_variables)]
10967            let offset = encoder.out_of_line_offset(bytes_len);
10968            let mut _prev_end_offset: usize = 0;
10969            if 1 > max_ordinal {
10970                return Ok(());
10971            }
10972
10973            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10974            // are envelope_size bytes.
10975            let cur_offset: usize = (1 - 1) * envelope_size;
10976
10977            // Zero reserved fields.
10978            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10979
10980            // Safety:
10981            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10982            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10983            //   envelope_size bytes, there is always sufficient room.
10984            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
10985                self.peer_sta_address
10986                    .as_ref()
10987                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
10988                encoder,
10989                offset + cur_offset,
10990                depth,
10991            )?;
10992
10993            _prev_end_offset = cur_offset + envelope_size;
10994
10995            Ok(())
10996        }
10997    }
10998
10999    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11000        for WlanFullmacImplIfcSaeHandshakeIndRequest
11001    {
11002        #[inline(always)]
11003        fn new_empty() -> Self {
11004            Self::default()
11005        }
11006
11007        unsafe fn decode(
11008            &mut self,
11009            decoder: &mut fidl::encoding::Decoder<'_, D>,
11010            offset: usize,
11011            mut depth: fidl::encoding::Depth,
11012        ) -> fidl::Result<()> {
11013            decoder.debug_check_bounds::<Self>(offset);
11014            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11015                None => return Err(fidl::Error::NotNullable),
11016                Some(len) => len,
11017            };
11018            // Calling decoder.out_of_line_offset(0) is not allowed.
11019            if len == 0 {
11020                return Ok(());
11021            };
11022            depth.increment()?;
11023            let envelope_size = 8;
11024            let bytes_len = len * envelope_size;
11025            let offset = decoder.out_of_line_offset(bytes_len)?;
11026            // Decode the envelope for each type.
11027            let mut _next_ordinal_to_read = 0;
11028            let mut next_offset = offset;
11029            let end_offset = offset + bytes_len;
11030            _next_ordinal_to_read += 1;
11031            if next_offset >= end_offset {
11032                return Ok(());
11033            }
11034
11035            // Decode unknown envelopes for gaps in ordinals.
11036            while _next_ordinal_to_read < 1 {
11037                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11038                _next_ordinal_to_read += 1;
11039                next_offset += envelope_size;
11040            }
11041
11042            let next_out_of_line = decoder.next_out_of_line();
11043            let handles_before = decoder.remaining_handles();
11044            if let Some((inlined, num_bytes, num_handles)) =
11045                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11046            {
11047                let member_inline_size =
11048                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
11049                        decoder.context,
11050                    );
11051                if inlined != (member_inline_size <= 4) {
11052                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11053                }
11054                let inner_offset;
11055                let mut inner_depth = depth.clone();
11056                if inlined {
11057                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11058                    inner_offset = next_offset;
11059                } else {
11060                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11061                    inner_depth.increment()?;
11062                }
11063                let val_ref = self
11064                    .peer_sta_address
11065                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
11066                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
11067                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11068                {
11069                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11070                }
11071                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11072                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11073                }
11074            }
11075
11076            next_offset += envelope_size;
11077
11078            // Decode the remaining unknown envelopes.
11079            while next_offset < end_offset {
11080                _next_ordinal_to_read += 1;
11081                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11082                next_offset += envelope_size;
11083            }
11084
11085            Ok(())
11086        }
11087    }
11088
11089    impl WlanFullmacImplIfcStartConfRequest {
11090        #[inline(always)]
11091        fn max_ordinal_present(&self) -> u64 {
11092            if let Some(_) = self.result_code {
11093                return 1;
11094            }
11095            0
11096        }
11097    }
11098
11099    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcStartConfRequest {
11100        type Borrowed<'a> = &'a Self;
11101        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11102            value
11103        }
11104    }
11105
11106    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcStartConfRequest {
11107        type Owned = Self;
11108
11109        #[inline(always)]
11110        fn inline_align(_context: fidl::encoding::Context) -> usize {
11111            8
11112        }
11113
11114        #[inline(always)]
11115        fn inline_size(_context: fidl::encoding::Context) -> usize {
11116            16
11117        }
11118    }
11119
11120    unsafe impl<D: fidl::encoding::ResourceDialect>
11121        fidl::encoding::Encode<WlanFullmacImplIfcStartConfRequest, D>
11122        for &WlanFullmacImplIfcStartConfRequest
11123    {
11124        unsafe fn encode(
11125            self,
11126            encoder: &mut fidl::encoding::Encoder<'_, D>,
11127            offset: usize,
11128            mut depth: fidl::encoding::Depth,
11129        ) -> fidl::Result<()> {
11130            encoder.debug_check_bounds::<WlanFullmacImplIfcStartConfRequest>(offset);
11131            // Vector header
11132            let max_ordinal: u64 = self.max_ordinal_present();
11133            encoder.write_num(max_ordinal, offset);
11134            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11135            // Calling encoder.out_of_line_offset(0) is not allowed.
11136            if max_ordinal == 0 {
11137                return Ok(());
11138            }
11139            depth.increment()?;
11140            let envelope_size = 8;
11141            let bytes_len = max_ordinal as usize * envelope_size;
11142            #[allow(unused_variables)]
11143            let offset = encoder.out_of_line_offset(bytes_len);
11144            let mut _prev_end_offset: usize = 0;
11145            if 1 > max_ordinal {
11146                return Ok(());
11147            }
11148
11149            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11150            // are envelope_size bytes.
11151            let cur_offset: usize = (1 - 1) * envelope_size;
11152
11153            // Zero reserved fields.
11154            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11155
11156            // Safety:
11157            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11158            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11159            //   envelope_size bytes, there is always sufficient room.
11160            fidl::encoding::encode_in_envelope_optional::<StartResult, D>(
11161                self.result_code
11162                    .as_ref()
11163                    .map(<StartResult as fidl::encoding::ValueTypeMarker>::borrow),
11164                encoder,
11165                offset + cur_offset,
11166                depth,
11167            )?;
11168
11169            _prev_end_offset = cur_offset + envelope_size;
11170
11171            Ok(())
11172        }
11173    }
11174
11175    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11176        for WlanFullmacImplIfcStartConfRequest
11177    {
11178        #[inline(always)]
11179        fn new_empty() -> Self {
11180            Self::default()
11181        }
11182
11183        unsafe fn decode(
11184            &mut self,
11185            decoder: &mut fidl::encoding::Decoder<'_, D>,
11186            offset: usize,
11187            mut depth: fidl::encoding::Depth,
11188        ) -> fidl::Result<()> {
11189            decoder.debug_check_bounds::<Self>(offset);
11190            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11191                None => return Err(fidl::Error::NotNullable),
11192                Some(len) => len,
11193            };
11194            // Calling decoder.out_of_line_offset(0) is not allowed.
11195            if len == 0 {
11196                return Ok(());
11197            };
11198            depth.increment()?;
11199            let envelope_size = 8;
11200            let bytes_len = len * envelope_size;
11201            let offset = decoder.out_of_line_offset(bytes_len)?;
11202            // Decode the envelope for each type.
11203            let mut _next_ordinal_to_read = 0;
11204            let mut next_offset = offset;
11205            let end_offset = offset + bytes_len;
11206            _next_ordinal_to_read += 1;
11207            if next_offset >= end_offset {
11208                return Ok(());
11209            }
11210
11211            // Decode unknown envelopes for gaps in ordinals.
11212            while _next_ordinal_to_read < 1 {
11213                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11214                _next_ordinal_to_read += 1;
11215                next_offset += envelope_size;
11216            }
11217
11218            let next_out_of_line = decoder.next_out_of_line();
11219            let handles_before = decoder.remaining_handles();
11220            if let Some((inlined, num_bytes, num_handles)) =
11221                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11222            {
11223                let member_inline_size =
11224                    <StartResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11225                if inlined != (member_inline_size <= 4) {
11226                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11227                }
11228                let inner_offset;
11229                let mut inner_depth = depth.clone();
11230                if inlined {
11231                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11232                    inner_offset = next_offset;
11233                } else {
11234                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11235                    inner_depth.increment()?;
11236                }
11237                let val_ref =
11238                    self.result_code.get_or_insert_with(|| fidl::new_empty!(StartResult, D));
11239                fidl::decode!(StartResult, D, val_ref, decoder, inner_offset, inner_depth)?;
11240                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11241                {
11242                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11243                }
11244                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11245                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11246                }
11247            }
11248
11249            next_offset += envelope_size;
11250
11251            // Decode the remaining unknown envelopes.
11252            while next_offset < end_offset {
11253                _next_ordinal_to_read += 1;
11254                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11255                next_offset += envelope_size;
11256            }
11257
11258            Ok(())
11259        }
11260    }
11261
11262    impl WlanFullmacImplIfcStopConfRequest {
11263        #[inline(always)]
11264        fn max_ordinal_present(&self) -> u64 {
11265            if let Some(_) = self.result_code {
11266                return 1;
11267            }
11268            0
11269        }
11270    }
11271
11272    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcStopConfRequest {
11273        type Borrowed<'a> = &'a Self;
11274        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11275            value
11276        }
11277    }
11278
11279    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcStopConfRequest {
11280        type Owned = Self;
11281
11282        #[inline(always)]
11283        fn inline_align(_context: fidl::encoding::Context) -> usize {
11284            8
11285        }
11286
11287        #[inline(always)]
11288        fn inline_size(_context: fidl::encoding::Context) -> usize {
11289            16
11290        }
11291    }
11292
11293    unsafe impl<D: fidl::encoding::ResourceDialect>
11294        fidl::encoding::Encode<WlanFullmacImplIfcStopConfRequest, D>
11295        for &WlanFullmacImplIfcStopConfRequest
11296    {
11297        unsafe fn encode(
11298            self,
11299            encoder: &mut fidl::encoding::Encoder<'_, D>,
11300            offset: usize,
11301            mut depth: fidl::encoding::Depth,
11302        ) -> fidl::Result<()> {
11303            encoder.debug_check_bounds::<WlanFullmacImplIfcStopConfRequest>(offset);
11304            // Vector header
11305            let max_ordinal: u64 = self.max_ordinal_present();
11306            encoder.write_num(max_ordinal, offset);
11307            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11308            // Calling encoder.out_of_line_offset(0) is not allowed.
11309            if max_ordinal == 0 {
11310                return Ok(());
11311            }
11312            depth.increment()?;
11313            let envelope_size = 8;
11314            let bytes_len = max_ordinal as usize * envelope_size;
11315            #[allow(unused_variables)]
11316            let offset = encoder.out_of_line_offset(bytes_len);
11317            let mut _prev_end_offset: usize = 0;
11318            if 1 > max_ordinal {
11319                return Ok(());
11320            }
11321
11322            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11323            // are envelope_size bytes.
11324            let cur_offset: usize = (1 - 1) * envelope_size;
11325
11326            // Zero reserved fields.
11327            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11328
11329            // Safety:
11330            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11331            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11332            //   envelope_size bytes, there is always sufficient room.
11333            fidl::encoding::encode_in_envelope_optional::<StopResult, D>(
11334                self.result_code
11335                    .as_ref()
11336                    .map(<StopResult as fidl::encoding::ValueTypeMarker>::borrow),
11337                encoder,
11338                offset + cur_offset,
11339                depth,
11340            )?;
11341
11342            _prev_end_offset = cur_offset + envelope_size;
11343
11344            Ok(())
11345        }
11346    }
11347
11348    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11349        for WlanFullmacImplIfcStopConfRequest
11350    {
11351        #[inline(always)]
11352        fn new_empty() -> Self {
11353            Self::default()
11354        }
11355
11356        unsafe fn decode(
11357            &mut self,
11358            decoder: &mut fidl::encoding::Decoder<'_, D>,
11359            offset: usize,
11360            mut depth: fidl::encoding::Depth,
11361        ) -> fidl::Result<()> {
11362            decoder.debug_check_bounds::<Self>(offset);
11363            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11364                None => return Err(fidl::Error::NotNullable),
11365                Some(len) => len,
11366            };
11367            // Calling decoder.out_of_line_offset(0) is not allowed.
11368            if len == 0 {
11369                return Ok(());
11370            };
11371            depth.increment()?;
11372            let envelope_size = 8;
11373            let bytes_len = len * envelope_size;
11374            let offset = decoder.out_of_line_offset(bytes_len)?;
11375            // Decode the envelope for each type.
11376            let mut _next_ordinal_to_read = 0;
11377            let mut next_offset = offset;
11378            let end_offset = offset + bytes_len;
11379            _next_ordinal_to_read += 1;
11380            if next_offset >= end_offset {
11381                return Ok(());
11382            }
11383
11384            // Decode unknown envelopes for gaps in ordinals.
11385            while _next_ordinal_to_read < 1 {
11386                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11387                _next_ordinal_to_read += 1;
11388                next_offset += envelope_size;
11389            }
11390
11391            let next_out_of_line = decoder.next_out_of_line();
11392            let handles_before = decoder.remaining_handles();
11393            if let Some((inlined, num_bytes, num_handles)) =
11394                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11395            {
11396                let member_inline_size =
11397                    <StopResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11398                if inlined != (member_inline_size <= 4) {
11399                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11400                }
11401                let inner_offset;
11402                let mut inner_depth = depth.clone();
11403                if inlined {
11404                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11405                    inner_offset = next_offset;
11406                } else {
11407                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11408                    inner_depth.increment()?;
11409                }
11410                let val_ref =
11411                    self.result_code.get_or_insert_with(|| fidl::new_empty!(StopResult, D));
11412                fidl::decode!(StopResult, D, val_ref, decoder, inner_offset, inner_depth)?;
11413                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11414                {
11415                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11416                }
11417                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11418                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11419                }
11420            }
11421
11422            next_offset += envelope_size;
11423
11424            // Decode the remaining unknown envelopes.
11425            while next_offset < end_offset {
11426                _next_ordinal_to_read += 1;
11427                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11428                next_offset += envelope_size;
11429            }
11430
11431            Ok(())
11432        }
11433    }
11434
11435    impl WlanFullmacImplOnLinkStateChangedRequest {
11436        #[inline(always)]
11437        fn max_ordinal_present(&self) -> u64 {
11438            if let Some(_) = self.online {
11439                return 1;
11440            }
11441            0
11442        }
11443    }
11444
11445    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplOnLinkStateChangedRequest {
11446        type Borrowed<'a> = &'a Self;
11447        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11448            value
11449        }
11450    }
11451
11452    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplOnLinkStateChangedRequest {
11453        type Owned = Self;
11454
11455        #[inline(always)]
11456        fn inline_align(_context: fidl::encoding::Context) -> usize {
11457            8
11458        }
11459
11460        #[inline(always)]
11461        fn inline_size(_context: fidl::encoding::Context) -> usize {
11462            16
11463        }
11464    }
11465
11466    unsafe impl<D: fidl::encoding::ResourceDialect>
11467        fidl::encoding::Encode<WlanFullmacImplOnLinkStateChangedRequest, D>
11468        for &WlanFullmacImplOnLinkStateChangedRequest
11469    {
11470        unsafe fn encode(
11471            self,
11472            encoder: &mut fidl::encoding::Encoder<'_, D>,
11473            offset: usize,
11474            mut depth: fidl::encoding::Depth,
11475        ) -> fidl::Result<()> {
11476            encoder.debug_check_bounds::<WlanFullmacImplOnLinkStateChangedRequest>(offset);
11477            // Vector header
11478            let max_ordinal: u64 = self.max_ordinal_present();
11479            encoder.write_num(max_ordinal, offset);
11480            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11481            // Calling encoder.out_of_line_offset(0) is not allowed.
11482            if max_ordinal == 0 {
11483                return Ok(());
11484            }
11485            depth.increment()?;
11486            let envelope_size = 8;
11487            let bytes_len = max_ordinal as usize * envelope_size;
11488            #[allow(unused_variables)]
11489            let offset = encoder.out_of_line_offset(bytes_len);
11490            let mut _prev_end_offset: usize = 0;
11491            if 1 > max_ordinal {
11492                return Ok(());
11493            }
11494
11495            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11496            // are envelope_size bytes.
11497            let cur_offset: usize = (1 - 1) * envelope_size;
11498
11499            // Zero reserved fields.
11500            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11501
11502            // Safety:
11503            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11504            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11505            //   envelope_size bytes, there is always sufficient room.
11506            fidl::encoding::encode_in_envelope_optional::<bool, D>(
11507                self.online.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
11508                encoder,
11509                offset + cur_offset,
11510                depth,
11511            )?;
11512
11513            _prev_end_offset = cur_offset + envelope_size;
11514
11515            Ok(())
11516        }
11517    }
11518
11519    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11520        for WlanFullmacImplOnLinkStateChangedRequest
11521    {
11522        #[inline(always)]
11523        fn new_empty() -> Self {
11524            Self::default()
11525        }
11526
11527        unsafe fn decode(
11528            &mut self,
11529            decoder: &mut fidl::encoding::Decoder<'_, D>,
11530            offset: usize,
11531            mut depth: fidl::encoding::Depth,
11532        ) -> fidl::Result<()> {
11533            decoder.debug_check_bounds::<Self>(offset);
11534            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11535                None => return Err(fidl::Error::NotNullable),
11536                Some(len) => len,
11537            };
11538            // Calling decoder.out_of_line_offset(0) is not allowed.
11539            if len == 0 {
11540                return Ok(());
11541            };
11542            depth.increment()?;
11543            let envelope_size = 8;
11544            let bytes_len = len * envelope_size;
11545            let offset = decoder.out_of_line_offset(bytes_len)?;
11546            // Decode the envelope for each type.
11547            let mut _next_ordinal_to_read = 0;
11548            let mut next_offset = offset;
11549            let end_offset = offset + bytes_len;
11550            _next_ordinal_to_read += 1;
11551            if next_offset >= end_offset {
11552                return Ok(());
11553            }
11554
11555            // Decode unknown envelopes for gaps in ordinals.
11556            while _next_ordinal_to_read < 1 {
11557                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11558                _next_ordinal_to_read += 1;
11559                next_offset += envelope_size;
11560            }
11561
11562            let next_out_of_line = decoder.next_out_of_line();
11563            let handles_before = decoder.remaining_handles();
11564            if let Some((inlined, num_bytes, num_handles)) =
11565                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11566            {
11567                let member_inline_size =
11568                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11569                if inlined != (member_inline_size <= 4) {
11570                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11571                }
11572                let inner_offset;
11573                let mut inner_depth = depth.clone();
11574                if inlined {
11575                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11576                    inner_offset = next_offset;
11577                } else {
11578                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11579                    inner_depth.increment()?;
11580                }
11581                let val_ref = self.online.get_or_insert_with(|| fidl::new_empty!(bool, D));
11582                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11583                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11584                {
11585                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11586                }
11587                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11588                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11589                }
11590            }
11591
11592            next_offset += envelope_size;
11593
11594            // Decode the remaining unknown envelopes.
11595            while next_offset < end_offset {
11596                _next_ordinal_to_read += 1;
11597                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11598                next_offset += envelope_size;
11599            }
11600
11601            Ok(())
11602        }
11603    }
11604
11605    impl WlanFullmacImplReconnectRequest {
11606        #[inline(always)]
11607        fn max_ordinal_present(&self) -> u64 {
11608            if let Some(_) = self.peer_sta_address {
11609                return 1;
11610            }
11611            0
11612        }
11613    }
11614
11615    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplReconnectRequest {
11616        type Borrowed<'a> = &'a Self;
11617        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11618            value
11619        }
11620    }
11621
11622    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplReconnectRequest {
11623        type Owned = Self;
11624
11625        #[inline(always)]
11626        fn inline_align(_context: fidl::encoding::Context) -> usize {
11627            8
11628        }
11629
11630        #[inline(always)]
11631        fn inline_size(_context: fidl::encoding::Context) -> usize {
11632            16
11633        }
11634    }
11635
11636    unsafe impl<D: fidl::encoding::ResourceDialect>
11637        fidl::encoding::Encode<WlanFullmacImplReconnectRequest, D>
11638        for &WlanFullmacImplReconnectRequest
11639    {
11640        unsafe fn encode(
11641            self,
11642            encoder: &mut fidl::encoding::Encoder<'_, D>,
11643            offset: usize,
11644            mut depth: fidl::encoding::Depth,
11645        ) -> fidl::Result<()> {
11646            encoder.debug_check_bounds::<WlanFullmacImplReconnectRequest>(offset);
11647            // Vector header
11648            let max_ordinal: u64 = self.max_ordinal_present();
11649            encoder.write_num(max_ordinal, offset);
11650            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11651            // Calling encoder.out_of_line_offset(0) is not allowed.
11652            if max_ordinal == 0 {
11653                return Ok(());
11654            }
11655            depth.increment()?;
11656            let envelope_size = 8;
11657            let bytes_len = max_ordinal as usize * envelope_size;
11658            #[allow(unused_variables)]
11659            let offset = encoder.out_of_line_offset(bytes_len);
11660            let mut _prev_end_offset: usize = 0;
11661            if 1 > max_ordinal {
11662                return Ok(());
11663            }
11664
11665            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11666            // are envelope_size bytes.
11667            let cur_offset: usize = (1 - 1) * envelope_size;
11668
11669            // Zero reserved fields.
11670            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11671
11672            // Safety:
11673            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11674            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11675            //   envelope_size bytes, there is always sufficient room.
11676            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
11677                self.peer_sta_address
11678                    .as_ref()
11679                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
11680                encoder,
11681                offset + cur_offset,
11682                depth,
11683            )?;
11684
11685            _prev_end_offset = cur_offset + envelope_size;
11686
11687            Ok(())
11688        }
11689    }
11690
11691    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11692        for WlanFullmacImplReconnectRequest
11693    {
11694        #[inline(always)]
11695        fn new_empty() -> Self {
11696            Self::default()
11697        }
11698
11699        unsafe fn decode(
11700            &mut self,
11701            decoder: &mut fidl::encoding::Decoder<'_, D>,
11702            offset: usize,
11703            mut depth: fidl::encoding::Depth,
11704        ) -> fidl::Result<()> {
11705            decoder.debug_check_bounds::<Self>(offset);
11706            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11707                None => return Err(fidl::Error::NotNullable),
11708                Some(len) => len,
11709            };
11710            // Calling decoder.out_of_line_offset(0) is not allowed.
11711            if len == 0 {
11712                return Ok(());
11713            };
11714            depth.increment()?;
11715            let envelope_size = 8;
11716            let bytes_len = len * envelope_size;
11717            let offset = decoder.out_of_line_offset(bytes_len)?;
11718            // Decode the envelope for each type.
11719            let mut _next_ordinal_to_read = 0;
11720            let mut next_offset = offset;
11721            let end_offset = offset + bytes_len;
11722            _next_ordinal_to_read += 1;
11723            if next_offset >= end_offset {
11724                return Ok(());
11725            }
11726
11727            // Decode unknown envelopes for gaps in ordinals.
11728            while _next_ordinal_to_read < 1 {
11729                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11730                _next_ordinal_to_read += 1;
11731                next_offset += envelope_size;
11732            }
11733
11734            let next_out_of_line = decoder.next_out_of_line();
11735            let handles_before = decoder.remaining_handles();
11736            if let Some((inlined, num_bytes, num_handles)) =
11737                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11738            {
11739                let member_inline_size =
11740                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
11741                        decoder.context,
11742                    );
11743                if inlined != (member_inline_size <= 4) {
11744                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11745                }
11746                let inner_offset;
11747                let mut inner_depth = depth.clone();
11748                if inlined {
11749                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11750                    inner_offset = next_offset;
11751                } else {
11752                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11753                    inner_depth.increment()?;
11754                }
11755                let val_ref = self
11756                    .peer_sta_address
11757                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
11758                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
11759                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11760                {
11761                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11762                }
11763                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11764                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11765                }
11766            }
11767
11768            next_offset += envelope_size;
11769
11770            // Decode the remaining unknown envelopes.
11771            while next_offset < end_offset {
11772                _next_ordinal_to_read += 1;
11773                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11774                next_offset += envelope_size;
11775            }
11776
11777            Ok(())
11778        }
11779    }
11780
11781    impl WlanFullmacImplRoamRequest {
11782        #[inline(always)]
11783        fn max_ordinal_present(&self) -> u64 {
11784            if let Some(_) = self.selected_bss {
11785                return 1;
11786            }
11787            0
11788        }
11789    }
11790
11791    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplRoamRequest {
11792        type Borrowed<'a> = &'a Self;
11793        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11794            value
11795        }
11796    }
11797
11798    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplRoamRequest {
11799        type Owned = Self;
11800
11801        #[inline(always)]
11802        fn inline_align(_context: fidl::encoding::Context) -> usize {
11803            8
11804        }
11805
11806        #[inline(always)]
11807        fn inline_size(_context: fidl::encoding::Context) -> usize {
11808            16
11809        }
11810    }
11811
11812    unsafe impl<D: fidl::encoding::ResourceDialect>
11813        fidl::encoding::Encode<WlanFullmacImplRoamRequest, D> for &WlanFullmacImplRoamRequest
11814    {
11815        unsafe fn encode(
11816            self,
11817            encoder: &mut fidl::encoding::Encoder<'_, D>,
11818            offset: usize,
11819            mut depth: fidl::encoding::Depth,
11820        ) -> fidl::Result<()> {
11821            encoder.debug_check_bounds::<WlanFullmacImplRoamRequest>(offset);
11822            // Vector header
11823            let max_ordinal: u64 = self.max_ordinal_present();
11824            encoder.write_num(max_ordinal, offset);
11825            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11826            // Calling encoder.out_of_line_offset(0) is not allowed.
11827            if max_ordinal == 0 {
11828                return Ok(());
11829            }
11830            depth.increment()?;
11831            let envelope_size = 8;
11832            let bytes_len = max_ordinal as usize * envelope_size;
11833            #[allow(unused_variables)]
11834            let offset = encoder.out_of_line_offset(bytes_len);
11835            let mut _prev_end_offset: usize = 0;
11836            if 1 > max_ordinal {
11837                return Ok(());
11838            }
11839
11840            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11841            // are envelope_size bytes.
11842            let cur_offset: usize = (1 - 1) * envelope_size;
11843
11844            // Zero reserved fields.
11845            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11846
11847            // Safety:
11848            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11849            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11850            //   envelope_size bytes, there is always sufficient room.
11851            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
11852            self.selected_bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
11853            encoder, offset + cur_offset, depth
11854        )?;
11855
11856            _prev_end_offset = cur_offset + envelope_size;
11857
11858            Ok(())
11859        }
11860    }
11861
11862    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11863        for WlanFullmacImplRoamRequest
11864    {
11865        #[inline(always)]
11866        fn new_empty() -> Self {
11867            Self::default()
11868        }
11869
11870        unsafe fn decode(
11871            &mut self,
11872            decoder: &mut fidl::encoding::Decoder<'_, D>,
11873            offset: usize,
11874            mut depth: fidl::encoding::Depth,
11875        ) -> fidl::Result<()> {
11876            decoder.debug_check_bounds::<Self>(offset);
11877            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11878                None => return Err(fidl::Error::NotNullable),
11879                Some(len) => len,
11880            };
11881            // Calling decoder.out_of_line_offset(0) is not allowed.
11882            if len == 0 {
11883                return Ok(());
11884            };
11885            depth.increment()?;
11886            let envelope_size = 8;
11887            let bytes_len = len * envelope_size;
11888            let offset = decoder.out_of_line_offset(bytes_len)?;
11889            // Decode the envelope for each type.
11890            let mut _next_ordinal_to_read = 0;
11891            let mut next_offset = offset;
11892            let end_offset = offset + bytes_len;
11893            _next_ordinal_to_read += 1;
11894            if next_offset >= end_offset {
11895                return Ok(());
11896            }
11897
11898            // Decode unknown envelopes for gaps in ordinals.
11899            while _next_ordinal_to_read < 1 {
11900                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11901                _next_ordinal_to_read += 1;
11902                next_offset += envelope_size;
11903            }
11904
11905            let next_out_of_line = decoder.next_out_of_line();
11906            let handles_before = decoder.remaining_handles();
11907            if let Some((inlined, num_bytes, num_handles)) =
11908                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11909            {
11910                let member_inline_size = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11911                if inlined != (member_inline_size <= 4) {
11912                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11913                }
11914                let inner_offset;
11915                let mut inner_depth = depth.clone();
11916                if inlined {
11917                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11918                    inner_offset = next_offset;
11919                } else {
11920                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11921                    inner_depth.increment()?;
11922                }
11923                let val_ref = self.selected_bss.get_or_insert_with(|| {
11924                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
11925                });
11926                fidl::decode!(
11927                    fidl_fuchsia_wlan_common__common::BssDescription,
11928                    D,
11929                    val_ref,
11930                    decoder,
11931                    inner_offset,
11932                    inner_depth
11933                )?;
11934                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11935                {
11936                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11937                }
11938                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11939                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11940                }
11941            }
11942
11943            next_offset += envelope_size;
11944
11945            // Decode the remaining unknown envelopes.
11946            while next_offset < end_offset {
11947                _next_ordinal_to_read += 1;
11948                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11949                next_offset += envelope_size;
11950            }
11951
11952            Ok(())
11953        }
11954    }
11955
11956    impl WlanFullmacImplSaeHandshakeRespRequest {
11957        #[inline(always)]
11958        fn max_ordinal_present(&self) -> u64 {
11959            if let Some(_) = self.status_code {
11960                return 2;
11961            }
11962            if let Some(_) = self.peer_sta_address {
11963                return 1;
11964            }
11965            0
11966        }
11967    }
11968
11969    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSaeHandshakeRespRequest {
11970        type Borrowed<'a> = &'a Self;
11971        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11972            value
11973        }
11974    }
11975
11976    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSaeHandshakeRespRequest {
11977        type Owned = Self;
11978
11979        #[inline(always)]
11980        fn inline_align(_context: fidl::encoding::Context) -> usize {
11981            8
11982        }
11983
11984        #[inline(always)]
11985        fn inline_size(_context: fidl::encoding::Context) -> usize {
11986            16
11987        }
11988    }
11989
11990    unsafe impl<D: fidl::encoding::ResourceDialect>
11991        fidl::encoding::Encode<WlanFullmacImplSaeHandshakeRespRequest, D>
11992        for &WlanFullmacImplSaeHandshakeRespRequest
11993    {
11994        unsafe fn encode(
11995            self,
11996            encoder: &mut fidl::encoding::Encoder<'_, D>,
11997            offset: usize,
11998            mut depth: fidl::encoding::Depth,
11999        ) -> fidl::Result<()> {
12000            encoder.debug_check_bounds::<WlanFullmacImplSaeHandshakeRespRequest>(offset);
12001            // Vector header
12002            let max_ordinal: u64 = self.max_ordinal_present();
12003            encoder.write_num(max_ordinal, offset);
12004            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12005            // Calling encoder.out_of_line_offset(0) is not allowed.
12006            if max_ordinal == 0 {
12007                return Ok(());
12008            }
12009            depth.increment()?;
12010            let envelope_size = 8;
12011            let bytes_len = max_ordinal as usize * envelope_size;
12012            #[allow(unused_variables)]
12013            let offset = encoder.out_of_line_offset(bytes_len);
12014            let mut _prev_end_offset: usize = 0;
12015            if 1 > max_ordinal {
12016                return Ok(());
12017            }
12018
12019            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12020            // are envelope_size bytes.
12021            let cur_offset: usize = (1 - 1) * envelope_size;
12022
12023            // Zero reserved fields.
12024            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12025
12026            // Safety:
12027            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12028            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12029            //   envelope_size bytes, there is always sufficient room.
12030            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
12031                self.peer_sta_address
12032                    .as_ref()
12033                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
12034                encoder,
12035                offset + cur_offset,
12036                depth,
12037            )?;
12038
12039            _prev_end_offset = cur_offset + envelope_size;
12040            if 2 > max_ordinal {
12041                return Ok(());
12042            }
12043
12044            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12045            // are envelope_size bytes.
12046            let cur_offset: usize = (2 - 1) * envelope_size;
12047
12048            // Zero reserved fields.
12049            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12050
12051            // Safety:
12052            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12053            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12054            //   envelope_size bytes, there is always sufficient room.
12055            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
12056            self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
12057            encoder, offset + cur_offset, depth
12058        )?;
12059
12060            _prev_end_offset = cur_offset + envelope_size;
12061
12062            Ok(())
12063        }
12064    }
12065
12066    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12067        for WlanFullmacImplSaeHandshakeRespRequest
12068    {
12069        #[inline(always)]
12070        fn new_empty() -> Self {
12071            Self::default()
12072        }
12073
12074        unsafe fn decode(
12075            &mut self,
12076            decoder: &mut fidl::encoding::Decoder<'_, D>,
12077            offset: usize,
12078            mut depth: fidl::encoding::Depth,
12079        ) -> fidl::Result<()> {
12080            decoder.debug_check_bounds::<Self>(offset);
12081            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12082                None => return Err(fidl::Error::NotNullable),
12083                Some(len) => len,
12084            };
12085            // Calling decoder.out_of_line_offset(0) is not allowed.
12086            if len == 0 {
12087                return Ok(());
12088            };
12089            depth.increment()?;
12090            let envelope_size = 8;
12091            let bytes_len = len * envelope_size;
12092            let offset = decoder.out_of_line_offset(bytes_len)?;
12093            // Decode the envelope for each type.
12094            let mut _next_ordinal_to_read = 0;
12095            let mut next_offset = offset;
12096            let end_offset = offset + bytes_len;
12097            _next_ordinal_to_read += 1;
12098            if next_offset >= end_offset {
12099                return Ok(());
12100            }
12101
12102            // Decode unknown envelopes for gaps in ordinals.
12103            while _next_ordinal_to_read < 1 {
12104                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12105                _next_ordinal_to_read += 1;
12106                next_offset += envelope_size;
12107            }
12108
12109            let next_out_of_line = decoder.next_out_of_line();
12110            let handles_before = decoder.remaining_handles();
12111            if let Some((inlined, num_bytes, num_handles)) =
12112                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12113            {
12114                let member_inline_size =
12115                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
12116                        decoder.context,
12117                    );
12118                if inlined != (member_inline_size <= 4) {
12119                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12120                }
12121                let inner_offset;
12122                let mut inner_depth = depth.clone();
12123                if inlined {
12124                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12125                    inner_offset = next_offset;
12126                } else {
12127                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12128                    inner_depth.increment()?;
12129                }
12130                let val_ref = self
12131                    .peer_sta_address
12132                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
12133                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
12134                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12135                {
12136                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12137                }
12138                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12139                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12140                }
12141            }
12142
12143            next_offset += envelope_size;
12144            _next_ordinal_to_read += 1;
12145            if next_offset >= end_offset {
12146                return Ok(());
12147            }
12148
12149            // Decode unknown envelopes for gaps in ordinals.
12150            while _next_ordinal_to_read < 2 {
12151                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12152                _next_ordinal_to_read += 1;
12153                next_offset += envelope_size;
12154            }
12155
12156            let next_out_of_line = decoder.next_out_of_line();
12157            let handles_before = decoder.remaining_handles();
12158            if let Some((inlined, num_bytes, num_handles)) =
12159                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12160            {
12161                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12162                if inlined != (member_inline_size <= 4) {
12163                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12164                }
12165                let inner_offset;
12166                let mut inner_depth = depth.clone();
12167                if inlined {
12168                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12169                    inner_offset = next_offset;
12170                } else {
12171                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12172                    inner_depth.increment()?;
12173                }
12174                let val_ref = self.status_code.get_or_insert_with(|| {
12175                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
12176                });
12177                fidl::decode!(
12178                    fidl_fuchsia_wlan_ieee80211__common::StatusCode,
12179                    D,
12180                    val_ref,
12181                    decoder,
12182                    inner_offset,
12183                    inner_depth
12184                )?;
12185                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12186                {
12187                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12188                }
12189                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12190                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12191                }
12192            }
12193
12194            next_offset += envelope_size;
12195
12196            // Decode the remaining unknown envelopes.
12197            while next_offset < end_offset {
12198                _next_ordinal_to_read += 1;
12199                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12200                next_offset += envelope_size;
12201            }
12202
12203            Ok(())
12204        }
12205    }
12206
12207    impl WlanFullmacImplSetKeysRequest {
12208        #[inline(always)]
12209        fn max_ordinal_present(&self) -> u64 {
12210            if let Some(_) = self.key_descriptors {
12211                return 2;
12212            }
12213            if let Some(_) = self.keylist {
12214                return 1;
12215            }
12216            0
12217        }
12218    }
12219
12220    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSetKeysRequest {
12221        type Borrowed<'a> = &'a Self;
12222        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12223            value
12224        }
12225    }
12226
12227    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSetKeysRequest {
12228        type Owned = Self;
12229
12230        #[inline(always)]
12231        fn inline_align(_context: fidl::encoding::Context) -> usize {
12232            8
12233        }
12234
12235        #[inline(always)]
12236        fn inline_size(_context: fidl::encoding::Context) -> usize {
12237            16
12238        }
12239    }
12240
12241    unsafe impl<D: fidl::encoding::ResourceDialect>
12242        fidl::encoding::Encode<WlanFullmacImplSetKeysRequest, D>
12243        for &WlanFullmacImplSetKeysRequest
12244    {
12245        unsafe fn encode(
12246            self,
12247            encoder: &mut fidl::encoding::Encoder<'_, D>,
12248            offset: usize,
12249            mut depth: fidl::encoding::Depth,
12250        ) -> fidl::Result<()> {
12251            encoder.debug_check_bounds::<WlanFullmacImplSetKeysRequest>(offset);
12252            // Vector header
12253            let max_ordinal: u64 = self.max_ordinal_present();
12254            encoder.write_num(max_ordinal, offset);
12255            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12256            // Calling encoder.out_of_line_offset(0) is not allowed.
12257            if max_ordinal == 0 {
12258                return Ok(());
12259            }
12260            depth.increment()?;
12261            let envelope_size = 8;
12262            let bytes_len = max_ordinal as usize * envelope_size;
12263            #[allow(unused_variables)]
12264            let offset = encoder.out_of_line_offset(bytes_len);
12265            let mut _prev_end_offset: usize = 0;
12266            if 1 > max_ordinal {
12267                return Ok(());
12268            }
12269
12270            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12271            // are envelope_size bytes.
12272            let cur_offset: usize = (1 - 1) * envelope_size;
12273
12274            // Zero reserved fields.
12275            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12276
12277            // Safety:
12278            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12279            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12280            //   envelope_size bytes, there is always sufficient room.
12281            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4>, D>(
12282            self.keylist.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4> as fidl::encoding::ValueTypeMarker>::borrow),
12283            encoder, offset + cur_offset, depth
12284        )?;
12285
12286            _prev_end_offset = cur_offset + envelope_size;
12287            if 2 > max_ordinal {
12288                return Ok(());
12289            }
12290
12291            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12292            // are envelope_size bytes.
12293            let cur_offset: usize = (2 - 1) * envelope_size;
12294
12295            // Zero reserved fields.
12296            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12297
12298            // Safety:
12299            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12300            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12301            //   envelope_size bytes, there is always sufficient room.
12302            fidl::encoding::encode_in_envelope_optional::<
12303                fidl::encoding::Vector<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, 4>,
12304                D,
12305            >(
12306                self.key_descriptors.as_ref().map(
12307                    <fidl::encoding::Vector<
12308                        fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor,
12309                        4,
12310                    > as fidl::encoding::ValueTypeMarker>::borrow,
12311                ),
12312                encoder,
12313                offset + cur_offset,
12314                depth,
12315            )?;
12316
12317            _prev_end_offset = cur_offset + envelope_size;
12318
12319            Ok(())
12320        }
12321    }
12322
12323    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12324        for WlanFullmacImplSetKeysRequest
12325    {
12326        #[inline(always)]
12327        fn new_empty() -> Self {
12328            Self::default()
12329        }
12330
12331        unsafe fn decode(
12332            &mut self,
12333            decoder: &mut fidl::encoding::Decoder<'_, D>,
12334            offset: usize,
12335            mut depth: fidl::encoding::Depth,
12336        ) -> fidl::Result<()> {
12337            decoder.debug_check_bounds::<Self>(offset);
12338            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12339                None => return Err(fidl::Error::NotNullable),
12340                Some(len) => len,
12341            };
12342            // Calling decoder.out_of_line_offset(0) is not allowed.
12343            if len == 0 {
12344                return Ok(());
12345            };
12346            depth.increment()?;
12347            let envelope_size = 8;
12348            let bytes_len = len * envelope_size;
12349            let offset = decoder.out_of_line_offset(bytes_len)?;
12350            // Decode the envelope for each type.
12351            let mut _next_ordinal_to_read = 0;
12352            let mut next_offset = offset;
12353            let end_offset = offset + bytes_len;
12354            _next_ordinal_to_read += 1;
12355            if next_offset >= end_offset {
12356                return Ok(());
12357            }
12358
12359            // Decode unknown envelopes for gaps in ordinals.
12360            while _next_ordinal_to_read < 1 {
12361                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12362                _next_ordinal_to_read += 1;
12363                next_offset += envelope_size;
12364            }
12365
12366            let next_out_of_line = decoder.next_out_of_line();
12367            let handles_before = decoder.remaining_handles();
12368            if let Some((inlined, num_bytes, num_handles)) =
12369                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12370            {
12371                let member_inline_size = <fidl::encoding::Vector<
12372                    fidl_fuchsia_wlan_common__common::WlanKeyConfig,
12373                    4,
12374                > as fidl::encoding::TypeMarker>::inline_size(
12375                    decoder.context
12376                );
12377                if inlined != (member_inline_size <= 4) {
12378                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12379                }
12380                let inner_offset;
12381                let mut inner_depth = depth.clone();
12382                if inlined {
12383                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12384                    inner_offset = next_offset;
12385                } else {
12386                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12387                    inner_depth.increment()?;
12388                }
12389                let val_ref =
12390                self.keylist.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4>, D));
12391                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4>, D, val_ref, decoder, inner_offset, inner_depth)?;
12392                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12393                {
12394                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12395                }
12396                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12397                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12398                }
12399            }
12400
12401            next_offset += envelope_size;
12402            _next_ordinal_to_read += 1;
12403            if next_offset >= end_offset {
12404                return Ok(());
12405            }
12406
12407            // Decode unknown envelopes for gaps in ordinals.
12408            while _next_ordinal_to_read < 2 {
12409                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12410                _next_ordinal_to_read += 1;
12411                next_offset += envelope_size;
12412            }
12413
12414            let next_out_of_line = decoder.next_out_of_line();
12415            let handles_before = decoder.remaining_handles();
12416            if let Some((inlined, num_bytes, num_handles)) =
12417                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12418            {
12419                let member_inline_size = <fidl::encoding::Vector<
12420                    fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor,
12421                    4,
12422                > as fidl::encoding::TypeMarker>::inline_size(
12423                    decoder.context
12424                );
12425                if inlined != (member_inline_size <= 4) {
12426                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12427                }
12428                let inner_offset;
12429                let mut inner_depth = depth.clone();
12430                if inlined {
12431                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12432                    inner_offset = next_offset;
12433                } else {
12434                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12435                    inner_depth.increment()?;
12436                }
12437                let val_ref =
12438                self.key_descriptors.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, 4>, D));
12439                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, 4>, D, val_ref, decoder, inner_offset, inner_depth)?;
12440                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12441                {
12442                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12443                }
12444                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12445                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12446                }
12447            }
12448
12449            next_offset += envelope_size;
12450
12451            // Decode the remaining unknown envelopes.
12452            while next_offset < end_offset {
12453                _next_ordinal_to_read += 1;
12454                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12455                next_offset += envelope_size;
12456            }
12457
12458            Ok(())
12459        }
12460    }
12461
12462    impl WlanFullmacImplStartBssRequest {
12463        #[inline(always)]
12464        fn max_ordinal_present(&self) -> u64 {
12465            if let Some(_) = self.vendor_ie {
12466                return 7;
12467            }
12468            if let Some(_) = self.rsne {
12469                return 6;
12470            }
12471            if let Some(_) = self.channel {
12472                return 5;
12473            }
12474            if let Some(_) = self.dtim_period {
12475                return 4;
12476            }
12477            if let Some(_) = self.beacon_period {
12478                return 3;
12479            }
12480            if let Some(_) = self.bss_type {
12481                return 2;
12482            }
12483            if let Some(_) = self.ssid {
12484                return 1;
12485            }
12486            0
12487        }
12488    }
12489
12490    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplStartBssRequest {
12491        type Borrowed<'a> = &'a Self;
12492        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12493            value
12494        }
12495    }
12496
12497    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplStartBssRequest {
12498        type Owned = Self;
12499
12500        #[inline(always)]
12501        fn inline_align(_context: fidl::encoding::Context) -> usize {
12502            8
12503        }
12504
12505        #[inline(always)]
12506        fn inline_size(_context: fidl::encoding::Context) -> usize {
12507            16
12508        }
12509    }
12510
12511    unsafe impl<D: fidl::encoding::ResourceDialect>
12512        fidl::encoding::Encode<WlanFullmacImplStartBssRequest, D>
12513        for &WlanFullmacImplStartBssRequest
12514    {
12515        unsafe fn encode(
12516            self,
12517            encoder: &mut fidl::encoding::Encoder<'_, D>,
12518            offset: usize,
12519            mut depth: fidl::encoding::Depth,
12520        ) -> fidl::Result<()> {
12521            encoder.debug_check_bounds::<WlanFullmacImplStartBssRequest>(offset);
12522            // Vector header
12523            let max_ordinal: u64 = self.max_ordinal_present();
12524            encoder.write_num(max_ordinal, offset);
12525            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12526            // Calling encoder.out_of_line_offset(0) is not allowed.
12527            if max_ordinal == 0 {
12528                return Ok(());
12529            }
12530            depth.increment()?;
12531            let envelope_size = 8;
12532            let bytes_len = max_ordinal as usize * envelope_size;
12533            #[allow(unused_variables)]
12534            let offset = encoder.out_of_line_offset(bytes_len);
12535            let mut _prev_end_offset: usize = 0;
12536            if 1 > max_ordinal {
12537                return Ok(());
12538            }
12539
12540            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12541            // are envelope_size bytes.
12542            let cur_offset: usize = (1 - 1) * envelope_size;
12543
12544            // Zero reserved fields.
12545            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12546
12547            // Safety:
12548            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12549            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12550            //   envelope_size bytes, there is always sufficient room.
12551            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
12552                self.ssid.as_ref().map(
12553                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
12554                ),
12555                encoder,
12556                offset + cur_offset,
12557                depth,
12558            )?;
12559
12560            _prev_end_offset = cur_offset + envelope_size;
12561            if 2 > max_ordinal {
12562                return Ok(());
12563            }
12564
12565            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12566            // are envelope_size bytes.
12567            let cur_offset: usize = (2 - 1) * envelope_size;
12568
12569            // Zero reserved fields.
12570            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12571
12572            // Safety:
12573            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12574            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12575            //   envelope_size bytes, there is always sufficient room.
12576            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssType, D>(
12577            self.bss_type.as_ref().map(<fidl_fuchsia_wlan_common__common::BssType as fidl::encoding::ValueTypeMarker>::borrow),
12578            encoder, offset + cur_offset, depth
12579        )?;
12580
12581            _prev_end_offset = cur_offset + envelope_size;
12582            if 3 > max_ordinal {
12583                return Ok(());
12584            }
12585
12586            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12587            // are envelope_size bytes.
12588            let cur_offset: usize = (3 - 1) * envelope_size;
12589
12590            // Zero reserved fields.
12591            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12592
12593            // Safety:
12594            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12595            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12596            //   envelope_size bytes, there is always sufficient room.
12597            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12598                self.beacon_period.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12599                encoder,
12600                offset + cur_offset,
12601                depth,
12602            )?;
12603
12604            _prev_end_offset = cur_offset + envelope_size;
12605            if 4 > max_ordinal {
12606                return Ok(());
12607            }
12608
12609            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12610            // are envelope_size bytes.
12611            let cur_offset: usize = (4 - 1) * envelope_size;
12612
12613            // Zero reserved fields.
12614            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12615
12616            // Safety:
12617            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12618            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12619            //   envelope_size bytes, there is always sufficient room.
12620            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12621                self.dtim_period.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12622                encoder,
12623                offset + cur_offset,
12624                depth,
12625            )?;
12626
12627            _prev_end_offset = cur_offset + envelope_size;
12628            if 5 > max_ordinal {
12629                return Ok(());
12630            }
12631
12632            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12633            // are envelope_size bytes.
12634            let cur_offset: usize = (5 - 1) * envelope_size;
12635
12636            // Zero reserved fields.
12637            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12638
12639            // Safety:
12640            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12641            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12642            //   envelope_size bytes, there is always sufficient room.
12643            fidl::encoding::encode_in_envelope_optional::<u8, D>(
12644                self.channel.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
12645                encoder,
12646                offset + cur_offset,
12647                depth,
12648            )?;
12649
12650            _prev_end_offset = cur_offset + envelope_size;
12651            if 6 > max_ordinal {
12652                return Ok(());
12653            }
12654
12655            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12656            // are envelope_size bytes.
12657            let cur_offset: usize = (6 - 1) * envelope_size;
12658
12659            // Zero reserved fields.
12660            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12661
12662            // Safety:
12663            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12664            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12665            //   envelope_size bytes, there is always sufficient room.
12666            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 257>, D>(
12667                self.rsne.as_ref().map(
12668                    <fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow,
12669                ),
12670                encoder,
12671                offset + cur_offset,
12672                depth,
12673            )?;
12674
12675            _prev_end_offset = cur_offset + envelope_size;
12676            if 7 > max_ordinal {
12677                return Ok(());
12678            }
12679
12680            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12681            // are envelope_size bytes.
12682            let cur_offset: usize = (7 - 1) * envelope_size;
12683
12684            // Zero reserved fields.
12685            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12686
12687            // Safety:
12688            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12689            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12690            //   envelope_size bytes, there is always sufficient room.
12691            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 514>, D>(
12692                self.vendor_ie.as_ref().map(
12693                    <fidl::encoding::Vector<u8, 514> as fidl::encoding::ValueTypeMarker>::borrow,
12694                ),
12695                encoder,
12696                offset + cur_offset,
12697                depth,
12698            )?;
12699
12700            _prev_end_offset = cur_offset + envelope_size;
12701
12702            Ok(())
12703        }
12704    }
12705
12706    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12707        for WlanFullmacImplStartBssRequest
12708    {
12709        #[inline(always)]
12710        fn new_empty() -> Self {
12711            Self::default()
12712        }
12713
12714        unsafe fn decode(
12715            &mut self,
12716            decoder: &mut fidl::encoding::Decoder<'_, D>,
12717            offset: usize,
12718            mut depth: fidl::encoding::Depth,
12719        ) -> fidl::Result<()> {
12720            decoder.debug_check_bounds::<Self>(offset);
12721            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12722                None => return Err(fidl::Error::NotNullable),
12723                Some(len) => len,
12724            };
12725            // Calling decoder.out_of_line_offset(0) is not allowed.
12726            if len == 0 {
12727                return Ok(());
12728            };
12729            depth.increment()?;
12730            let envelope_size = 8;
12731            let bytes_len = len * envelope_size;
12732            let offset = decoder.out_of_line_offset(bytes_len)?;
12733            // Decode the envelope for each type.
12734            let mut _next_ordinal_to_read = 0;
12735            let mut next_offset = offset;
12736            let end_offset = offset + bytes_len;
12737            _next_ordinal_to_read += 1;
12738            if next_offset >= end_offset {
12739                return Ok(());
12740            }
12741
12742            // Decode unknown envelopes for gaps in ordinals.
12743            while _next_ordinal_to_read < 1 {
12744                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12745                _next_ordinal_to_read += 1;
12746                next_offset += envelope_size;
12747            }
12748
12749            let next_out_of_line = decoder.next_out_of_line();
12750            let handles_before = decoder.remaining_handles();
12751            if let Some((inlined, num_bytes, num_handles)) =
12752                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12753            {
12754                let member_inline_size =
12755                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
12756                        decoder.context,
12757                    );
12758                if inlined != (member_inline_size <= 4) {
12759                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12760                }
12761                let inner_offset;
12762                let mut inner_depth = depth.clone();
12763                if inlined {
12764                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12765                    inner_offset = next_offset;
12766                } else {
12767                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12768                    inner_depth.increment()?;
12769                }
12770                let val_ref = self
12771                    .ssid
12772                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
12773                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
12774                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12775                {
12776                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12777                }
12778                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12779                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12780                }
12781            }
12782
12783            next_offset += envelope_size;
12784            _next_ordinal_to_read += 1;
12785            if next_offset >= end_offset {
12786                return Ok(());
12787            }
12788
12789            // Decode unknown envelopes for gaps in ordinals.
12790            while _next_ordinal_to_read < 2 {
12791                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12792                _next_ordinal_to_read += 1;
12793                next_offset += envelope_size;
12794            }
12795
12796            let next_out_of_line = decoder.next_out_of_line();
12797            let handles_before = decoder.remaining_handles();
12798            if let Some((inlined, num_bytes, num_handles)) =
12799                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12800            {
12801                let member_inline_size = <fidl_fuchsia_wlan_common__common::BssType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12802                if inlined != (member_inline_size <= 4) {
12803                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12804                }
12805                let inner_offset;
12806                let mut inner_depth = depth.clone();
12807                if inlined {
12808                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12809                    inner_offset = next_offset;
12810                } else {
12811                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12812                    inner_depth.increment()?;
12813                }
12814                let val_ref = self.bss_type.get_or_insert_with(|| {
12815                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssType, D)
12816                });
12817                fidl::decode!(
12818                    fidl_fuchsia_wlan_common__common::BssType,
12819                    D,
12820                    val_ref,
12821                    decoder,
12822                    inner_offset,
12823                    inner_depth
12824                )?;
12825                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12826                {
12827                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12828                }
12829                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12830                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12831                }
12832            }
12833
12834            next_offset += envelope_size;
12835            _next_ordinal_to_read += 1;
12836            if next_offset >= end_offset {
12837                return Ok(());
12838            }
12839
12840            // Decode unknown envelopes for gaps in ordinals.
12841            while _next_ordinal_to_read < 3 {
12842                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12843                _next_ordinal_to_read += 1;
12844                next_offset += envelope_size;
12845            }
12846
12847            let next_out_of_line = decoder.next_out_of_line();
12848            let handles_before = decoder.remaining_handles();
12849            if let Some((inlined, num_bytes, num_handles)) =
12850                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12851            {
12852                let member_inline_size =
12853                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12854                if inlined != (member_inline_size <= 4) {
12855                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12856                }
12857                let inner_offset;
12858                let mut inner_depth = depth.clone();
12859                if inlined {
12860                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12861                    inner_offset = next_offset;
12862                } else {
12863                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12864                    inner_depth.increment()?;
12865                }
12866                let val_ref = self.beacon_period.get_or_insert_with(|| fidl::new_empty!(u32, D));
12867                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12868                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12869                {
12870                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12871                }
12872                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12873                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12874                }
12875            }
12876
12877            next_offset += envelope_size;
12878            _next_ordinal_to_read += 1;
12879            if next_offset >= end_offset {
12880                return Ok(());
12881            }
12882
12883            // Decode unknown envelopes for gaps in ordinals.
12884            while _next_ordinal_to_read < 4 {
12885                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12886                _next_ordinal_to_read += 1;
12887                next_offset += envelope_size;
12888            }
12889
12890            let next_out_of_line = decoder.next_out_of_line();
12891            let handles_before = decoder.remaining_handles();
12892            if let Some((inlined, num_bytes, num_handles)) =
12893                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12894            {
12895                let member_inline_size =
12896                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12897                if inlined != (member_inline_size <= 4) {
12898                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12899                }
12900                let inner_offset;
12901                let mut inner_depth = depth.clone();
12902                if inlined {
12903                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12904                    inner_offset = next_offset;
12905                } else {
12906                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12907                    inner_depth.increment()?;
12908                }
12909                let val_ref = self.dtim_period.get_or_insert_with(|| fidl::new_empty!(u32, D));
12910                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12911                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12912                {
12913                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12914                }
12915                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12916                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12917                }
12918            }
12919
12920            next_offset += envelope_size;
12921            _next_ordinal_to_read += 1;
12922            if next_offset >= end_offset {
12923                return Ok(());
12924            }
12925
12926            // Decode unknown envelopes for gaps in ordinals.
12927            while _next_ordinal_to_read < 5 {
12928                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12929                _next_ordinal_to_read += 1;
12930                next_offset += envelope_size;
12931            }
12932
12933            let next_out_of_line = decoder.next_out_of_line();
12934            let handles_before = decoder.remaining_handles();
12935            if let Some((inlined, num_bytes, num_handles)) =
12936                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12937            {
12938                let member_inline_size =
12939                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12940                if inlined != (member_inline_size <= 4) {
12941                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12942                }
12943                let inner_offset;
12944                let mut inner_depth = depth.clone();
12945                if inlined {
12946                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12947                    inner_offset = next_offset;
12948                } else {
12949                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12950                    inner_depth.increment()?;
12951                }
12952                let val_ref = self.channel.get_or_insert_with(|| fidl::new_empty!(u8, D));
12953                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
12954                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12955                {
12956                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12957                }
12958                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12959                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12960                }
12961            }
12962
12963            next_offset += envelope_size;
12964            _next_ordinal_to_read += 1;
12965            if next_offset >= end_offset {
12966                return Ok(());
12967            }
12968
12969            // Decode unknown envelopes for gaps in ordinals.
12970            while _next_ordinal_to_read < 6 {
12971                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12972                _next_ordinal_to_read += 1;
12973                next_offset += envelope_size;
12974            }
12975
12976            let next_out_of_line = decoder.next_out_of_line();
12977            let handles_before = decoder.remaining_handles();
12978            if let Some((inlined, num_bytes, num_handles)) =
12979                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12980            {
12981                let member_inline_size =
12982                    <fidl::encoding::Vector<u8, 257> as fidl::encoding::TypeMarker>::inline_size(
12983                        decoder.context,
12984                    );
12985                if inlined != (member_inline_size <= 4) {
12986                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12987                }
12988                let inner_offset;
12989                let mut inner_depth = depth.clone();
12990                if inlined {
12991                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12992                    inner_offset = next_offset;
12993                } else {
12994                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12995                    inner_depth.increment()?;
12996                }
12997                let val_ref = self
12998                    .rsne
12999                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 257>, D));
13000                fidl::decode!(fidl::encoding::Vector<u8, 257>, D, val_ref, decoder, inner_offset, inner_depth)?;
13001                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13002                {
13003                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13004                }
13005                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13006                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13007                }
13008            }
13009
13010            next_offset += envelope_size;
13011            _next_ordinal_to_read += 1;
13012            if next_offset >= end_offset {
13013                return Ok(());
13014            }
13015
13016            // Decode unknown envelopes for gaps in ordinals.
13017            while _next_ordinal_to_read < 7 {
13018                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13019                _next_ordinal_to_read += 1;
13020                next_offset += envelope_size;
13021            }
13022
13023            let next_out_of_line = decoder.next_out_of_line();
13024            let handles_before = decoder.remaining_handles();
13025            if let Some((inlined, num_bytes, num_handles)) =
13026                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13027            {
13028                let member_inline_size =
13029                    <fidl::encoding::Vector<u8, 514> as fidl::encoding::TypeMarker>::inline_size(
13030                        decoder.context,
13031                    );
13032                if inlined != (member_inline_size <= 4) {
13033                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13034                }
13035                let inner_offset;
13036                let mut inner_depth = depth.clone();
13037                if inlined {
13038                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13039                    inner_offset = next_offset;
13040                } else {
13041                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13042                    inner_depth.increment()?;
13043                }
13044                let val_ref = self
13045                    .vendor_ie
13046                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 514>, D));
13047                fidl::decode!(fidl::encoding::Vector<u8, 514>, D, val_ref, decoder, inner_offset, inner_depth)?;
13048                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13049                {
13050                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13051                }
13052                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13053                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13054                }
13055            }
13056
13057            next_offset += envelope_size;
13058
13059            // Decode the remaining unknown envelopes.
13060            while next_offset < end_offset {
13061                _next_ordinal_to_read += 1;
13062                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13063                next_offset += envelope_size;
13064            }
13065
13066            Ok(())
13067        }
13068    }
13069
13070    impl WlanFullmacImplStartScanRequest {
13071        #[inline(always)]
13072        fn max_ordinal_present(&self) -> u64 {
13073            if let Some(_) = self.max_channel_time {
13074                return 6;
13075            }
13076            if let Some(_) = self.min_channel_time {
13077                return 5;
13078            }
13079            if let Some(_) = self.ssids {
13080                return 4;
13081            }
13082            if let Some(_) = self.channels {
13083                return 3;
13084            }
13085            if let Some(_) = self.scan_type {
13086                return 2;
13087            }
13088            if let Some(_) = self.txn_id {
13089                return 1;
13090            }
13091            0
13092        }
13093    }
13094
13095    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplStartScanRequest {
13096        type Borrowed<'a> = &'a Self;
13097        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13098            value
13099        }
13100    }
13101
13102    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplStartScanRequest {
13103        type Owned = Self;
13104
13105        #[inline(always)]
13106        fn inline_align(_context: fidl::encoding::Context) -> usize {
13107            8
13108        }
13109
13110        #[inline(always)]
13111        fn inline_size(_context: fidl::encoding::Context) -> usize {
13112            16
13113        }
13114    }
13115
13116    unsafe impl<D: fidl::encoding::ResourceDialect>
13117        fidl::encoding::Encode<WlanFullmacImplStartScanRequest, D>
13118        for &WlanFullmacImplStartScanRequest
13119    {
13120        unsafe fn encode(
13121            self,
13122            encoder: &mut fidl::encoding::Encoder<'_, D>,
13123            offset: usize,
13124            mut depth: fidl::encoding::Depth,
13125        ) -> fidl::Result<()> {
13126            encoder.debug_check_bounds::<WlanFullmacImplStartScanRequest>(offset);
13127            // Vector header
13128            let max_ordinal: u64 = self.max_ordinal_present();
13129            encoder.write_num(max_ordinal, offset);
13130            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13131            // Calling encoder.out_of_line_offset(0) is not allowed.
13132            if max_ordinal == 0 {
13133                return Ok(());
13134            }
13135            depth.increment()?;
13136            let envelope_size = 8;
13137            let bytes_len = max_ordinal as usize * envelope_size;
13138            #[allow(unused_variables)]
13139            let offset = encoder.out_of_line_offset(bytes_len);
13140            let mut _prev_end_offset: usize = 0;
13141            if 1 > max_ordinal {
13142                return Ok(());
13143            }
13144
13145            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13146            // are envelope_size bytes.
13147            let cur_offset: usize = (1 - 1) * envelope_size;
13148
13149            // Zero reserved fields.
13150            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13151
13152            // Safety:
13153            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13154            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13155            //   envelope_size bytes, there is always sufficient room.
13156            fidl::encoding::encode_in_envelope_optional::<u64, D>(
13157                self.txn_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
13158                encoder,
13159                offset + cur_offset,
13160                depth,
13161            )?;
13162
13163            _prev_end_offset = cur_offset + envelope_size;
13164            if 2 > max_ordinal {
13165                return Ok(());
13166            }
13167
13168            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13169            // are envelope_size bytes.
13170            let cur_offset: usize = (2 - 1) * envelope_size;
13171
13172            // Zero reserved fields.
13173            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13174
13175            // Safety:
13176            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13177            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13178            //   envelope_size bytes, there is always sufficient room.
13179            fidl::encoding::encode_in_envelope_optional::<WlanScanType, D>(
13180                self.scan_type
13181                    .as_ref()
13182                    .map(<WlanScanType as fidl::encoding::ValueTypeMarker>::borrow),
13183                encoder,
13184                offset + cur_offset,
13185                depth,
13186            )?;
13187
13188            _prev_end_offset = cur_offset + envelope_size;
13189            if 3 > max_ordinal {
13190                return Ok(());
13191            }
13192
13193            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13194            // are envelope_size bytes.
13195            let cur_offset: usize = (3 - 1) * envelope_size;
13196
13197            // Zero reserved fields.
13198            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13199
13200            // Safety:
13201            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13202            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13203            //   envelope_size bytes, there is always sufficient room.
13204            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 256>, D>(
13205                self.channels.as_ref().map(
13206                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow,
13207                ),
13208                encoder,
13209                offset + cur_offset,
13210                depth,
13211            )?;
13212
13213            _prev_end_offset = cur_offset + envelope_size;
13214            if 4 > max_ordinal {
13215                return Ok(());
13216            }
13217
13218            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13219            // are envelope_size bytes.
13220            let cur_offset: usize = (4 - 1) * envelope_size;
13221
13222            // Zero reserved fields.
13223            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13224
13225            // Safety:
13226            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13227            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13228            //   envelope_size bytes, there is always sufficient room.
13229            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>, D>(
13230            self.ssids.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>> as fidl::encoding::ValueTypeMarker>::borrow),
13231            encoder, offset + cur_offset, depth
13232        )?;
13233
13234            _prev_end_offset = cur_offset + envelope_size;
13235            if 5 > max_ordinal {
13236                return Ok(());
13237            }
13238
13239            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13240            // are envelope_size bytes.
13241            let cur_offset: usize = (5 - 1) * envelope_size;
13242
13243            // Zero reserved fields.
13244            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13245
13246            // Safety:
13247            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13248            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13249            //   envelope_size bytes, there is always sufficient room.
13250            fidl::encoding::encode_in_envelope_optional::<u32, D>(
13251                self.min_channel_time
13252                    .as_ref()
13253                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
13254                encoder,
13255                offset + cur_offset,
13256                depth,
13257            )?;
13258
13259            _prev_end_offset = cur_offset + envelope_size;
13260            if 6 > max_ordinal {
13261                return Ok(());
13262            }
13263
13264            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13265            // are envelope_size bytes.
13266            let cur_offset: usize = (6 - 1) * envelope_size;
13267
13268            // Zero reserved fields.
13269            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13270
13271            // Safety:
13272            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13273            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13274            //   envelope_size bytes, there is always sufficient room.
13275            fidl::encoding::encode_in_envelope_optional::<u32, D>(
13276                self.max_channel_time
13277                    .as_ref()
13278                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
13279                encoder,
13280                offset + cur_offset,
13281                depth,
13282            )?;
13283
13284            _prev_end_offset = cur_offset + envelope_size;
13285
13286            Ok(())
13287        }
13288    }
13289
13290    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13291        for WlanFullmacImplStartScanRequest
13292    {
13293        #[inline(always)]
13294        fn new_empty() -> Self {
13295            Self::default()
13296        }
13297
13298        unsafe fn decode(
13299            &mut self,
13300            decoder: &mut fidl::encoding::Decoder<'_, D>,
13301            offset: usize,
13302            mut depth: fidl::encoding::Depth,
13303        ) -> fidl::Result<()> {
13304            decoder.debug_check_bounds::<Self>(offset);
13305            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13306                None => return Err(fidl::Error::NotNullable),
13307                Some(len) => len,
13308            };
13309            // Calling decoder.out_of_line_offset(0) is not allowed.
13310            if len == 0 {
13311                return Ok(());
13312            };
13313            depth.increment()?;
13314            let envelope_size = 8;
13315            let bytes_len = len * envelope_size;
13316            let offset = decoder.out_of_line_offset(bytes_len)?;
13317            // Decode the envelope for each type.
13318            let mut _next_ordinal_to_read = 0;
13319            let mut next_offset = offset;
13320            let end_offset = offset + bytes_len;
13321            _next_ordinal_to_read += 1;
13322            if next_offset >= end_offset {
13323                return Ok(());
13324            }
13325
13326            // Decode unknown envelopes for gaps in ordinals.
13327            while _next_ordinal_to_read < 1 {
13328                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13329                _next_ordinal_to_read += 1;
13330                next_offset += envelope_size;
13331            }
13332
13333            let next_out_of_line = decoder.next_out_of_line();
13334            let handles_before = decoder.remaining_handles();
13335            if let Some((inlined, num_bytes, num_handles)) =
13336                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13337            {
13338                let member_inline_size =
13339                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13340                if inlined != (member_inline_size <= 4) {
13341                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13342                }
13343                let inner_offset;
13344                let mut inner_depth = depth.clone();
13345                if inlined {
13346                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13347                    inner_offset = next_offset;
13348                } else {
13349                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13350                    inner_depth.increment()?;
13351                }
13352                let val_ref = self.txn_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
13353                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
13354                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13355                {
13356                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13357                }
13358                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13359                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13360                }
13361            }
13362
13363            next_offset += envelope_size;
13364            _next_ordinal_to_read += 1;
13365            if next_offset >= end_offset {
13366                return Ok(());
13367            }
13368
13369            // Decode unknown envelopes for gaps in ordinals.
13370            while _next_ordinal_to_read < 2 {
13371                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13372                _next_ordinal_to_read += 1;
13373                next_offset += envelope_size;
13374            }
13375
13376            let next_out_of_line = decoder.next_out_of_line();
13377            let handles_before = decoder.remaining_handles();
13378            if let Some((inlined, num_bytes, num_handles)) =
13379                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13380            {
13381                let member_inline_size =
13382                    <WlanScanType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13383                if inlined != (member_inline_size <= 4) {
13384                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13385                }
13386                let inner_offset;
13387                let mut inner_depth = depth.clone();
13388                if inlined {
13389                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13390                    inner_offset = next_offset;
13391                } else {
13392                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13393                    inner_depth.increment()?;
13394                }
13395                let val_ref =
13396                    self.scan_type.get_or_insert_with(|| fidl::new_empty!(WlanScanType, D));
13397                fidl::decode!(WlanScanType, D, val_ref, decoder, inner_offset, inner_depth)?;
13398                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13399                {
13400                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13401                }
13402                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13403                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13404                }
13405            }
13406
13407            next_offset += envelope_size;
13408            _next_ordinal_to_read += 1;
13409            if next_offset >= end_offset {
13410                return Ok(());
13411            }
13412
13413            // Decode unknown envelopes for gaps in ordinals.
13414            while _next_ordinal_to_read < 3 {
13415                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13416                _next_ordinal_to_read += 1;
13417                next_offset += envelope_size;
13418            }
13419
13420            let next_out_of_line = decoder.next_out_of_line();
13421            let handles_before = decoder.remaining_handles();
13422            if let Some((inlined, num_bytes, num_handles)) =
13423                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13424            {
13425                let member_inline_size =
13426                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::TypeMarker>::inline_size(
13427                        decoder.context,
13428                    );
13429                if inlined != (member_inline_size <= 4) {
13430                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13431                }
13432                let inner_offset;
13433                let mut inner_depth = depth.clone();
13434                if inlined {
13435                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13436                    inner_offset = next_offset;
13437                } else {
13438                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13439                    inner_depth.increment()?;
13440                }
13441                let val_ref = self
13442                    .channels
13443                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D));
13444                fidl::decode!(fidl::encoding::Vector<u8, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
13445                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13446                {
13447                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13448                }
13449                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13450                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13451                }
13452            }
13453
13454            next_offset += envelope_size;
13455            _next_ordinal_to_read += 1;
13456            if next_offset >= end_offset {
13457                return Ok(());
13458            }
13459
13460            // Decode unknown envelopes for gaps in ordinals.
13461            while _next_ordinal_to_read < 4 {
13462                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13463                _next_ordinal_to_read += 1;
13464                next_offset += envelope_size;
13465            }
13466
13467            let next_out_of_line = decoder.next_out_of_line();
13468            let handles_before = decoder.remaining_handles();
13469            if let Some((inlined, num_bytes, num_handles)) =
13470                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13471            {
13472                let member_inline_size = <fidl::encoding::UnboundedVector<
13473                    fidl::encoding::Vector<u8, 32>,
13474                > as fidl::encoding::TypeMarker>::inline_size(
13475                    decoder.context
13476                );
13477                if inlined != (member_inline_size <= 4) {
13478                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13479                }
13480                let inner_offset;
13481                let mut inner_depth = depth.clone();
13482                if inlined {
13483                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13484                    inner_offset = next_offset;
13485                } else {
13486                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13487                    inner_depth.increment()?;
13488                }
13489                let val_ref = self.ssids.get_or_insert_with(|| {
13490                    fidl::new_empty!(
13491                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>,
13492                        D
13493                    )
13494                });
13495                fidl::decode!(
13496                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>,
13497                    D,
13498                    val_ref,
13499                    decoder,
13500                    inner_offset,
13501                    inner_depth
13502                )?;
13503                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13504                {
13505                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13506                }
13507                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13508                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13509                }
13510            }
13511
13512            next_offset += envelope_size;
13513            _next_ordinal_to_read += 1;
13514            if next_offset >= end_offset {
13515                return Ok(());
13516            }
13517
13518            // Decode unknown envelopes for gaps in ordinals.
13519            while _next_ordinal_to_read < 5 {
13520                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13521                _next_ordinal_to_read += 1;
13522                next_offset += envelope_size;
13523            }
13524
13525            let next_out_of_line = decoder.next_out_of_line();
13526            let handles_before = decoder.remaining_handles();
13527            if let Some((inlined, num_bytes, num_handles)) =
13528                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13529            {
13530                let member_inline_size =
13531                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13532                if inlined != (member_inline_size <= 4) {
13533                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13534                }
13535                let inner_offset;
13536                let mut inner_depth = depth.clone();
13537                if inlined {
13538                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13539                    inner_offset = next_offset;
13540                } else {
13541                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13542                    inner_depth.increment()?;
13543                }
13544                let val_ref = self.min_channel_time.get_or_insert_with(|| fidl::new_empty!(u32, D));
13545                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
13546                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13547                {
13548                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13549                }
13550                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13551                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13552                }
13553            }
13554
13555            next_offset += envelope_size;
13556            _next_ordinal_to_read += 1;
13557            if next_offset >= end_offset {
13558                return Ok(());
13559            }
13560
13561            // Decode unknown envelopes for gaps in ordinals.
13562            while _next_ordinal_to_read < 6 {
13563                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13564                _next_ordinal_to_read += 1;
13565                next_offset += envelope_size;
13566            }
13567
13568            let next_out_of_line = decoder.next_out_of_line();
13569            let handles_before = decoder.remaining_handles();
13570            if let Some((inlined, num_bytes, num_handles)) =
13571                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13572            {
13573                let member_inline_size =
13574                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13575                if inlined != (member_inline_size <= 4) {
13576                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13577                }
13578                let inner_offset;
13579                let mut inner_depth = depth.clone();
13580                if inlined {
13581                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13582                    inner_offset = next_offset;
13583                } else {
13584                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13585                    inner_depth.increment()?;
13586                }
13587                let val_ref = self.max_channel_time.get_or_insert_with(|| fidl::new_empty!(u32, D));
13588                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
13589                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13590                {
13591                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13592                }
13593                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13594                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13595                }
13596            }
13597
13598            next_offset += envelope_size;
13599
13600            // Decode the remaining unknown envelopes.
13601            while next_offset < end_offset {
13602                _next_ordinal_to_read += 1;
13603                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13604                next_offset += envelope_size;
13605            }
13606
13607            Ok(())
13608        }
13609    }
13610
13611    impl WlanFullmacImplStopBssRequest {
13612        #[inline(always)]
13613        fn max_ordinal_present(&self) -> u64 {
13614            if let Some(_) = self.ssid {
13615                return 1;
13616            }
13617            0
13618        }
13619    }
13620
13621    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplStopBssRequest {
13622        type Borrowed<'a> = &'a Self;
13623        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13624            value
13625        }
13626    }
13627
13628    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplStopBssRequest {
13629        type Owned = Self;
13630
13631        #[inline(always)]
13632        fn inline_align(_context: fidl::encoding::Context) -> usize {
13633            8
13634        }
13635
13636        #[inline(always)]
13637        fn inline_size(_context: fidl::encoding::Context) -> usize {
13638            16
13639        }
13640    }
13641
13642    unsafe impl<D: fidl::encoding::ResourceDialect>
13643        fidl::encoding::Encode<WlanFullmacImplStopBssRequest, D>
13644        for &WlanFullmacImplStopBssRequest
13645    {
13646        unsafe fn encode(
13647            self,
13648            encoder: &mut fidl::encoding::Encoder<'_, D>,
13649            offset: usize,
13650            mut depth: fidl::encoding::Depth,
13651        ) -> fidl::Result<()> {
13652            encoder.debug_check_bounds::<WlanFullmacImplStopBssRequest>(offset);
13653            // Vector header
13654            let max_ordinal: u64 = self.max_ordinal_present();
13655            encoder.write_num(max_ordinal, offset);
13656            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13657            // Calling encoder.out_of_line_offset(0) is not allowed.
13658            if max_ordinal == 0 {
13659                return Ok(());
13660            }
13661            depth.increment()?;
13662            let envelope_size = 8;
13663            let bytes_len = max_ordinal as usize * envelope_size;
13664            #[allow(unused_variables)]
13665            let offset = encoder.out_of_line_offset(bytes_len);
13666            let mut _prev_end_offset: usize = 0;
13667            if 1 > max_ordinal {
13668                return Ok(());
13669            }
13670
13671            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13672            // are envelope_size bytes.
13673            let cur_offset: usize = (1 - 1) * envelope_size;
13674
13675            // Zero reserved fields.
13676            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13677
13678            // Safety:
13679            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13680            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13681            //   envelope_size bytes, there is always sufficient room.
13682            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
13683                self.ssid.as_ref().map(
13684                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
13685                ),
13686                encoder,
13687                offset + cur_offset,
13688                depth,
13689            )?;
13690
13691            _prev_end_offset = cur_offset + envelope_size;
13692
13693            Ok(())
13694        }
13695    }
13696
13697    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13698        for WlanFullmacImplStopBssRequest
13699    {
13700        #[inline(always)]
13701        fn new_empty() -> Self {
13702            Self::default()
13703        }
13704
13705        unsafe fn decode(
13706            &mut self,
13707            decoder: &mut fidl::encoding::Decoder<'_, D>,
13708            offset: usize,
13709            mut depth: fidl::encoding::Depth,
13710        ) -> fidl::Result<()> {
13711            decoder.debug_check_bounds::<Self>(offset);
13712            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13713                None => return Err(fidl::Error::NotNullable),
13714                Some(len) => len,
13715            };
13716            // Calling decoder.out_of_line_offset(0) is not allowed.
13717            if len == 0 {
13718                return Ok(());
13719            };
13720            depth.increment()?;
13721            let envelope_size = 8;
13722            let bytes_len = len * envelope_size;
13723            let offset = decoder.out_of_line_offset(bytes_len)?;
13724            // Decode the envelope for each type.
13725            let mut _next_ordinal_to_read = 0;
13726            let mut next_offset = offset;
13727            let end_offset = offset + bytes_len;
13728            _next_ordinal_to_read += 1;
13729            if next_offset >= end_offset {
13730                return Ok(());
13731            }
13732
13733            // Decode unknown envelopes for gaps in ordinals.
13734            while _next_ordinal_to_read < 1 {
13735                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13736                _next_ordinal_to_read += 1;
13737                next_offset += envelope_size;
13738            }
13739
13740            let next_out_of_line = decoder.next_out_of_line();
13741            let handles_before = decoder.remaining_handles();
13742            if let Some((inlined, num_bytes, num_handles)) =
13743                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13744            {
13745                let member_inline_size =
13746                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
13747                        decoder.context,
13748                    );
13749                if inlined != (member_inline_size <= 4) {
13750                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13751                }
13752                let inner_offset;
13753                let mut inner_depth = depth.clone();
13754                if inlined {
13755                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13756                    inner_offset = next_offset;
13757                } else {
13758                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13759                    inner_depth.increment()?;
13760                }
13761                let val_ref = self
13762                    .ssid
13763                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
13764                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
13765                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13766                {
13767                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13768                }
13769                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13770                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13771                }
13772            }
13773
13774            next_offset += envelope_size;
13775
13776            // Decode the remaining unknown envelopes.
13777            while next_offset < end_offset {
13778                _next_ordinal_to_read += 1;
13779                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13780                next_offset += envelope_size;
13781            }
13782
13783            Ok(())
13784        }
13785    }
13786
13787    impl WlanFullmacImplQueryResponse {
13788        #[inline(always)]
13789        fn max_ordinal_present(&self) -> u64 {
13790            if let Some(_) = self.band_caps {
13791                return 3;
13792            }
13793            if let Some(_) = self.role {
13794                return 2;
13795            }
13796            if let Some(_) = self.sta_addr {
13797                return 1;
13798            }
13799            0
13800        }
13801    }
13802
13803    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQueryResponse {
13804        type Borrowed<'a> = &'a Self;
13805        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13806            value
13807        }
13808    }
13809
13810    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQueryResponse {
13811        type Owned = Self;
13812
13813        #[inline(always)]
13814        fn inline_align(_context: fidl::encoding::Context) -> usize {
13815            8
13816        }
13817
13818        #[inline(always)]
13819        fn inline_size(_context: fidl::encoding::Context) -> usize {
13820            16
13821        }
13822    }
13823
13824    unsafe impl<D: fidl::encoding::ResourceDialect>
13825        fidl::encoding::Encode<WlanFullmacImplQueryResponse, D> for &WlanFullmacImplQueryResponse
13826    {
13827        unsafe fn encode(
13828            self,
13829            encoder: &mut fidl::encoding::Encoder<'_, D>,
13830            offset: usize,
13831            mut depth: fidl::encoding::Depth,
13832        ) -> fidl::Result<()> {
13833            encoder.debug_check_bounds::<WlanFullmacImplQueryResponse>(offset);
13834            // Vector header
13835            let max_ordinal: u64 = self.max_ordinal_present();
13836            encoder.write_num(max_ordinal, offset);
13837            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13838            // Calling encoder.out_of_line_offset(0) is not allowed.
13839            if max_ordinal == 0 {
13840                return Ok(());
13841            }
13842            depth.increment()?;
13843            let envelope_size = 8;
13844            let bytes_len = max_ordinal as usize * envelope_size;
13845            #[allow(unused_variables)]
13846            let offset = encoder.out_of_line_offset(bytes_len);
13847            let mut _prev_end_offset: usize = 0;
13848            if 1 > max_ordinal {
13849                return Ok(());
13850            }
13851
13852            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13853            // are envelope_size bytes.
13854            let cur_offset: usize = (1 - 1) * envelope_size;
13855
13856            // Zero reserved fields.
13857            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13858
13859            // Safety:
13860            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13861            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13862            //   envelope_size bytes, there is always sufficient room.
13863            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
13864                self.sta_addr
13865                    .as_ref()
13866                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
13867                encoder,
13868                offset + cur_offset,
13869                depth,
13870            )?;
13871
13872            _prev_end_offset = cur_offset + envelope_size;
13873            if 2 > max_ordinal {
13874                return Ok(());
13875            }
13876
13877            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13878            // are envelope_size bytes.
13879            let cur_offset: usize = (2 - 1) * envelope_size;
13880
13881            // Zero reserved fields.
13882            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13883
13884            // Safety:
13885            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13886            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13887            //   envelope_size bytes, there is always sufficient room.
13888            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::WlanMacRole, D>(
13889            self.role.as_ref().map(<fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::ValueTypeMarker>::borrow),
13890            encoder, offset + cur_offset, depth
13891        )?;
13892
13893            _prev_end_offset = cur_offset + envelope_size;
13894            if 3 > max_ordinal {
13895                return Ok(());
13896            }
13897
13898            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13899            // are envelope_size bytes.
13900            let cur_offset: usize = (3 - 1) * envelope_size;
13901
13902            // Zero reserved fields.
13903            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13904
13905            // Safety:
13906            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13907            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13908            //   envelope_size bytes, there is always sufficient room.
13909            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<BandCapability, 16>, D>(
13910            self.band_caps.as_ref().map(<fidl::encoding::Vector<BandCapability, 16> as fidl::encoding::ValueTypeMarker>::borrow),
13911            encoder, offset + cur_offset, depth
13912        )?;
13913
13914            _prev_end_offset = cur_offset + envelope_size;
13915
13916            Ok(())
13917        }
13918    }
13919
13920    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13921        for WlanFullmacImplQueryResponse
13922    {
13923        #[inline(always)]
13924        fn new_empty() -> Self {
13925            Self::default()
13926        }
13927
13928        unsafe fn decode(
13929            &mut self,
13930            decoder: &mut fidl::encoding::Decoder<'_, D>,
13931            offset: usize,
13932            mut depth: fidl::encoding::Depth,
13933        ) -> fidl::Result<()> {
13934            decoder.debug_check_bounds::<Self>(offset);
13935            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13936                None => return Err(fidl::Error::NotNullable),
13937                Some(len) => len,
13938            };
13939            // Calling decoder.out_of_line_offset(0) is not allowed.
13940            if len == 0 {
13941                return Ok(());
13942            };
13943            depth.increment()?;
13944            let envelope_size = 8;
13945            let bytes_len = len * envelope_size;
13946            let offset = decoder.out_of_line_offset(bytes_len)?;
13947            // Decode the envelope for each type.
13948            let mut _next_ordinal_to_read = 0;
13949            let mut next_offset = offset;
13950            let end_offset = offset + bytes_len;
13951            _next_ordinal_to_read += 1;
13952            if next_offset >= end_offset {
13953                return Ok(());
13954            }
13955
13956            // Decode unknown envelopes for gaps in ordinals.
13957            while _next_ordinal_to_read < 1 {
13958                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13959                _next_ordinal_to_read += 1;
13960                next_offset += envelope_size;
13961            }
13962
13963            let next_out_of_line = decoder.next_out_of_line();
13964            let handles_before = decoder.remaining_handles();
13965            if let Some((inlined, num_bytes, num_handles)) =
13966                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13967            {
13968                let member_inline_size =
13969                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
13970                        decoder.context,
13971                    );
13972                if inlined != (member_inline_size <= 4) {
13973                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13974                }
13975                let inner_offset;
13976                let mut inner_depth = depth.clone();
13977                if inlined {
13978                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13979                    inner_offset = next_offset;
13980                } else {
13981                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13982                    inner_depth.increment()?;
13983                }
13984                let val_ref = self
13985                    .sta_addr
13986                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
13987                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
13988                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13989                {
13990                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13991                }
13992                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13993                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13994                }
13995            }
13996
13997            next_offset += envelope_size;
13998            _next_ordinal_to_read += 1;
13999            if next_offset >= end_offset {
14000                return Ok(());
14001            }
14002
14003            // Decode unknown envelopes for gaps in ordinals.
14004            while _next_ordinal_to_read < 2 {
14005                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14006                _next_ordinal_to_read += 1;
14007                next_offset += envelope_size;
14008            }
14009
14010            let next_out_of_line = decoder.next_out_of_line();
14011            let handles_before = decoder.remaining_handles();
14012            if let Some((inlined, num_bytes, num_handles)) =
14013                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14014            {
14015                let member_inline_size = <fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14016                if inlined != (member_inline_size <= 4) {
14017                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14018                }
14019                let inner_offset;
14020                let mut inner_depth = depth.clone();
14021                if inlined {
14022                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14023                    inner_offset = next_offset;
14024                } else {
14025                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14026                    inner_depth.increment()?;
14027                }
14028                let val_ref = self.role.get_or_insert_with(|| {
14029                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanMacRole, D)
14030                });
14031                fidl::decode!(
14032                    fidl_fuchsia_wlan_common__common::WlanMacRole,
14033                    D,
14034                    val_ref,
14035                    decoder,
14036                    inner_offset,
14037                    inner_depth
14038                )?;
14039                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14040                {
14041                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14042                }
14043                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14044                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14045                }
14046            }
14047
14048            next_offset += envelope_size;
14049            _next_ordinal_to_read += 1;
14050            if next_offset >= end_offset {
14051                return Ok(());
14052            }
14053
14054            // Decode unknown envelopes for gaps in ordinals.
14055            while _next_ordinal_to_read < 3 {
14056                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14057                _next_ordinal_to_read += 1;
14058                next_offset += envelope_size;
14059            }
14060
14061            let next_out_of_line = decoder.next_out_of_line();
14062            let handles_before = decoder.remaining_handles();
14063            if let Some((inlined, num_bytes, num_handles)) =
14064                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14065            {
14066                let member_inline_size = <fidl::encoding::Vector<BandCapability, 16> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14067                if inlined != (member_inline_size <= 4) {
14068                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14069                }
14070                let inner_offset;
14071                let mut inner_depth = depth.clone();
14072                if inlined {
14073                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14074                    inner_offset = next_offset;
14075                } else {
14076                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14077                    inner_depth.increment()?;
14078                }
14079                let val_ref = self.band_caps.get_or_insert_with(
14080                    || fidl::new_empty!(fidl::encoding::Vector<BandCapability, 16>, D),
14081                );
14082                fidl::decode!(fidl::encoding::Vector<BandCapability, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
14083                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14084                {
14085                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14086                }
14087                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14088                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14089                }
14090            }
14091
14092            next_offset += envelope_size;
14093
14094            // Decode the remaining unknown envelopes.
14095            while next_offset < end_offset {
14096                _next_ordinal_to_read += 1;
14097                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14098                next_offset += envelope_size;
14099            }
14100
14101            Ok(())
14102        }
14103    }
14104}