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
1205pub mod wlan_fullmac_impl__ordinals {
1206    pub const INIT: u64 = 0x593dfb6cb3f0f1aa;
1207    pub const QUERY: u64 = 0x28ac65f9da3941d4;
1208    pub const QUERY_SECURITY_SUPPORT: u64 = 0x11cf3fa6eeb93f84;
1209    pub const QUERY_SPECTRUM_MANAGEMENT_SUPPORT: u64 = 0x22ae7551d855b83a;
1210    pub const QUERY_TELEMETRY_SUPPORT: u64 = 0x4561479ca560827f;
1211    pub const START_SCAN: u64 = 0x26c17bf595aa161c;
1212    pub const CONNECT: u64 = 0x19eb0322efb07a76;
1213    pub const RECONNECT: u64 = 0x474084c4ef19ee71;
1214    pub const ROAM: u64 = 0x1e35dcc98b124b64;
1215    pub const AUTH_RESP: u64 = 0x5f7ea24b44a4aaeb;
1216    pub const DEAUTH: u64 = 0x112786eccbf12f37;
1217    pub const ASSOC_RESP: u64 = 0x5022ce6b8eefec2f;
1218    pub const DISASSOC: u64 = 0x9c0fc4e8de53e01;
1219    pub const START_BSS: u64 = 0x6922644d6b1d341d;
1220    pub const STOP_BSS: u64 = 0x5aeb9b72e7575268;
1221    pub const SET_KEYS: u64 = 0x20f46b1e039f0985;
1222    pub const EAPOL_TX: u64 = 0x529a2d90fd4c8177;
1223    pub const GET_IFACE_STATS: u64 = 0x505563776ef0392f;
1224    pub const GET_IFACE_HISTOGRAM_STATS: u64 = 0x503d586f30ccf2cd;
1225    pub const SAE_HANDSHAKE_RESP: u64 = 0x72cd3a31ae5a54f6;
1226    pub const SAE_FRAME_TX: u64 = 0x4715ad5dc5a6340f;
1227    pub const WMM_STATUS_REQ: u64 = 0x635ecef3beb7a059;
1228    pub const ON_LINK_STATE_CHANGED: u64 = 0x4d896e5b68e488d7;
1229}
1230
1231pub mod wlan_fullmac_impl_ifc_ordinals {
1232    pub const ON_SCAN_RESULT: u64 = 0x29aa81dc570f7a3e;
1233    pub const ON_SCAN_END: u64 = 0x7cd8aff80d27073c;
1234    pub const CONNECT_CONF: u64 = 0x3c22c6d80b2a2759;
1235    pub const ROAM_CONF: u64 = 0x368b2a5b903b3f7b;
1236    pub const ROAM_START_IND: u64 = 0x23e1d9368935e7e4;
1237    pub const ROAM_RESULT_IND: u64 = 0x7081c1b1ceea4914;
1238    pub const AUTH_IND: u64 = 0x270e1f8889650d0b;
1239    pub const DEAUTH_CONF: u64 = 0x2c94b0d7258111b7;
1240    pub const DEAUTH_IND: u64 = 0x26cd27cdadd8dbaf;
1241    pub const ASSOC_IND: u64 = 0x3e44529e3dc179ce;
1242    pub const DISASSOC_CONF: u64 = 0x7c713bcd58a76cb3;
1243    pub const DISASSOC_IND: u64 = 0x6667b381b7f3990f;
1244    pub const START_CONF: u64 = 0x3e9b9641f3ddc7fc;
1245    pub const STOP_CONF: u64 = 0x320a5ff227a4e9df;
1246    pub const EAPOL_CONF: u64 = 0x77364db9cc3970ec;
1247    pub const ON_CHANNEL_SWITCH: u64 = 0x21db0b8f71cae647;
1248    pub const SIGNAL_REPORT: u64 = 0x79679fa8789c3d9f;
1249    pub const EAPOL_IND: u64 = 0x3de8ec1eda10d1d0;
1250    pub const ON_PMK_AVAILABLE: u64 = 0x5cedd8d9be28a17e;
1251    pub const SAE_HANDSHAKE_IND: u64 = 0x4f3d53885503a1d8;
1252    pub const SAE_FRAME_RX: u64 = 0x51650906857ed4d4;
1253    pub const ON_WMM_STATUS_RESP: u64 = 0x6823a88bf3ba8b2a;
1254}
1255
1256mod internal {
1257    use super::*;
1258    unsafe impl fidl::encoding::TypeMarker for EapolTxResult {
1259        type Owned = Self;
1260
1261        #[inline(always)]
1262        fn inline_align(_context: fidl::encoding::Context) -> usize {
1263            std::mem::align_of::<u8>()
1264        }
1265
1266        #[inline(always)]
1267        fn inline_size(_context: fidl::encoding::Context) -> usize {
1268            std::mem::size_of::<u8>()
1269        }
1270
1271        #[inline(always)]
1272        fn encode_is_copy() -> bool {
1273            false
1274        }
1275
1276        #[inline(always)]
1277        fn decode_is_copy() -> bool {
1278            false
1279        }
1280    }
1281
1282    impl fidl::encoding::ValueTypeMarker for EapolTxResult {
1283        type Borrowed<'a> = Self;
1284        #[inline(always)]
1285        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1286            *value
1287        }
1288    }
1289
1290    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for EapolTxResult {
1291        #[inline]
1292        unsafe fn encode(
1293            self,
1294            encoder: &mut fidl::encoding::Encoder<'_, D>,
1295            offset: usize,
1296            _depth: fidl::encoding::Depth,
1297        ) -> fidl::Result<()> {
1298            encoder.debug_check_bounds::<Self>(offset);
1299            encoder.write_num(self.into_primitive(), offset);
1300            Ok(())
1301        }
1302    }
1303
1304    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EapolTxResult {
1305        #[inline(always)]
1306        fn new_empty() -> Self {
1307            Self::unknown()
1308        }
1309
1310        #[inline]
1311        unsafe fn decode(
1312            &mut self,
1313            decoder: &mut fidl::encoding::Decoder<'_, D>,
1314            offset: usize,
1315            _depth: fidl::encoding::Depth,
1316        ) -> fidl::Result<()> {
1317            decoder.debug_check_bounds::<Self>(offset);
1318            let prim = decoder.read_num::<u8>(offset);
1319
1320            *self = Self::from_primitive_allow_unknown(prim);
1321            Ok(())
1322        }
1323    }
1324    unsafe impl fidl::encoding::TypeMarker for StartResult {
1325        type Owned = Self;
1326
1327        #[inline(always)]
1328        fn inline_align(_context: fidl::encoding::Context) -> usize {
1329            std::mem::align_of::<u8>()
1330        }
1331
1332        #[inline(always)]
1333        fn inline_size(_context: fidl::encoding::Context) -> usize {
1334            std::mem::size_of::<u8>()
1335        }
1336
1337        #[inline(always)]
1338        fn encode_is_copy() -> bool {
1339            false
1340        }
1341
1342        #[inline(always)]
1343        fn decode_is_copy() -> bool {
1344            false
1345        }
1346    }
1347
1348    impl fidl::encoding::ValueTypeMarker for StartResult {
1349        type Borrowed<'a> = Self;
1350        #[inline(always)]
1351        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1352            *value
1353        }
1354    }
1355
1356    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StartResult {
1357        #[inline]
1358        unsafe fn encode(
1359            self,
1360            encoder: &mut fidl::encoding::Encoder<'_, D>,
1361            offset: usize,
1362            _depth: fidl::encoding::Depth,
1363        ) -> fidl::Result<()> {
1364            encoder.debug_check_bounds::<Self>(offset);
1365            encoder.write_num(self.into_primitive(), offset);
1366            Ok(())
1367        }
1368    }
1369
1370    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartResult {
1371        #[inline(always)]
1372        fn new_empty() -> Self {
1373            Self::unknown()
1374        }
1375
1376        #[inline]
1377        unsafe fn decode(
1378            &mut self,
1379            decoder: &mut fidl::encoding::Decoder<'_, D>,
1380            offset: usize,
1381            _depth: fidl::encoding::Depth,
1382        ) -> fidl::Result<()> {
1383            decoder.debug_check_bounds::<Self>(offset);
1384            let prim = decoder.read_num::<u8>(offset);
1385
1386            *self = Self::from_primitive_allow_unknown(prim);
1387            Ok(())
1388        }
1389    }
1390    unsafe impl fidl::encoding::TypeMarker for StopResult {
1391        type Owned = Self;
1392
1393        #[inline(always)]
1394        fn inline_align(_context: fidl::encoding::Context) -> usize {
1395            std::mem::align_of::<u8>()
1396        }
1397
1398        #[inline(always)]
1399        fn inline_size(_context: fidl::encoding::Context) -> usize {
1400            std::mem::size_of::<u8>()
1401        }
1402
1403        #[inline(always)]
1404        fn encode_is_copy() -> bool {
1405            false
1406        }
1407
1408        #[inline(always)]
1409        fn decode_is_copy() -> bool {
1410            false
1411        }
1412    }
1413
1414    impl fidl::encoding::ValueTypeMarker for StopResult {
1415        type Borrowed<'a> = Self;
1416        #[inline(always)]
1417        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1418            *value
1419        }
1420    }
1421
1422    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StopResult {
1423        #[inline]
1424        unsafe fn encode(
1425            self,
1426            encoder: &mut fidl::encoding::Encoder<'_, D>,
1427            offset: usize,
1428            _depth: fidl::encoding::Depth,
1429        ) -> fidl::Result<()> {
1430            encoder.debug_check_bounds::<Self>(offset);
1431            encoder.write_num(self.into_primitive(), offset);
1432            Ok(())
1433        }
1434    }
1435
1436    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopResult {
1437        #[inline(always)]
1438        fn new_empty() -> Self {
1439            Self::unknown()
1440        }
1441
1442        #[inline]
1443        unsafe fn decode(
1444            &mut self,
1445            decoder: &mut fidl::encoding::Decoder<'_, D>,
1446            offset: usize,
1447            _depth: fidl::encoding::Depth,
1448        ) -> fidl::Result<()> {
1449            decoder.debug_check_bounds::<Self>(offset);
1450            let prim = decoder.read_num::<u8>(offset);
1451
1452            *self = Self::from_primitive_allow_unknown(prim);
1453            Ok(())
1454        }
1455    }
1456    unsafe impl fidl::encoding::TypeMarker for WlanAssocResult {
1457        type Owned = Self;
1458
1459        #[inline(always)]
1460        fn inline_align(_context: fidl::encoding::Context) -> usize {
1461            std::mem::align_of::<u8>()
1462        }
1463
1464        #[inline(always)]
1465        fn inline_size(_context: fidl::encoding::Context) -> usize {
1466            std::mem::size_of::<u8>()
1467        }
1468
1469        #[inline(always)]
1470        fn encode_is_copy() -> bool {
1471            false
1472        }
1473
1474        #[inline(always)]
1475        fn decode_is_copy() -> bool {
1476            false
1477        }
1478    }
1479
1480    impl fidl::encoding::ValueTypeMarker for WlanAssocResult {
1481        type Borrowed<'a> = Self;
1482        #[inline(always)]
1483        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1484            *value
1485        }
1486    }
1487
1488    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1489        for WlanAssocResult
1490    {
1491        #[inline]
1492        unsafe fn encode(
1493            self,
1494            encoder: &mut fidl::encoding::Encoder<'_, D>,
1495            offset: usize,
1496            _depth: fidl::encoding::Depth,
1497        ) -> fidl::Result<()> {
1498            encoder.debug_check_bounds::<Self>(offset);
1499            encoder.write_num(self.into_primitive(), offset);
1500            Ok(())
1501        }
1502    }
1503
1504    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanAssocResult {
1505        #[inline(always)]
1506        fn new_empty() -> Self {
1507            Self::unknown()
1508        }
1509
1510        #[inline]
1511        unsafe fn decode(
1512            &mut self,
1513            decoder: &mut fidl::encoding::Decoder<'_, D>,
1514            offset: usize,
1515            _depth: fidl::encoding::Depth,
1516        ) -> fidl::Result<()> {
1517            decoder.debug_check_bounds::<Self>(offset);
1518            let prim = decoder.read_num::<u8>(offset);
1519
1520            *self = Self::from_primitive_allow_unknown(prim);
1521            Ok(())
1522        }
1523    }
1524    unsafe impl fidl::encoding::TypeMarker for WlanAuthResult {
1525        type Owned = Self;
1526
1527        #[inline(always)]
1528        fn inline_align(_context: fidl::encoding::Context) -> usize {
1529            std::mem::align_of::<u8>()
1530        }
1531
1532        #[inline(always)]
1533        fn inline_size(_context: fidl::encoding::Context) -> usize {
1534            std::mem::size_of::<u8>()
1535        }
1536
1537        #[inline(always)]
1538        fn encode_is_copy() -> bool {
1539            false
1540        }
1541
1542        #[inline(always)]
1543        fn decode_is_copy() -> bool {
1544            false
1545        }
1546    }
1547
1548    impl fidl::encoding::ValueTypeMarker for WlanAuthResult {
1549        type Borrowed<'a> = Self;
1550        #[inline(always)]
1551        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1552            *value
1553        }
1554    }
1555
1556    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanAuthResult {
1557        #[inline]
1558        unsafe fn encode(
1559            self,
1560            encoder: &mut fidl::encoding::Encoder<'_, D>,
1561            offset: usize,
1562            _depth: fidl::encoding::Depth,
1563        ) -> fidl::Result<()> {
1564            encoder.debug_check_bounds::<Self>(offset);
1565            encoder.write_num(self.into_primitive(), offset);
1566            Ok(())
1567        }
1568    }
1569
1570    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanAuthResult {
1571        #[inline(always)]
1572        fn new_empty() -> Self {
1573            Self::unknown()
1574        }
1575
1576        #[inline]
1577        unsafe fn decode(
1578            &mut self,
1579            decoder: &mut fidl::encoding::Decoder<'_, D>,
1580            offset: usize,
1581            _depth: fidl::encoding::Depth,
1582        ) -> fidl::Result<()> {
1583            decoder.debug_check_bounds::<Self>(offset);
1584            let prim = decoder.read_num::<u8>(offset);
1585
1586            *self = Self::from_primitive_allow_unknown(prim);
1587            Ok(())
1588        }
1589    }
1590    unsafe impl fidl::encoding::TypeMarker for WlanAuthType {
1591        type Owned = Self;
1592
1593        #[inline(always)]
1594        fn inline_align(_context: fidl::encoding::Context) -> usize {
1595            std::mem::align_of::<u8>()
1596        }
1597
1598        #[inline(always)]
1599        fn inline_size(_context: fidl::encoding::Context) -> usize {
1600            std::mem::size_of::<u8>()
1601        }
1602
1603        #[inline(always)]
1604        fn encode_is_copy() -> bool {
1605            false
1606        }
1607
1608        #[inline(always)]
1609        fn decode_is_copy() -> bool {
1610            false
1611        }
1612    }
1613
1614    impl fidl::encoding::ValueTypeMarker for WlanAuthType {
1615        type Borrowed<'a> = Self;
1616        #[inline(always)]
1617        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1618            *value
1619        }
1620    }
1621
1622    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanAuthType {
1623        #[inline]
1624        unsafe fn encode(
1625            self,
1626            encoder: &mut fidl::encoding::Encoder<'_, D>,
1627            offset: usize,
1628            _depth: fidl::encoding::Depth,
1629        ) -> fidl::Result<()> {
1630            encoder.debug_check_bounds::<Self>(offset);
1631            encoder.write_num(self.into_primitive(), offset);
1632            Ok(())
1633        }
1634    }
1635
1636    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanAuthType {
1637        #[inline(always)]
1638        fn new_empty() -> Self {
1639            Self::unknown()
1640        }
1641
1642        #[inline]
1643        unsafe fn decode(
1644            &mut self,
1645            decoder: &mut fidl::encoding::Decoder<'_, D>,
1646            offset: usize,
1647            _depth: fidl::encoding::Depth,
1648        ) -> fidl::Result<()> {
1649            decoder.debug_check_bounds::<Self>(offset);
1650            let prim = decoder.read_num::<u8>(offset);
1651
1652            *self = Self::from_primitive_allow_unknown(prim);
1653            Ok(())
1654        }
1655    }
1656    unsafe impl fidl::encoding::TypeMarker for WlanScanResult {
1657        type Owned = Self;
1658
1659        #[inline(always)]
1660        fn inline_align(_context: fidl::encoding::Context) -> usize {
1661            std::mem::align_of::<u8>()
1662        }
1663
1664        #[inline(always)]
1665        fn inline_size(_context: fidl::encoding::Context) -> usize {
1666            std::mem::size_of::<u8>()
1667        }
1668
1669        #[inline(always)]
1670        fn encode_is_copy() -> bool {
1671            false
1672        }
1673
1674        #[inline(always)]
1675        fn decode_is_copy() -> bool {
1676            false
1677        }
1678    }
1679
1680    impl fidl::encoding::ValueTypeMarker for WlanScanResult {
1681        type Borrowed<'a> = Self;
1682        #[inline(always)]
1683        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1684            *value
1685        }
1686    }
1687
1688    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanScanResult {
1689        #[inline]
1690        unsafe fn encode(
1691            self,
1692            encoder: &mut fidl::encoding::Encoder<'_, D>,
1693            offset: usize,
1694            _depth: fidl::encoding::Depth,
1695        ) -> fidl::Result<()> {
1696            encoder.debug_check_bounds::<Self>(offset);
1697            encoder.write_num(self.into_primitive(), offset);
1698            Ok(())
1699        }
1700    }
1701
1702    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanScanResult {
1703        #[inline(always)]
1704        fn new_empty() -> Self {
1705            Self::unknown()
1706        }
1707
1708        #[inline]
1709        unsafe fn decode(
1710            &mut self,
1711            decoder: &mut fidl::encoding::Decoder<'_, D>,
1712            offset: usize,
1713            _depth: fidl::encoding::Depth,
1714        ) -> fidl::Result<()> {
1715            decoder.debug_check_bounds::<Self>(offset);
1716            let prim = decoder.read_num::<u8>(offset);
1717
1718            *self = Self::from_primitive_allow_unknown(prim);
1719            Ok(())
1720        }
1721    }
1722    unsafe impl fidl::encoding::TypeMarker for WlanScanType {
1723        type Owned = Self;
1724
1725        #[inline(always)]
1726        fn inline_align(_context: fidl::encoding::Context) -> usize {
1727            std::mem::align_of::<u8>()
1728        }
1729
1730        #[inline(always)]
1731        fn inline_size(_context: fidl::encoding::Context) -> usize {
1732            std::mem::size_of::<u8>()
1733        }
1734
1735        #[inline(always)]
1736        fn encode_is_copy() -> bool {
1737            false
1738        }
1739
1740        #[inline(always)]
1741        fn decode_is_copy() -> bool {
1742            false
1743        }
1744    }
1745
1746    impl fidl::encoding::ValueTypeMarker for WlanScanType {
1747        type Borrowed<'a> = Self;
1748        #[inline(always)]
1749        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1750            *value
1751        }
1752    }
1753
1754    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WlanScanType {
1755        #[inline]
1756        unsafe fn encode(
1757            self,
1758            encoder: &mut fidl::encoding::Encoder<'_, D>,
1759            offset: usize,
1760            _depth: fidl::encoding::Depth,
1761        ) -> fidl::Result<()> {
1762            encoder.debug_check_bounds::<Self>(offset);
1763            encoder.write_num(self.into_primitive(), offset);
1764            Ok(())
1765        }
1766    }
1767
1768    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanScanType {
1769        #[inline(always)]
1770        fn new_empty() -> Self {
1771            Self::unknown()
1772        }
1773
1774        #[inline]
1775        unsafe fn decode(
1776            &mut self,
1777            decoder: &mut fidl::encoding::Decoder<'_, D>,
1778            offset: usize,
1779            _depth: fidl::encoding::Depth,
1780        ) -> fidl::Result<()> {
1781            decoder.debug_check_bounds::<Self>(offset);
1782            let prim = decoder.read_num::<u8>(offset);
1783
1784            *self = Self::from_primitive_allow_unknown(prim);
1785            Ok(())
1786        }
1787    }
1788
1789    impl fidl::encoding::ValueTypeMarker for WlanFullmacChannelSwitchInfo {
1790        type Borrowed<'a> = &'a Self;
1791        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1792            value
1793        }
1794    }
1795
1796    unsafe impl fidl::encoding::TypeMarker for WlanFullmacChannelSwitchInfo {
1797        type Owned = Self;
1798
1799        #[inline(always)]
1800        fn inline_align(_context: fidl::encoding::Context) -> usize {
1801            1
1802        }
1803
1804        #[inline(always)]
1805        fn inline_size(_context: fidl::encoding::Context) -> usize {
1806            1
1807        }
1808        #[inline(always)]
1809        fn encode_is_copy() -> bool {
1810            true
1811        }
1812
1813        #[inline(always)]
1814        fn decode_is_copy() -> bool {
1815            true
1816        }
1817    }
1818
1819    unsafe impl<D: fidl::encoding::ResourceDialect>
1820        fidl::encoding::Encode<WlanFullmacChannelSwitchInfo, D> for &WlanFullmacChannelSwitchInfo
1821    {
1822        #[inline]
1823        unsafe fn encode(
1824            self,
1825            encoder: &mut fidl::encoding::Encoder<'_, D>,
1826            offset: usize,
1827            _depth: fidl::encoding::Depth,
1828        ) -> fidl::Result<()> {
1829            encoder.debug_check_bounds::<WlanFullmacChannelSwitchInfo>(offset);
1830            unsafe {
1831                // Copy the object into the buffer.
1832                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1833                (buf_ptr as *mut WlanFullmacChannelSwitchInfo)
1834                    .write_unaligned((self as *const WlanFullmacChannelSwitchInfo).read());
1835                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1836                // done second because the memcpy will write garbage to these bytes.
1837            }
1838            Ok(())
1839        }
1840    }
1841    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
1842        fidl::encoding::Encode<WlanFullmacChannelSwitchInfo, D> for (T0,)
1843    {
1844        #[inline]
1845        unsafe fn encode(
1846            self,
1847            encoder: &mut fidl::encoding::Encoder<'_, D>,
1848            offset: usize,
1849            depth: fidl::encoding::Depth,
1850        ) -> fidl::Result<()> {
1851            encoder.debug_check_bounds::<WlanFullmacChannelSwitchInfo>(offset);
1852            // Zero out padding regions. There's no need to apply masks
1853            // because the unmasked parts will be overwritten by fields.
1854            // Write the fields.
1855            self.0.encode(encoder, offset + 0, depth)?;
1856            Ok(())
1857        }
1858    }
1859
1860    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1861        for WlanFullmacChannelSwitchInfo
1862    {
1863        #[inline(always)]
1864        fn new_empty() -> Self {
1865            Self { new_channel: fidl::new_empty!(u8, D) }
1866        }
1867
1868        #[inline]
1869        unsafe fn decode(
1870            &mut self,
1871            decoder: &mut fidl::encoding::Decoder<'_, D>,
1872            offset: usize,
1873            _depth: fidl::encoding::Depth,
1874        ) -> fidl::Result<()> {
1875            decoder.debug_check_bounds::<Self>(offset);
1876            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1877            // Verify that padding bytes are zero.
1878            // Copy from the buffer into the object.
1879            unsafe {
1880                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
1881            }
1882            Ok(())
1883        }
1884    }
1885
1886    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnChannelSwitchRequest {
1887        type Borrowed<'a> = &'a Self;
1888        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1889            value
1890        }
1891    }
1892
1893    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnChannelSwitchRequest {
1894        type Owned = Self;
1895
1896        #[inline(always)]
1897        fn inline_align(_context: fidl::encoding::Context) -> usize {
1898            1
1899        }
1900
1901        #[inline(always)]
1902        fn inline_size(_context: fidl::encoding::Context) -> usize {
1903            1
1904        }
1905        #[inline(always)]
1906        fn encode_is_copy() -> bool {
1907            true
1908        }
1909
1910        #[inline(always)]
1911        fn decode_is_copy() -> bool {
1912            true
1913        }
1914    }
1915
1916    unsafe impl<D: fidl::encoding::ResourceDialect>
1917        fidl::encoding::Encode<WlanFullmacImplIfcOnChannelSwitchRequest, D>
1918        for &WlanFullmacImplIfcOnChannelSwitchRequest
1919    {
1920        #[inline]
1921        unsafe fn encode(
1922            self,
1923            encoder: &mut fidl::encoding::Encoder<'_, D>,
1924            offset: usize,
1925            _depth: fidl::encoding::Depth,
1926        ) -> fidl::Result<()> {
1927            encoder.debug_check_bounds::<WlanFullmacImplIfcOnChannelSwitchRequest>(offset);
1928            unsafe {
1929                // Copy the object into the buffer.
1930                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1931                (buf_ptr as *mut WlanFullmacImplIfcOnChannelSwitchRequest).write_unaligned(
1932                    (self as *const WlanFullmacImplIfcOnChannelSwitchRequest).read(),
1933                );
1934                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1935                // done second because the memcpy will write garbage to these bytes.
1936            }
1937            Ok(())
1938        }
1939    }
1940    unsafe impl<
1941            D: fidl::encoding::ResourceDialect,
1942            T0: fidl::encoding::Encode<WlanFullmacChannelSwitchInfo, D>,
1943        > fidl::encoding::Encode<WlanFullmacImplIfcOnChannelSwitchRequest, D> for (T0,)
1944    {
1945        #[inline]
1946        unsafe fn encode(
1947            self,
1948            encoder: &mut fidl::encoding::Encoder<'_, D>,
1949            offset: usize,
1950            depth: fidl::encoding::Depth,
1951        ) -> fidl::Result<()> {
1952            encoder.debug_check_bounds::<WlanFullmacImplIfcOnChannelSwitchRequest>(offset);
1953            // Zero out padding regions. There's no need to apply masks
1954            // because the unmasked parts will be overwritten by fields.
1955            // Write the fields.
1956            self.0.encode(encoder, offset + 0, depth)?;
1957            Ok(())
1958        }
1959    }
1960
1961    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1962        for WlanFullmacImplIfcOnChannelSwitchRequest
1963    {
1964        #[inline(always)]
1965        fn new_empty() -> Self {
1966            Self { ind: fidl::new_empty!(WlanFullmacChannelSwitchInfo, D) }
1967        }
1968
1969        #[inline]
1970        unsafe fn decode(
1971            &mut self,
1972            decoder: &mut fidl::encoding::Decoder<'_, D>,
1973            offset: usize,
1974            _depth: fidl::encoding::Depth,
1975        ) -> fidl::Result<()> {
1976            decoder.debug_check_bounds::<Self>(offset);
1977            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1978            // Verify that padding bytes are zero.
1979            // Copy from the buffer into the object.
1980            unsafe {
1981                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
1982            }
1983            Ok(())
1984        }
1985    }
1986
1987    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnWmmStatusRespRequest {
1988        type Borrowed<'a> = &'a Self;
1989        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1990            value
1991        }
1992    }
1993
1994    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnWmmStatusRespRequest {
1995        type Owned = Self;
1996
1997        #[inline(always)]
1998        fn inline_align(_context: fidl::encoding::Context) -> usize {
1999            4
2000        }
2001
2002        #[inline(always)]
2003        fn inline_size(_context: fidl::encoding::Context) -> usize {
2004            40
2005        }
2006    }
2007
2008    unsafe impl<D: fidl::encoding::ResourceDialect>
2009        fidl::encoding::Encode<WlanFullmacImplIfcOnWmmStatusRespRequest, D>
2010        for &WlanFullmacImplIfcOnWmmStatusRespRequest
2011    {
2012        #[inline]
2013        unsafe fn encode(
2014            self,
2015            encoder: &mut fidl::encoding::Encoder<'_, D>,
2016            offset: usize,
2017            _depth: fidl::encoding::Depth,
2018        ) -> fidl::Result<()> {
2019            encoder.debug_check_bounds::<WlanFullmacImplIfcOnWmmStatusRespRequest>(offset);
2020            // Delegate to tuple encoding.
2021            fidl::encoding::Encode::<WlanFullmacImplIfcOnWmmStatusRespRequest, D>::encode(
2022                (
2023                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
2024                    <fidl_fuchsia_wlan_common__common::WlanWmmParameters as fidl::encoding::ValueTypeMarker>::borrow(&self.wmm_params),
2025                ),
2026                encoder, offset, _depth
2027            )
2028        }
2029    }
2030    unsafe impl<
2031            D: fidl::encoding::ResourceDialect,
2032            T0: fidl::encoding::Encode<i32, D>,
2033            T1: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::WlanWmmParameters, D>,
2034        > fidl::encoding::Encode<WlanFullmacImplIfcOnWmmStatusRespRequest, D> for (T0, T1)
2035    {
2036        #[inline]
2037        unsafe fn encode(
2038            self,
2039            encoder: &mut fidl::encoding::Encoder<'_, D>,
2040            offset: usize,
2041            depth: fidl::encoding::Depth,
2042        ) -> fidl::Result<()> {
2043            encoder.debug_check_bounds::<WlanFullmacImplIfcOnWmmStatusRespRequest>(offset);
2044            // Zero out padding regions. There's no need to apply masks
2045            // because the unmasked parts will be overwritten by fields.
2046            unsafe {
2047                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(36);
2048                (ptr as *mut u32).write_unaligned(0);
2049            }
2050            // Write the fields.
2051            self.0.encode(encoder, offset + 0, depth)?;
2052            self.1.encode(encoder, offset + 4, depth)?;
2053            Ok(())
2054        }
2055    }
2056
2057    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2058        for WlanFullmacImplIfcOnWmmStatusRespRequest
2059    {
2060        #[inline(always)]
2061        fn new_empty() -> Self {
2062            Self {
2063                status: fidl::new_empty!(i32, D),
2064                wmm_params: fidl::new_empty!(
2065                    fidl_fuchsia_wlan_common__common::WlanWmmParameters,
2066                    D
2067                ),
2068            }
2069        }
2070
2071        #[inline]
2072        unsafe fn decode(
2073            &mut self,
2074            decoder: &mut fidl::encoding::Decoder<'_, D>,
2075            offset: usize,
2076            _depth: fidl::encoding::Depth,
2077        ) -> fidl::Result<()> {
2078            decoder.debug_check_bounds::<Self>(offset);
2079            // Verify that padding bytes are zero.
2080            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(36) };
2081            let padval = unsafe { (ptr as *const u32).read_unaligned() };
2082            let mask = 0xffff0000u32;
2083            let maskedval = padval & mask;
2084            if maskedval != 0 {
2085                return Err(fidl::Error::NonZeroPadding {
2086                    padding_start: offset + 36 + ((mask as u64).trailing_zeros() / 8) as usize,
2087                });
2088            }
2089            fidl::decode!(i32, D, &mut self.status, decoder, offset + 0, _depth)?;
2090            fidl::decode!(
2091                fidl_fuchsia_wlan_common__common::WlanWmmParameters,
2092                D,
2093                &mut self.wmm_params,
2094                decoder,
2095                offset + 4,
2096                _depth
2097            )?;
2098            Ok(())
2099        }
2100    }
2101
2102    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcSaeFrameRxRequest {
2103        type Borrowed<'a> = &'a Self;
2104        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2105            value
2106        }
2107    }
2108
2109    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcSaeFrameRxRequest {
2110        type Owned = Self;
2111
2112        #[inline(always)]
2113        fn inline_align(_context: fidl::encoding::Context) -> usize {
2114            8
2115        }
2116
2117        #[inline(always)]
2118        fn inline_size(_context: fidl::encoding::Context) -> usize {
2119            16
2120        }
2121    }
2122
2123    unsafe impl<D: fidl::encoding::ResourceDialect>
2124        fidl::encoding::Encode<WlanFullmacImplIfcSaeFrameRxRequest, D>
2125        for &WlanFullmacImplIfcSaeFrameRxRequest
2126    {
2127        #[inline]
2128        unsafe fn encode(
2129            self,
2130            encoder: &mut fidl::encoding::Encoder<'_, D>,
2131            offset: usize,
2132            _depth: fidl::encoding::Depth,
2133        ) -> fidl::Result<()> {
2134            encoder.debug_check_bounds::<WlanFullmacImplIfcSaeFrameRxRequest>(offset);
2135            // Delegate to tuple encoding.
2136            fidl::encoding::Encode::<WlanFullmacImplIfcSaeFrameRxRequest, D>::encode(
2137                (<SaeFrame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
2138                encoder,
2139                offset,
2140                _depth,
2141            )
2142        }
2143    }
2144    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SaeFrame, D>>
2145        fidl::encoding::Encode<WlanFullmacImplIfcSaeFrameRxRequest, D> for (T0,)
2146    {
2147        #[inline]
2148        unsafe fn encode(
2149            self,
2150            encoder: &mut fidl::encoding::Encoder<'_, D>,
2151            offset: usize,
2152            depth: fidl::encoding::Depth,
2153        ) -> fidl::Result<()> {
2154            encoder.debug_check_bounds::<WlanFullmacImplIfcSaeFrameRxRequest>(offset);
2155            // Zero out padding regions. There's no need to apply masks
2156            // because the unmasked parts will be overwritten by fields.
2157            // Write the fields.
2158            self.0.encode(encoder, offset + 0, depth)?;
2159            Ok(())
2160        }
2161    }
2162
2163    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2164        for WlanFullmacImplIfcSaeFrameRxRequest
2165    {
2166        #[inline(always)]
2167        fn new_empty() -> Self {
2168            Self { frame: fidl::new_empty!(SaeFrame, D) }
2169        }
2170
2171        #[inline]
2172        unsafe fn decode(
2173            &mut self,
2174            decoder: &mut fidl::encoding::Decoder<'_, D>,
2175            offset: usize,
2176            _depth: fidl::encoding::Depth,
2177        ) -> fidl::Result<()> {
2178            decoder.debug_check_bounds::<Self>(offset);
2179            // Verify that padding bytes are zero.
2180            fidl::decode!(SaeFrame, D, &mut self.frame, decoder, offset + 0, _depth)?;
2181            Ok(())
2182        }
2183    }
2184
2185    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcSignalReportRequest {
2186        type Borrowed<'a> = &'a Self;
2187        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2188            value
2189        }
2190    }
2191
2192    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcSignalReportRequest {
2193        type Owned = Self;
2194
2195        #[inline(always)]
2196        fn inline_align(_context: fidl::encoding::Context) -> usize {
2197            1
2198        }
2199
2200        #[inline(always)]
2201        fn inline_size(_context: fidl::encoding::Context) -> usize {
2202            2
2203        }
2204        #[inline(always)]
2205        fn encode_is_copy() -> bool {
2206            true
2207        }
2208
2209        #[inline(always)]
2210        fn decode_is_copy() -> bool {
2211            true
2212        }
2213    }
2214
2215    unsafe impl<D: fidl::encoding::ResourceDialect>
2216        fidl::encoding::Encode<WlanFullmacImplIfcSignalReportRequest, D>
2217        for &WlanFullmacImplIfcSignalReportRequest
2218    {
2219        #[inline]
2220        unsafe fn encode(
2221            self,
2222            encoder: &mut fidl::encoding::Encoder<'_, D>,
2223            offset: usize,
2224            _depth: fidl::encoding::Depth,
2225        ) -> fidl::Result<()> {
2226            encoder.debug_check_bounds::<WlanFullmacImplIfcSignalReportRequest>(offset);
2227            unsafe {
2228                // Copy the object into the buffer.
2229                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2230                (buf_ptr as *mut WlanFullmacImplIfcSignalReportRequest)
2231                    .write_unaligned((self as *const WlanFullmacImplIfcSignalReportRequest).read());
2232                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2233                // done second because the memcpy will write garbage to these bytes.
2234            }
2235            Ok(())
2236        }
2237    }
2238    unsafe impl<
2239            D: fidl::encoding::ResourceDialect,
2240            T0: fidl::encoding::Encode<WlanFullmacSignalReportIndication, D>,
2241        > fidl::encoding::Encode<WlanFullmacImplIfcSignalReportRequest, D> for (T0,)
2242    {
2243        #[inline]
2244        unsafe fn encode(
2245            self,
2246            encoder: &mut fidl::encoding::Encoder<'_, D>,
2247            offset: usize,
2248            depth: fidl::encoding::Depth,
2249        ) -> fidl::Result<()> {
2250            encoder.debug_check_bounds::<WlanFullmacImplIfcSignalReportRequest>(offset);
2251            // Zero out padding regions. There's no need to apply masks
2252            // because the unmasked parts will be overwritten by fields.
2253            // Write the fields.
2254            self.0.encode(encoder, offset + 0, depth)?;
2255            Ok(())
2256        }
2257    }
2258
2259    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2260        for WlanFullmacImplIfcSignalReportRequest
2261    {
2262        #[inline(always)]
2263        fn new_empty() -> Self {
2264            Self { ind: fidl::new_empty!(WlanFullmacSignalReportIndication, D) }
2265        }
2266
2267        #[inline]
2268        unsafe fn decode(
2269            &mut self,
2270            decoder: &mut fidl::encoding::Decoder<'_, D>,
2271            offset: usize,
2272            _depth: fidl::encoding::Depth,
2273        ) -> fidl::Result<()> {
2274            decoder.debug_check_bounds::<Self>(offset);
2275            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2276            // Verify that padding bytes are zero.
2277            // Copy from the buffer into the object.
2278            unsafe {
2279                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2280            }
2281            Ok(())
2282        }
2283    }
2284
2285    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSaeFrameTxRequest {
2286        type Borrowed<'a> = &'a Self;
2287        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2288            value
2289        }
2290    }
2291
2292    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSaeFrameTxRequest {
2293        type Owned = Self;
2294
2295        #[inline(always)]
2296        fn inline_align(_context: fidl::encoding::Context) -> usize {
2297            8
2298        }
2299
2300        #[inline(always)]
2301        fn inline_size(_context: fidl::encoding::Context) -> usize {
2302            16
2303        }
2304    }
2305
2306    unsafe impl<D: fidl::encoding::ResourceDialect>
2307        fidl::encoding::Encode<WlanFullmacImplSaeFrameTxRequest, D>
2308        for &WlanFullmacImplSaeFrameTxRequest
2309    {
2310        #[inline]
2311        unsafe fn encode(
2312            self,
2313            encoder: &mut fidl::encoding::Encoder<'_, D>,
2314            offset: usize,
2315            _depth: fidl::encoding::Depth,
2316        ) -> fidl::Result<()> {
2317            encoder.debug_check_bounds::<WlanFullmacImplSaeFrameTxRequest>(offset);
2318            // Delegate to tuple encoding.
2319            fidl::encoding::Encode::<WlanFullmacImplSaeFrameTxRequest, D>::encode(
2320                (<SaeFrame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
2321                encoder,
2322                offset,
2323                _depth,
2324            )
2325        }
2326    }
2327    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SaeFrame, D>>
2328        fidl::encoding::Encode<WlanFullmacImplSaeFrameTxRequest, D> for (T0,)
2329    {
2330        #[inline]
2331        unsafe fn encode(
2332            self,
2333            encoder: &mut fidl::encoding::Encoder<'_, D>,
2334            offset: usize,
2335            depth: fidl::encoding::Depth,
2336        ) -> fidl::Result<()> {
2337            encoder.debug_check_bounds::<WlanFullmacImplSaeFrameTxRequest>(offset);
2338            // Zero out padding regions. There's no need to apply masks
2339            // because the unmasked parts will be overwritten by fields.
2340            // Write the fields.
2341            self.0.encode(encoder, offset + 0, depth)?;
2342            Ok(())
2343        }
2344    }
2345
2346    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2347        for WlanFullmacImplSaeFrameTxRequest
2348    {
2349        #[inline(always)]
2350        fn new_empty() -> Self {
2351            Self { frame: fidl::new_empty!(SaeFrame, D) }
2352        }
2353
2354        #[inline]
2355        unsafe fn decode(
2356            &mut self,
2357            decoder: &mut fidl::encoding::Decoder<'_, D>,
2358            offset: usize,
2359            _depth: fidl::encoding::Depth,
2360        ) -> fidl::Result<()> {
2361            decoder.debug_check_bounds::<Self>(offset);
2362            // Verify that padding bytes are zero.
2363            fidl::decode!(SaeFrame, D, &mut self.frame, decoder, offset + 0, _depth)?;
2364            Ok(())
2365        }
2366    }
2367
2368    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSetKeysResponse {
2369        type Borrowed<'a> = &'a Self;
2370        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2371            value
2372        }
2373    }
2374
2375    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSetKeysResponse {
2376        type Owned = Self;
2377
2378        #[inline(always)]
2379        fn inline_align(_context: fidl::encoding::Context) -> usize {
2380            8
2381        }
2382
2383        #[inline(always)]
2384        fn inline_size(_context: fidl::encoding::Context) -> usize {
2385            16
2386        }
2387    }
2388
2389    unsafe impl<D: fidl::encoding::ResourceDialect>
2390        fidl::encoding::Encode<WlanFullmacImplSetKeysResponse, D>
2391        for &WlanFullmacImplSetKeysResponse
2392    {
2393        #[inline]
2394        unsafe fn encode(
2395            self,
2396            encoder: &mut fidl::encoding::Encoder<'_, D>,
2397            offset: usize,
2398            _depth: fidl::encoding::Depth,
2399        ) -> fidl::Result<()> {
2400            encoder.debug_check_bounds::<WlanFullmacImplSetKeysResponse>(offset);
2401            // Delegate to tuple encoding.
2402            fidl::encoding::Encode::<WlanFullmacImplSetKeysResponse, D>::encode(
2403                (<WlanFullmacSetKeysResp as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
2404                encoder,
2405                offset,
2406                _depth,
2407            )
2408        }
2409    }
2410    unsafe impl<
2411            D: fidl::encoding::ResourceDialect,
2412            T0: fidl::encoding::Encode<WlanFullmacSetKeysResp, D>,
2413        > fidl::encoding::Encode<WlanFullmacImplSetKeysResponse, D> for (T0,)
2414    {
2415        #[inline]
2416        unsafe fn encode(
2417            self,
2418            encoder: &mut fidl::encoding::Encoder<'_, D>,
2419            offset: usize,
2420            depth: fidl::encoding::Depth,
2421        ) -> fidl::Result<()> {
2422            encoder.debug_check_bounds::<WlanFullmacImplSetKeysResponse>(offset);
2423            // Zero out padding regions. There's no need to apply masks
2424            // because the unmasked parts will be overwritten by fields.
2425            // Write the fields.
2426            self.0.encode(encoder, offset + 0, depth)?;
2427            Ok(())
2428        }
2429    }
2430
2431    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2432        for WlanFullmacImplSetKeysResponse
2433    {
2434        #[inline(always)]
2435        fn new_empty() -> Self {
2436            Self { resp: fidl::new_empty!(WlanFullmacSetKeysResp, D) }
2437        }
2438
2439        #[inline]
2440        unsafe fn decode(
2441            &mut self,
2442            decoder: &mut fidl::encoding::Decoder<'_, D>,
2443            offset: usize,
2444            _depth: fidl::encoding::Depth,
2445        ) -> fidl::Result<()> {
2446            decoder.debug_check_bounds::<Self>(offset);
2447            // Verify that padding bytes are zero.
2448            fidl::decode!(WlanFullmacSetKeysResp, D, &mut self.resp, decoder, offset + 0, _depth)?;
2449            Ok(())
2450        }
2451    }
2452
2453    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplGetIfaceHistogramStatsResponse {
2454        type Borrowed<'a> = &'a Self;
2455        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2456            value
2457        }
2458    }
2459
2460    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplGetIfaceHistogramStatsResponse {
2461        type Owned = Self;
2462
2463        #[inline(always)]
2464        fn inline_align(_context: fidl::encoding::Context) -> usize {
2465            8
2466        }
2467
2468        #[inline(always)]
2469        fn inline_size(_context: fidl::encoding::Context) -> usize {
2470            16
2471        }
2472    }
2473
2474    unsafe impl<D: fidl::encoding::ResourceDialect>
2475        fidl::encoding::Encode<WlanFullmacImplGetIfaceHistogramStatsResponse, D>
2476        for &WlanFullmacImplGetIfaceHistogramStatsResponse
2477    {
2478        #[inline]
2479        unsafe fn encode(
2480            self,
2481            encoder: &mut fidl::encoding::Encoder<'_, D>,
2482            offset: usize,
2483            _depth: fidl::encoding::Depth,
2484        ) -> fidl::Result<()> {
2485            encoder.debug_check_bounds::<WlanFullmacImplGetIfaceHistogramStatsResponse>(offset);
2486            // Delegate to tuple encoding.
2487            fidl::encoding::Encode::<WlanFullmacImplGetIfaceHistogramStatsResponse, D>::encode(
2488                (
2489                    <fidl_fuchsia_wlan_stats__common::IfaceHistogramStats as fidl::encoding::ValueTypeMarker>::borrow(&self.stats),
2490                ),
2491                encoder, offset, _depth
2492            )
2493        }
2494    }
2495    unsafe impl<
2496            D: fidl::encoding::ResourceDialect,
2497            T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D>,
2498        > fidl::encoding::Encode<WlanFullmacImplGetIfaceHistogramStatsResponse, D> for (T0,)
2499    {
2500        #[inline]
2501        unsafe fn encode(
2502            self,
2503            encoder: &mut fidl::encoding::Encoder<'_, D>,
2504            offset: usize,
2505            depth: fidl::encoding::Depth,
2506        ) -> fidl::Result<()> {
2507            encoder.debug_check_bounds::<WlanFullmacImplGetIfaceHistogramStatsResponse>(offset);
2508            // Zero out padding regions. There's no need to apply masks
2509            // because the unmasked parts will be overwritten by fields.
2510            // Write the fields.
2511            self.0.encode(encoder, offset + 0, depth)?;
2512            Ok(())
2513        }
2514    }
2515
2516    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2517        for WlanFullmacImplGetIfaceHistogramStatsResponse
2518    {
2519        #[inline(always)]
2520        fn new_empty() -> Self {
2521            Self {
2522                stats: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D),
2523            }
2524        }
2525
2526        #[inline]
2527        unsafe fn decode(
2528            &mut self,
2529            decoder: &mut fidl::encoding::Decoder<'_, D>,
2530            offset: usize,
2531            _depth: fidl::encoding::Depth,
2532        ) -> fidl::Result<()> {
2533            decoder.debug_check_bounds::<Self>(offset);
2534            // Verify that padding bytes are zero.
2535            fidl::decode!(
2536                fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
2537                D,
2538                &mut self.stats,
2539                decoder,
2540                offset + 0,
2541                _depth
2542            )?;
2543            Ok(())
2544        }
2545    }
2546
2547    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplGetIfaceStatsResponse {
2548        type Borrowed<'a> = &'a Self;
2549        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2550            value
2551        }
2552    }
2553
2554    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplGetIfaceStatsResponse {
2555        type Owned = Self;
2556
2557        #[inline(always)]
2558        fn inline_align(_context: fidl::encoding::Context) -> usize {
2559            8
2560        }
2561
2562        #[inline(always)]
2563        fn inline_size(_context: fidl::encoding::Context) -> usize {
2564            16
2565        }
2566    }
2567
2568    unsafe impl<D: fidl::encoding::ResourceDialect>
2569        fidl::encoding::Encode<WlanFullmacImplGetIfaceStatsResponse, D>
2570        for &WlanFullmacImplGetIfaceStatsResponse
2571    {
2572        #[inline]
2573        unsafe fn encode(
2574            self,
2575            encoder: &mut fidl::encoding::Encoder<'_, D>,
2576            offset: usize,
2577            _depth: fidl::encoding::Depth,
2578        ) -> fidl::Result<()> {
2579            encoder.debug_check_bounds::<WlanFullmacImplGetIfaceStatsResponse>(offset);
2580            // Delegate to tuple encoding.
2581            fidl::encoding::Encode::<WlanFullmacImplGetIfaceStatsResponse, D>::encode(
2582                (
2583                    <fidl_fuchsia_wlan_stats__common::IfaceStats as fidl::encoding::ValueTypeMarker>::borrow(&self.stats),
2584                ),
2585                encoder, offset, _depth
2586            )
2587        }
2588    }
2589    unsafe impl<
2590            D: fidl::encoding::ResourceDialect,
2591            T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::IfaceStats, D>,
2592        > fidl::encoding::Encode<WlanFullmacImplGetIfaceStatsResponse, D> for (T0,)
2593    {
2594        #[inline]
2595        unsafe fn encode(
2596            self,
2597            encoder: &mut fidl::encoding::Encoder<'_, D>,
2598            offset: usize,
2599            depth: fidl::encoding::Depth,
2600        ) -> fidl::Result<()> {
2601            encoder.debug_check_bounds::<WlanFullmacImplGetIfaceStatsResponse>(offset);
2602            // Zero out padding regions. There's no need to apply masks
2603            // because the unmasked parts will be overwritten by fields.
2604            // Write the fields.
2605            self.0.encode(encoder, offset + 0, depth)?;
2606            Ok(())
2607        }
2608    }
2609
2610    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2611        for WlanFullmacImplGetIfaceStatsResponse
2612    {
2613        #[inline(always)]
2614        fn new_empty() -> Self {
2615            Self { stats: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceStats, D) }
2616        }
2617
2618        #[inline]
2619        unsafe fn decode(
2620            &mut self,
2621            decoder: &mut fidl::encoding::Decoder<'_, D>,
2622            offset: usize,
2623            _depth: fidl::encoding::Depth,
2624        ) -> fidl::Result<()> {
2625            decoder.debug_check_bounds::<Self>(offset);
2626            // Verify that padding bytes are zero.
2627            fidl::decode!(
2628                fidl_fuchsia_wlan_stats__common::IfaceStats,
2629                D,
2630                &mut self.stats,
2631                decoder,
2632                offset + 0,
2633                _depth
2634            )?;
2635            Ok(())
2636        }
2637    }
2638
2639    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQuerySecuritySupportResponse {
2640        type Borrowed<'a> = &'a Self;
2641        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2642            value
2643        }
2644    }
2645
2646    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQuerySecuritySupportResponse {
2647        type Owned = Self;
2648
2649        #[inline(always)]
2650        fn inline_align(_context: fidl::encoding::Context) -> usize {
2651            1
2652        }
2653
2654        #[inline(always)]
2655        fn inline_size(_context: fidl::encoding::Context) -> usize {
2656            3
2657        }
2658    }
2659
2660    unsafe impl<D: fidl::encoding::ResourceDialect>
2661        fidl::encoding::Encode<WlanFullmacImplQuerySecuritySupportResponse, D>
2662        for &WlanFullmacImplQuerySecuritySupportResponse
2663    {
2664        #[inline]
2665        unsafe fn encode(
2666            self,
2667            encoder: &mut fidl::encoding::Encoder<'_, D>,
2668            offset: usize,
2669            _depth: fidl::encoding::Depth,
2670        ) -> fidl::Result<()> {
2671            encoder.debug_check_bounds::<WlanFullmacImplQuerySecuritySupportResponse>(offset);
2672            // Delegate to tuple encoding.
2673            fidl::encoding::Encode::<WlanFullmacImplQuerySecuritySupportResponse, D>::encode(
2674                (
2675                    <fidl_fuchsia_wlan_common__common::SecuritySupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
2676                ),
2677                encoder, offset, _depth
2678            )
2679        }
2680    }
2681    unsafe impl<
2682            D: fidl::encoding::ResourceDialect,
2683            T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::SecuritySupport, D>,
2684        > fidl::encoding::Encode<WlanFullmacImplQuerySecuritySupportResponse, D> for (T0,)
2685    {
2686        #[inline]
2687        unsafe fn encode(
2688            self,
2689            encoder: &mut fidl::encoding::Encoder<'_, D>,
2690            offset: usize,
2691            depth: fidl::encoding::Depth,
2692        ) -> fidl::Result<()> {
2693            encoder.debug_check_bounds::<WlanFullmacImplQuerySecuritySupportResponse>(offset);
2694            // Zero out padding regions. There's no need to apply masks
2695            // because the unmasked parts will be overwritten by fields.
2696            // Write the fields.
2697            self.0.encode(encoder, offset + 0, depth)?;
2698            Ok(())
2699        }
2700    }
2701
2702    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2703        for WlanFullmacImplQuerySecuritySupportResponse
2704    {
2705        #[inline(always)]
2706        fn new_empty() -> Self {
2707            Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_common__common::SecuritySupport, D) }
2708        }
2709
2710        #[inline]
2711        unsafe fn decode(
2712            &mut self,
2713            decoder: &mut fidl::encoding::Decoder<'_, D>,
2714            offset: usize,
2715            _depth: fidl::encoding::Depth,
2716        ) -> fidl::Result<()> {
2717            decoder.debug_check_bounds::<Self>(offset);
2718            // Verify that padding bytes are zero.
2719            fidl::decode!(
2720                fidl_fuchsia_wlan_common__common::SecuritySupport,
2721                D,
2722                &mut self.resp,
2723                decoder,
2724                offset + 0,
2725                _depth
2726            )?;
2727            Ok(())
2728        }
2729    }
2730
2731    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQuerySpectrumManagementSupportResponse {
2732        type Borrowed<'a> = &'a Self;
2733        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2734            value
2735        }
2736    }
2737
2738    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQuerySpectrumManagementSupportResponse {
2739        type Owned = Self;
2740
2741        #[inline(always)]
2742        fn inline_align(_context: fidl::encoding::Context) -> usize {
2743            1
2744        }
2745
2746        #[inline(always)]
2747        fn inline_size(_context: fidl::encoding::Context) -> usize {
2748            1
2749        }
2750    }
2751
2752    unsafe impl<D: fidl::encoding::ResourceDialect>
2753        fidl::encoding::Encode<WlanFullmacImplQuerySpectrumManagementSupportResponse, D>
2754        for &WlanFullmacImplQuerySpectrumManagementSupportResponse
2755    {
2756        #[inline]
2757        unsafe fn encode(
2758            self,
2759            encoder: &mut fidl::encoding::Encoder<'_, D>,
2760            offset: usize,
2761            _depth: fidl::encoding::Depth,
2762        ) -> fidl::Result<()> {
2763            encoder.debug_check_bounds::<WlanFullmacImplQuerySpectrumManagementSupportResponse>(
2764                offset,
2765            );
2766            // Delegate to tuple encoding.
2767            fidl::encoding::Encode::<WlanFullmacImplQuerySpectrumManagementSupportResponse, D>::encode(
2768                (
2769                    <fidl_fuchsia_wlan_common__common::SpectrumManagementSupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
2770                ),
2771                encoder, offset, _depth
2772            )
2773        }
2774    }
2775    unsafe impl<
2776            D: fidl::encoding::ResourceDialect,
2777            T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::SpectrumManagementSupport, D>,
2778        > fidl::encoding::Encode<WlanFullmacImplQuerySpectrumManagementSupportResponse, D>
2779        for (T0,)
2780    {
2781        #[inline]
2782        unsafe fn encode(
2783            self,
2784            encoder: &mut fidl::encoding::Encoder<'_, D>,
2785            offset: usize,
2786            depth: fidl::encoding::Depth,
2787        ) -> fidl::Result<()> {
2788            encoder.debug_check_bounds::<WlanFullmacImplQuerySpectrumManagementSupportResponse>(
2789                offset,
2790            );
2791            // Zero out padding regions. There's no need to apply masks
2792            // because the unmasked parts will be overwritten by fields.
2793            // Write the fields.
2794            self.0.encode(encoder, offset + 0, depth)?;
2795            Ok(())
2796        }
2797    }
2798
2799    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2800        for WlanFullmacImplQuerySpectrumManagementSupportResponse
2801    {
2802        #[inline(always)]
2803        fn new_empty() -> Self {
2804            Self {
2805                resp: fidl::new_empty!(
2806                    fidl_fuchsia_wlan_common__common::SpectrumManagementSupport,
2807                    D
2808                ),
2809            }
2810        }
2811
2812        #[inline]
2813        unsafe fn decode(
2814            &mut self,
2815            decoder: &mut fidl::encoding::Decoder<'_, D>,
2816            offset: usize,
2817            _depth: fidl::encoding::Depth,
2818        ) -> fidl::Result<()> {
2819            decoder.debug_check_bounds::<Self>(offset);
2820            // Verify that padding bytes are zero.
2821            fidl::decode!(
2822                fidl_fuchsia_wlan_common__common::SpectrumManagementSupport,
2823                D,
2824                &mut self.resp,
2825                decoder,
2826                offset + 0,
2827                _depth
2828            )?;
2829            Ok(())
2830        }
2831    }
2832
2833    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQueryTelemetrySupportResponse {
2834        type Borrowed<'a> = &'a Self;
2835        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2836            value
2837        }
2838    }
2839
2840    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQueryTelemetrySupportResponse {
2841        type Owned = Self;
2842
2843        #[inline(always)]
2844        fn inline_align(_context: fidl::encoding::Context) -> usize {
2845            8
2846        }
2847
2848        #[inline(always)]
2849        fn inline_size(_context: fidl::encoding::Context) -> usize {
2850            16
2851        }
2852    }
2853
2854    unsafe impl<D: fidl::encoding::ResourceDialect>
2855        fidl::encoding::Encode<WlanFullmacImplQueryTelemetrySupportResponse, D>
2856        for &WlanFullmacImplQueryTelemetrySupportResponse
2857    {
2858        #[inline]
2859        unsafe fn encode(
2860            self,
2861            encoder: &mut fidl::encoding::Encoder<'_, D>,
2862            offset: usize,
2863            _depth: fidl::encoding::Depth,
2864        ) -> fidl::Result<()> {
2865            encoder.debug_check_bounds::<WlanFullmacImplQueryTelemetrySupportResponse>(offset);
2866            // Delegate to tuple encoding.
2867            fidl::encoding::Encode::<WlanFullmacImplQueryTelemetrySupportResponse, D>::encode(
2868                (
2869                    <fidl_fuchsia_wlan_stats__common::TelemetrySupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
2870                ),
2871                encoder, offset, _depth
2872            )
2873        }
2874    }
2875    unsafe impl<
2876            D: fidl::encoding::ResourceDialect,
2877            T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::TelemetrySupport, D>,
2878        > fidl::encoding::Encode<WlanFullmacImplQueryTelemetrySupportResponse, D> for (T0,)
2879    {
2880        #[inline]
2881        unsafe fn encode(
2882            self,
2883            encoder: &mut fidl::encoding::Encoder<'_, D>,
2884            offset: usize,
2885            depth: fidl::encoding::Depth,
2886        ) -> fidl::Result<()> {
2887            encoder.debug_check_bounds::<WlanFullmacImplQueryTelemetrySupportResponse>(offset);
2888            // Zero out padding regions. There's no need to apply masks
2889            // because the unmasked parts will be overwritten by fields.
2890            // Write the fields.
2891            self.0.encode(encoder, offset + 0, depth)?;
2892            Ok(())
2893        }
2894    }
2895
2896    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2897        for WlanFullmacImplQueryTelemetrySupportResponse
2898    {
2899        #[inline(always)]
2900        fn new_empty() -> Self {
2901            Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::TelemetrySupport, D) }
2902        }
2903
2904        #[inline]
2905        unsafe fn decode(
2906            &mut self,
2907            decoder: &mut fidl::encoding::Decoder<'_, D>,
2908            offset: usize,
2909            _depth: fidl::encoding::Depth,
2910        ) -> fidl::Result<()> {
2911            decoder.debug_check_bounds::<Self>(offset);
2912            // Verify that padding bytes are zero.
2913            fidl::decode!(
2914                fidl_fuchsia_wlan_stats__common::TelemetrySupport,
2915                D,
2916                &mut self.resp,
2917                decoder,
2918                offset + 0,
2919                _depth
2920            )?;
2921            Ok(())
2922        }
2923    }
2924
2925    impl fidl::encoding::ValueTypeMarker for WlanFullmacRssiStats {
2926        type Borrowed<'a> = &'a Self;
2927        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2928            value
2929        }
2930    }
2931
2932    unsafe impl fidl::encoding::TypeMarker for WlanFullmacRssiStats {
2933        type Owned = Self;
2934
2935        #[inline(always)]
2936        fn inline_align(_context: fidl::encoding::Context) -> usize {
2937            8
2938        }
2939
2940        #[inline(always)]
2941        fn inline_size(_context: fidl::encoding::Context) -> usize {
2942            16
2943        }
2944    }
2945
2946    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WlanFullmacRssiStats, D>
2947        for &WlanFullmacRssiStats
2948    {
2949        #[inline]
2950        unsafe fn encode(
2951            self,
2952            encoder: &mut fidl::encoding::Encoder<'_, D>,
2953            offset: usize,
2954            _depth: fidl::encoding::Depth,
2955        ) -> fidl::Result<()> {
2956            encoder.debug_check_bounds::<WlanFullmacRssiStats>(offset);
2957            // Delegate to tuple encoding.
2958            fidl::encoding::Encode::<WlanFullmacRssiStats, D>::encode(
2959                (
2960                    <fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(&self.hist),
2961                ),
2962                encoder, offset, _depth
2963            )
2964        }
2965    }
2966    unsafe impl<
2967            D: fidl::encoding::ResourceDialect,
2968            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u64>, D>,
2969        > fidl::encoding::Encode<WlanFullmacRssiStats, D> for (T0,)
2970    {
2971        #[inline]
2972        unsafe fn encode(
2973            self,
2974            encoder: &mut fidl::encoding::Encoder<'_, D>,
2975            offset: usize,
2976            depth: fidl::encoding::Depth,
2977        ) -> fidl::Result<()> {
2978            encoder.debug_check_bounds::<WlanFullmacRssiStats>(offset);
2979            // Zero out padding regions. There's no need to apply masks
2980            // because the unmasked parts will be overwritten by fields.
2981            // Write the fields.
2982            self.0.encode(encoder, offset + 0, depth)?;
2983            Ok(())
2984        }
2985    }
2986
2987    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WlanFullmacRssiStats {
2988        #[inline(always)]
2989        fn new_empty() -> Self {
2990            Self { hist: fidl::new_empty!(fidl::encoding::UnboundedVector<u64>, D) }
2991        }
2992
2993        #[inline]
2994        unsafe fn decode(
2995            &mut self,
2996            decoder: &mut fidl::encoding::Decoder<'_, D>,
2997            offset: usize,
2998            _depth: fidl::encoding::Depth,
2999        ) -> fidl::Result<()> {
3000            decoder.debug_check_bounds::<Self>(offset);
3001            // Verify that padding bytes are zero.
3002            fidl::decode!(
3003                fidl::encoding::UnboundedVector<u64>,
3004                D,
3005                &mut self.hist,
3006                decoder,
3007                offset + 0,
3008                _depth
3009            )?;
3010            Ok(())
3011        }
3012    }
3013
3014    impl fidl::encoding::ValueTypeMarker for WlanFullmacSetKeysResp {
3015        type Borrowed<'a> = &'a Self;
3016        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3017            value
3018        }
3019    }
3020
3021    unsafe impl fidl::encoding::TypeMarker for WlanFullmacSetKeysResp {
3022        type Owned = Self;
3023
3024        #[inline(always)]
3025        fn inline_align(_context: fidl::encoding::Context) -> usize {
3026            8
3027        }
3028
3029        #[inline(always)]
3030        fn inline_size(_context: fidl::encoding::Context) -> usize {
3031            16
3032        }
3033    }
3034
3035    unsafe impl<D: fidl::encoding::ResourceDialect>
3036        fidl::encoding::Encode<WlanFullmacSetKeysResp, D> for &WlanFullmacSetKeysResp
3037    {
3038        #[inline]
3039        unsafe fn encode(
3040            self,
3041            encoder: &mut fidl::encoding::Encoder<'_, D>,
3042            offset: usize,
3043            _depth: fidl::encoding::Depth,
3044        ) -> fidl::Result<()> {
3045            encoder.debug_check_bounds::<WlanFullmacSetKeysResp>(offset);
3046            // Delegate to tuple encoding.
3047            fidl::encoding::Encode::<WlanFullmacSetKeysResp, D>::encode(
3048                (<fidl::encoding::Vector<i32, 4> as fidl::encoding::ValueTypeMarker>::borrow(
3049                    &self.statuslist,
3050                ),),
3051                encoder,
3052                offset,
3053                _depth,
3054            )
3055        }
3056    }
3057    unsafe impl<
3058            D: fidl::encoding::ResourceDialect,
3059            T0: fidl::encoding::Encode<fidl::encoding::Vector<i32, 4>, D>,
3060        > fidl::encoding::Encode<WlanFullmacSetKeysResp, D> for (T0,)
3061    {
3062        #[inline]
3063        unsafe fn encode(
3064            self,
3065            encoder: &mut fidl::encoding::Encoder<'_, D>,
3066            offset: usize,
3067            depth: fidl::encoding::Depth,
3068        ) -> fidl::Result<()> {
3069            encoder.debug_check_bounds::<WlanFullmacSetKeysResp>(offset);
3070            // Zero out padding regions. There's no need to apply masks
3071            // because the unmasked parts will be overwritten by fields.
3072            // Write the fields.
3073            self.0.encode(encoder, offset + 0, depth)?;
3074            Ok(())
3075        }
3076    }
3077
3078    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3079        for WlanFullmacSetKeysResp
3080    {
3081        #[inline(always)]
3082        fn new_empty() -> Self {
3083            Self { statuslist: fidl::new_empty!(fidl::encoding::Vector<i32, 4>, D) }
3084        }
3085
3086        #[inline]
3087        unsafe fn decode(
3088            &mut self,
3089            decoder: &mut fidl::encoding::Decoder<'_, D>,
3090            offset: usize,
3091            _depth: fidl::encoding::Depth,
3092        ) -> fidl::Result<()> {
3093            decoder.debug_check_bounds::<Self>(offset);
3094            // Verify that padding bytes are zero.
3095            fidl::decode!(fidl::encoding::Vector<i32, 4>, D, &mut self.statuslist, decoder, offset + 0, _depth)?;
3096            Ok(())
3097        }
3098    }
3099
3100    impl fidl::encoding::ValueTypeMarker for WlanFullmacSignalReportIndication {
3101        type Borrowed<'a> = &'a Self;
3102        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3103            value
3104        }
3105    }
3106
3107    unsafe impl fidl::encoding::TypeMarker for WlanFullmacSignalReportIndication {
3108        type Owned = Self;
3109
3110        #[inline(always)]
3111        fn inline_align(_context: fidl::encoding::Context) -> usize {
3112            1
3113        }
3114
3115        #[inline(always)]
3116        fn inline_size(_context: fidl::encoding::Context) -> usize {
3117            2
3118        }
3119        #[inline(always)]
3120        fn encode_is_copy() -> bool {
3121            true
3122        }
3123
3124        #[inline(always)]
3125        fn decode_is_copy() -> bool {
3126            true
3127        }
3128    }
3129
3130    unsafe impl<D: fidl::encoding::ResourceDialect>
3131        fidl::encoding::Encode<WlanFullmacSignalReportIndication, D>
3132        for &WlanFullmacSignalReportIndication
3133    {
3134        #[inline]
3135        unsafe fn encode(
3136            self,
3137            encoder: &mut fidl::encoding::Encoder<'_, D>,
3138            offset: usize,
3139            _depth: fidl::encoding::Depth,
3140        ) -> fidl::Result<()> {
3141            encoder.debug_check_bounds::<WlanFullmacSignalReportIndication>(offset);
3142            unsafe {
3143                // Copy the object into the buffer.
3144                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3145                (buf_ptr as *mut WlanFullmacSignalReportIndication)
3146                    .write_unaligned((self as *const WlanFullmacSignalReportIndication).read());
3147                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
3148                // done second because the memcpy will write garbage to these bytes.
3149            }
3150            Ok(())
3151        }
3152    }
3153    unsafe impl<
3154            D: fidl::encoding::ResourceDialect,
3155            T0: fidl::encoding::Encode<i8, D>,
3156            T1: fidl::encoding::Encode<i8, D>,
3157        > fidl::encoding::Encode<WlanFullmacSignalReportIndication, D> for (T0, T1)
3158    {
3159        #[inline]
3160        unsafe fn encode(
3161            self,
3162            encoder: &mut fidl::encoding::Encoder<'_, D>,
3163            offset: usize,
3164            depth: fidl::encoding::Depth,
3165        ) -> fidl::Result<()> {
3166            encoder.debug_check_bounds::<WlanFullmacSignalReportIndication>(offset);
3167            // Zero out padding regions. There's no need to apply masks
3168            // because the unmasked parts will be overwritten by fields.
3169            // Write the fields.
3170            self.0.encode(encoder, offset + 0, depth)?;
3171            self.1.encode(encoder, offset + 1, depth)?;
3172            Ok(())
3173        }
3174    }
3175
3176    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3177        for WlanFullmacSignalReportIndication
3178    {
3179        #[inline(always)]
3180        fn new_empty() -> Self {
3181            Self { rssi_dbm: fidl::new_empty!(i8, D), snr_db: fidl::new_empty!(i8, D) }
3182        }
3183
3184        #[inline]
3185        unsafe fn decode(
3186            &mut self,
3187            decoder: &mut fidl::encoding::Decoder<'_, D>,
3188            offset: usize,
3189            _depth: fidl::encoding::Depth,
3190        ) -> fidl::Result<()> {
3191            decoder.debug_check_bounds::<Self>(offset);
3192            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3193            // Verify that padding bytes are zero.
3194            // Copy from the buffer into the object.
3195            unsafe {
3196                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
3197            }
3198            Ok(())
3199        }
3200    }
3201
3202    impl BandCapability {
3203        #[inline(always)]
3204        fn max_ordinal_present(&self) -> u64 {
3205            if let Some(_) = self.operating_channels {
3206                return 5;
3207            }
3208            if let Some(_) = self.vht_caps {
3209                return 4;
3210            }
3211            if let Some(_) = self.ht_caps {
3212                return 3;
3213            }
3214            if let Some(_) = self.basic_rates {
3215                return 2;
3216            }
3217            if let Some(_) = self.band {
3218                return 1;
3219            }
3220            0
3221        }
3222    }
3223
3224    impl fidl::encoding::ValueTypeMarker for BandCapability {
3225        type Borrowed<'a> = &'a Self;
3226        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3227            value
3228        }
3229    }
3230
3231    unsafe impl fidl::encoding::TypeMarker for BandCapability {
3232        type Owned = Self;
3233
3234        #[inline(always)]
3235        fn inline_align(_context: fidl::encoding::Context) -> usize {
3236            8
3237        }
3238
3239        #[inline(always)]
3240        fn inline_size(_context: fidl::encoding::Context) -> usize {
3241            16
3242        }
3243    }
3244
3245    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BandCapability, D>
3246        for &BandCapability
3247    {
3248        unsafe fn encode(
3249            self,
3250            encoder: &mut fidl::encoding::Encoder<'_, D>,
3251            offset: usize,
3252            mut depth: fidl::encoding::Depth,
3253        ) -> fidl::Result<()> {
3254            encoder.debug_check_bounds::<BandCapability>(offset);
3255            // Vector header
3256            let max_ordinal: u64 = self.max_ordinal_present();
3257            encoder.write_num(max_ordinal, offset);
3258            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3259            // Calling encoder.out_of_line_offset(0) is not allowed.
3260            if max_ordinal == 0 {
3261                return Ok(());
3262            }
3263            depth.increment()?;
3264            let envelope_size = 8;
3265            let bytes_len = max_ordinal as usize * envelope_size;
3266            #[allow(unused_variables)]
3267            let offset = encoder.out_of_line_offset(bytes_len);
3268            let mut _prev_end_offset: usize = 0;
3269            if 1 > max_ordinal {
3270                return Ok(());
3271            }
3272
3273            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3274            // are envelope_size bytes.
3275            let cur_offset: usize = (1 - 1) * envelope_size;
3276
3277            // Zero reserved fields.
3278            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3279
3280            // Safety:
3281            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3282            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3283            //   envelope_size bytes, there is always sufficient room.
3284            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::WlanBand, D>(
3285            self.band.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::WlanBand as fidl::encoding::ValueTypeMarker>::borrow),
3286            encoder, offset + cur_offset, depth
3287        )?;
3288
3289            _prev_end_offset = cur_offset + envelope_size;
3290            if 2 > max_ordinal {
3291                return Ok(());
3292            }
3293
3294            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3295            // are envelope_size bytes.
3296            let cur_offset: usize = (2 - 1) * envelope_size;
3297
3298            // Zero reserved fields.
3299            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3300
3301            // Safety:
3302            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3303            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3304            //   envelope_size bytes, there is always sufficient room.
3305            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 12>, D>(
3306                self.basic_rates.as_ref().map(
3307                    <fidl::encoding::Vector<u8, 12> as fidl::encoding::ValueTypeMarker>::borrow,
3308                ),
3309                encoder,
3310                offset + cur_offset,
3311                depth,
3312            )?;
3313
3314            _prev_end_offset = cur_offset + envelope_size;
3315            if 3 > max_ordinal {
3316                return Ok(());
3317            }
3318
3319            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3320            // are envelope_size bytes.
3321            let cur_offset: usize = (3 - 1) * envelope_size;
3322
3323            // Zero reserved fields.
3324            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3325
3326            // Safety:
3327            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3328            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3329            //   envelope_size bytes, there is always sufficient room.
3330            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities, D>(
3331            self.ht_caps.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
3332            encoder, offset + cur_offset, depth
3333        )?;
3334
3335            _prev_end_offset = cur_offset + envelope_size;
3336            if 4 > max_ordinal {
3337                return Ok(());
3338            }
3339
3340            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3341            // are envelope_size bytes.
3342            let cur_offset: usize = (4 - 1) * envelope_size;
3343
3344            // Zero reserved fields.
3345            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3346
3347            // Safety:
3348            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3349            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3350            //   envelope_size bytes, there is always sufficient room.
3351            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities, D>(
3352            self.vht_caps.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
3353            encoder, offset + cur_offset, depth
3354        )?;
3355
3356            _prev_end_offset = cur_offset + envelope_size;
3357            if 5 > max_ordinal {
3358                return Ok(());
3359            }
3360
3361            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3362            // are envelope_size bytes.
3363            let cur_offset: usize = (5 - 1) * envelope_size;
3364
3365            // Zero reserved fields.
3366            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3367
3368            // Safety:
3369            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3370            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3371            //   envelope_size bytes, there is always sufficient room.
3372            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 256>, D>(
3373                self.operating_channels.as_ref().map(
3374                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow,
3375                ),
3376                encoder,
3377                offset + cur_offset,
3378                depth,
3379            )?;
3380
3381            _prev_end_offset = cur_offset + envelope_size;
3382
3383            Ok(())
3384        }
3385    }
3386
3387    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BandCapability {
3388        #[inline(always)]
3389        fn new_empty() -> Self {
3390            Self::default()
3391        }
3392
3393        unsafe fn decode(
3394            &mut self,
3395            decoder: &mut fidl::encoding::Decoder<'_, D>,
3396            offset: usize,
3397            mut depth: fidl::encoding::Depth,
3398        ) -> fidl::Result<()> {
3399            decoder.debug_check_bounds::<Self>(offset);
3400            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3401                None => return Err(fidl::Error::NotNullable),
3402                Some(len) => len,
3403            };
3404            // Calling decoder.out_of_line_offset(0) is not allowed.
3405            if len == 0 {
3406                return Ok(());
3407            };
3408            depth.increment()?;
3409            let envelope_size = 8;
3410            let bytes_len = len * envelope_size;
3411            let offset = decoder.out_of_line_offset(bytes_len)?;
3412            // Decode the envelope for each type.
3413            let mut _next_ordinal_to_read = 0;
3414            let mut next_offset = offset;
3415            let end_offset = offset + bytes_len;
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 < 1 {
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 = <fidl_fuchsia_wlan_ieee80211__common::WlanBand as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3434                if inlined != (member_inline_size <= 4) {
3435                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3436                }
3437                let inner_offset;
3438                let mut inner_depth = depth.clone();
3439                if inlined {
3440                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3441                    inner_offset = next_offset;
3442                } else {
3443                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3444                    inner_depth.increment()?;
3445                }
3446                let val_ref = self.band.get_or_insert_with(|| {
3447                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::WlanBand, D)
3448                });
3449                fidl::decode!(
3450                    fidl_fuchsia_wlan_ieee80211__common::WlanBand,
3451                    D,
3452                    val_ref,
3453                    decoder,
3454                    inner_offset,
3455                    inner_depth
3456                )?;
3457                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3458                {
3459                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3460                }
3461                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3462                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3463                }
3464            }
3465
3466            next_offset += envelope_size;
3467            _next_ordinal_to_read += 1;
3468            if next_offset >= end_offset {
3469                return Ok(());
3470            }
3471
3472            // Decode unknown envelopes for gaps in ordinals.
3473            while _next_ordinal_to_read < 2 {
3474                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3475                _next_ordinal_to_read += 1;
3476                next_offset += envelope_size;
3477            }
3478
3479            let next_out_of_line = decoder.next_out_of_line();
3480            let handles_before = decoder.remaining_handles();
3481            if let Some((inlined, num_bytes, num_handles)) =
3482                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3483            {
3484                let member_inline_size =
3485                    <fidl::encoding::Vector<u8, 12> as fidl::encoding::TypeMarker>::inline_size(
3486                        decoder.context,
3487                    );
3488                if inlined != (member_inline_size <= 4) {
3489                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3490                }
3491                let inner_offset;
3492                let mut inner_depth = depth.clone();
3493                if inlined {
3494                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3495                    inner_offset = next_offset;
3496                } else {
3497                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3498                    inner_depth.increment()?;
3499                }
3500                let val_ref = self
3501                    .basic_rates
3502                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 12>, D));
3503                fidl::decode!(fidl::encoding::Vector<u8, 12>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 3 {
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::HtCapabilities 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.ht_caps.get_or_insert_with(|| {
3545                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::HtCapabilities, D)
3546                });
3547                fidl::decode!(
3548                    fidl_fuchsia_wlan_ieee80211__common::HtCapabilities,
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 < 4 {
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 = <fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3583                if inlined != (member_inline_size <= 4) {
3584                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3585                }
3586                let inner_offset;
3587                let mut inner_depth = depth.clone();
3588                if inlined {
3589                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3590                    inner_offset = next_offset;
3591                } else {
3592                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3593                    inner_depth.increment()?;
3594                }
3595                let val_ref = self.vht_caps.get_or_insert_with(|| {
3596                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities, D)
3597                });
3598                fidl::decode!(
3599                    fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities,
3600                    D,
3601                    val_ref,
3602                    decoder,
3603                    inner_offset,
3604                    inner_depth
3605                )?;
3606                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3607                {
3608                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3609                }
3610                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3611                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3612                }
3613            }
3614
3615            next_offset += envelope_size;
3616            _next_ordinal_to_read += 1;
3617            if next_offset >= end_offset {
3618                return Ok(());
3619            }
3620
3621            // Decode unknown envelopes for gaps in ordinals.
3622            while _next_ordinal_to_read < 5 {
3623                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3624                _next_ordinal_to_read += 1;
3625                next_offset += envelope_size;
3626            }
3627
3628            let next_out_of_line = decoder.next_out_of_line();
3629            let handles_before = decoder.remaining_handles();
3630            if let Some((inlined, num_bytes, num_handles)) =
3631                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3632            {
3633                let member_inline_size =
3634                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::TypeMarker>::inline_size(
3635                        decoder.context,
3636                    );
3637                if inlined != (member_inline_size <= 4) {
3638                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3639                }
3640                let inner_offset;
3641                let mut inner_depth = depth.clone();
3642                if inlined {
3643                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3644                    inner_offset = next_offset;
3645                } else {
3646                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3647                    inner_depth.increment()?;
3648                }
3649                let val_ref = self
3650                    .operating_channels
3651                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D));
3652                fidl::decode!(fidl::encoding::Vector<u8, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
3653                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3654                {
3655                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3656                }
3657                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3658                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3659                }
3660            }
3661
3662            next_offset += envelope_size;
3663
3664            // Decode the remaining unknown envelopes.
3665            while next_offset < end_offset {
3666                _next_ordinal_to_read += 1;
3667                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3668                next_offset += envelope_size;
3669            }
3670
3671            Ok(())
3672        }
3673    }
3674
3675    impl SaeFrame {
3676        #[inline(always)]
3677        fn max_ordinal_present(&self) -> u64 {
3678            if let Some(_) = self.sae_fields {
3679                return 4;
3680            }
3681            if let Some(_) = self.seq_num {
3682                return 3;
3683            }
3684            if let Some(_) = self.status_code {
3685                return 2;
3686            }
3687            if let Some(_) = self.peer_sta_address {
3688                return 1;
3689            }
3690            0
3691        }
3692    }
3693
3694    impl fidl::encoding::ValueTypeMarker for SaeFrame {
3695        type Borrowed<'a> = &'a Self;
3696        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3697            value
3698        }
3699    }
3700
3701    unsafe impl fidl::encoding::TypeMarker for SaeFrame {
3702        type Owned = Self;
3703
3704        #[inline(always)]
3705        fn inline_align(_context: fidl::encoding::Context) -> usize {
3706            8
3707        }
3708
3709        #[inline(always)]
3710        fn inline_size(_context: fidl::encoding::Context) -> usize {
3711            16
3712        }
3713    }
3714
3715    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SaeFrame, D> for &SaeFrame {
3716        unsafe fn encode(
3717            self,
3718            encoder: &mut fidl::encoding::Encoder<'_, D>,
3719            offset: usize,
3720            mut depth: fidl::encoding::Depth,
3721        ) -> fidl::Result<()> {
3722            encoder.debug_check_bounds::<SaeFrame>(offset);
3723            // Vector header
3724            let max_ordinal: u64 = self.max_ordinal_present();
3725            encoder.write_num(max_ordinal, offset);
3726            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3727            // Calling encoder.out_of_line_offset(0) is not allowed.
3728            if max_ordinal == 0 {
3729                return Ok(());
3730            }
3731            depth.increment()?;
3732            let envelope_size = 8;
3733            let bytes_len = max_ordinal as usize * envelope_size;
3734            #[allow(unused_variables)]
3735            let offset = encoder.out_of_line_offset(bytes_len);
3736            let mut _prev_end_offset: usize = 0;
3737            if 1 > max_ordinal {
3738                return Ok(());
3739            }
3740
3741            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3742            // are envelope_size bytes.
3743            let cur_offset: usize = (1 - 1) * envelope_size;
3744
3745            // Zero reserved fields.
3746            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3747
3748            // Safety:
3749            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3750            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3751            //   envelope_size bytes, there is always sufficient room.
3752            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
3753                self.peer_sta_address
3754                    .as_ref()
3755                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
3756                encoder,
3757                offset + cur_offset,
3758                depth,
3759            )?;
3760
3761            _prev_end_offset = cur_offset + envelope_size;
3762            if 2 > max_ordinal {
3763                return Ok(());
3764            }
3765
3766            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3767            // are envelope_size bytes.
3768            let cur_offset: usize = (2 - 1) * envelope_size;
3769
3770            // Zero reserved fields.
3771            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3772
3773            // Safety:
3774            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3775            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3776            //   envelope_size bytes, there is always sufficient room.
3777            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
3778            self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
3779            encoder, offset + cur_offset, depth
3780        )?;
3781
3782            _prev_end_offset = cur_offset + envelope_size;
3783            if 3 > max_ordinal {
3784                return Ok(());
3785            }
3786
3787            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3788            // are envelope_size bytes.
3789            let cur_offset: usize = (3 - 1) * envelope_size;
3790
3791            // Zero reserved fields.
3792            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3793
3794            // Safety:
3795            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3796            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3797            //   envelope_size bytes, there is always sufficient room.
3798            fidl::encoding::encode_in_envelope_optional::<u16, D>(
3799                self.seq_num.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3800                encoder,
3801                offset + cur_offset,
3802                depth,
3803            )?;
3804
3805            _prev_end_offset = cur_offset + envelope_size;
3806            if 4 > max_ordinal {
3807                return Ok(());
3808            }
3809
3810            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3811            // are envelope_size bytes.
3812            let cur_offset: usize = (4 - 1) * envelope_size;
3813
3814            // Zero reserved fields.
3815            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3816
3817            // Safety:
3818            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3819            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3820            //   envelope_size bytes, there is always sufficient room.
3821            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
3822            self.sae_fields.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
3823            encoder, offset + cur_offset, depth
3824        )?;
3825
3826            _prev_end_offset = cur_offset + envelope_size;
3827
3828            Ok(())
3829        }
3830    }
3831
3832    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SaeFrame {
3833        #[inline(always)]
3834        fn new_empty() -> Self {
3835            Self::default()
3836        }
3837
3838        unsafe fn decode(
3839            &mut self,
3840            decoder: &mut fidl::encoding::Decoder<'_, D>,
3841            offset: usize,
3842            mut depth: fidl::encoding::Depth,
3843        ) -> fidl::Result<()> {
3844            decoder.debug_check_bounds::<Self>(offset);
3845            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3846                None => return Err(fidl::Error::NotNullable),
3847                Some(len) => len,
3848            };
3849            // Calling decoder.out_of_line_offset(0) is not allowed.
3850            if len == 0 {
3851                return Ok(());
3852            };
3853            depth.increment()?;
3854            let envelope_size = 8;
3855            let bytes_len = len * envelope_size;
3856            let offset = decoder.out_of_line_offset(bytes_len)?;
3857            // Decode the envelope for each type.
3858            let mut _next_ordinal_to_read = 0;
3859            let mut next_offset = offset;
3860            let end_offset = offset + bytes_len;
3861            _next_ordinal_to_read += 1;
3862            if next_offset >= end_offset {
3863                return Ok(());
3864            }
3865
3866            // Decode unknown envelopes for gaps in ordinals.
3867            while _next_ordinal_to_read < 1 {
3868                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3869                _next_ordinal_to_read += 1;
3870                next_offset += envelope_size;
3871            }
3872
3873            let next_out_of_line = decoder.next_out_of_line();
3874            let handles_before = decoder.remaining_handles();
3875            if let Some((inlined, num_bytes, num_handles)) =
3876                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3877            {
3878                let member_inline_size =
3879                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
3880                        decoder.context,
3881                    );
3882                if inlined != (member_inline_size <= 4) {
3883                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3884                }
3885                let inner_offset;
3886                let mut inner_depth = depth.clone();
3887                if inlined {
3888                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3889                    inner_offset = next_offset;
3890                } else {
3891                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3892                    inner_depth.increment()?;
3893                }
3894                let val_ref = self
3895                    .peer_sta_address
3896                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
3897                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3926                if inlined != (member_inline_size <= 4) {
3927                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3928                }
3929                let inner_offset;
3930                let mut inner_depth = depth.clone();
3931                if inlined {
3932                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3933                    inner_offset = next_offset;
3934                } else {
3935                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3936                    inner_depth.increment()?;
3937                }
3938                let val_ref = self.status_code.get_or_insert_with(|| {
3939                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
3940                });
3941                fidl::decode!(
3942                    fidl_fuchsia_wlan_ieee80211__common::StatusCode,
3943                    D,
3944                    val_ref,
3945                    decoder,
3946                    inner_offset,
3947                    inner_depth
3948                )?;
3949                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3950                {
3951                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3952                }
3953                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3954                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3955                }
3956            }
3957
3958            next_offset += envelope_size;
3959            _next_ordinal_to_read += 1;
3960            if next_offset >= end_offset {
3961                return Ok(());
3962            }
3963
3964            // Decode unknown envelopes for gaps in ordinals.
3965            while _next_ordinal_to_read < 3 {
3966                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3967                _next_ordinal_to_read += 1;
3968                next_offset += envelope_size;
3969            }
3970
3971            let next_out_of_line = decoder.next_out_of_line();
3972            let handles_before = decoder.remaining_handles();
3973            if let Some((inlined, num_bytes, num_handles)) =
3974                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3975            {
3976                let member_inline_size =
3977                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3978                if inlined != (member_inline_size <= 4) {
3979                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3980                }
3981                let inner_offset;
3982                let mut inner_depth = depth.clone();
3983                if inlined {
3984                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3985                    inner_offset = next_offset;
3986                } else {
3987                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3988                    inner_depth.increment()?;
3989                }
3990                let val_ref = self.seq_num.get_or_insert_with(|| fidl::new_empty!(u16, D));
3991                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
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            _next_ordinal_to_read += 1;
4003            if next_offset >= end_offset {
4004                return Ok(());
4005            }
4006
4007            // Decode unknown envelopes for gaps in ordinals.
4008            while _next_ordinal_to_read < 4 {
4009                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4010                _next_ordinal_to_read += 1;
4011                next_offset += envelope_size;
4012            }
4013
4014            let next_out_of_line = decoder.next_out_of_line();
4015            let handles_before = decoder.remaining_handles();
4016            if let Some((inlined, num_bytes, num_handles)) =
4017                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4018            {
4019                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4020                if inlined != (member_inline_size <= 4) {
4021                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4022                }
4023                let inner_offset;
4024                let mut inner_depth = depth.clone();
4025                if inlined {
4026                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4027                    inner_offset = next_offset;
4028                } else {
4029                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4030                    inner_depth.increment()?;
4031                }
4032                let val_ref = self.sae_fields.get_or_insert_with(|| {
4033                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
4034                });
4035                fidl::decode!(
4036                    fidl::encoding::UnboundedVector<u8>,
4037                    D,
4038                    val_ref,
4039                    decoder,
4040                    inner_offset,
4041                    inner_depth
4042                )?;
4043                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4044                {
4045                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4046                }
4047                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4048                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4049                }
4050            }
4051
4052            next_offset += envelope_size;
4053
4054            // Decode the remaining unknown envelopes.
4055            while next_offset < end_offset {
4056                _next_ordinal_to_read += 1;
4057                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4058                next_offset += envelope_size;
4059            }
4060
4061            Ok(())
4062        }
4063    }
4064
4065    impl WlanFullmacImplAssocRespRequest {
4066        #[inline(always)]
4067        fn max_ordinal_present(&self) -> u64 {
4068            if let Some(_) = self.association_id {
4069                return 3;
4070            }
4071            if let Some(_) = self.result_code {
4072                return 2;
4073            }
4074            if let Some(_) = self.peer_sta_address {
4075                return 1;
4076            }
4077            0
4078        }
4079    }
4080
4081    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplAssocRespRequest {
4082        type Borrowed<'a> = &'a Self;
4083        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4084            value
4085        }
4086    }
4087
4088    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplAssocRespRequest {
4089        type Owned = Self;
4090
4091        #[inline(always)]
4092        fn inline_align(_context: fidl::encoding::Context) -> usize {
4093            8
4094        }
4095
4096        #[inline(always)]
4097        fn inline_size(_context: fidl::encoding::Context) -> usize {
4098            16
4099        }
4100    }
4101
4102    unsafe impl<D: fidl::encoding::ResourceDialect>
4103        fidl::encoding::Encode<WlanFullmacImplAssocRespRequest, D>
4104        for &WlanFullmacImplAssocRespRequest
4105    {
4106        unsafe fn encode(
4107            self,
4108            encoder: &mut fidl::encoding::Encoder<'_, D>,
4109            offset: usize,
4110            mut depth: fidl::encoding::Depth,
4111        ) -> fidl::Result<()> {
4112            encoder.debug_check_bounds::<WlanFullmacImplAssocRespRequest>(offset);
4113            // Vector header
4114            let max_ordinal: u64 = self.max_ordinal_present();
4115            encoder.write_num(max_ordinal, offset);
4116            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4117            // Calling encoder.out_of_line_offset(0) is not allowed.
4118            if max_ordinal == 0 {
4119                return Ok(());
4120            }
4121            depth.increment()?;
4122            let envelope_size = 8;
4123            let bytes_len = max_ordinal as usize * envelope_size;
4124            #[allow(unused_variables)]
4125            let offset = encoder.out_of_line_offset(bytes_len);
4126            let mut _prev_end_offset: usize = 0;
4127            if 1 > max_ordinal {
4128                return Ok(());
4129            }
4130
4131            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4132            // are envelope_size bytes.
4133            let cur_offset: usize = (1 - 1) * envelope_size;
4134
4135            // Zero reserved fields.
4136            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4137
4138            // Safety:
4139            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4140            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4141            //   envelope_size bytes, there is always sufficient room.
4142            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
4143                self.peer_sta_address
4144                    .as_ref()
4145                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
4146                encoder,
4147                offset + cur_offset,
4148                depth,
4149            )?;
4150
4151            _prev_end_offset = cur_offset + envelope_size;
4152            if 2 > max_ordinal {
4153                return Ok(());
4154            }
4155
4156            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4157            // are envelope_size bytes.
4158            let cur_offset: usize = (2 - 1) * envelope_size;
4159
4160            // Zero reserved fields.
4161            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4162
4163            // Safety:
4164            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4165            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4166            //   envelope_size bytes, there is always sufficient room.
4167            fidl::encoding::encode_in_envelope_optional::<WlanAssocResult, D>(
4168                self.result_code
4169                    .as_ref()
4170                    .map(<WlanAssocResult as fidl::encoding::ValueTypeMarker>::borrow),
4171                encoder,
4172                offset + cur_offset,
4173                depth,
4174            )?;
4175
4176            _prev_end_offset = cur_offset + envelope_size;
4177            if 3 > max_ordinal {
4178                return Ok(());
4179            }
4180
4181            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4182            // are envelope_size bytes.
4183            let cur_offset: usize = (3 - 1) * envelope_size;
4184
4185            // Zero reserved fields.
4186            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4187
4188            // Safety:
4189            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4190            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4191            //   envelope_size bytes, there is always sufficient room.
4192            fidl::encoding::encode_in_envelope_optional::<u16, D>(
4193                self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4194                encoder,
4195                offset + cur_offset,
4196                depth,
4197            )?;
4198
4199            _prev_end_offset = cur_offset + envelope_size;
4200
4201            Ok(())
4202        }
4203    }
4204
4205    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4206        for WlanFullmacImplAssocRespRequest
4207    {
4208        #[inline(always)]
4209        fn new_empty() -> Self {
4210            Self::default()
4211        }
4212
4213        unsafe fn decode(
4214            &mut self,
4215            decoder: &mut fidl::encoding::Decoder<'_, D>,
4216            offset: usize,
4217            mut depth: fidl::encoding::Depth,
4218        ) -> fidl::Result<()> {
4219            decoder.debug_check_bounds::<Self>(offset);
4220            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4221                None => return Err(fidl::Error::NotNullable),
4222                Some(len) => len,
4223            };
4224            // Calling decoder.out_of_line_offset(0) is not allowed.
4225            if len == 0 {
4226                return Ok(());
4227            };
4228            depth.increment()?;
4229            let envelope_size = 8;
4230            let bytes_len = len * envelope_size;
4231            let offset = decoder.out_of_line_offset(bytes_len)?;
4232            // Decode the envelope for each type.
4233            let mut _next_ordinal_to_read = 0;
4234            let mut next_offset = offset;
4235            let end_offset = offset + bytes_len;
4236            _next_ordinal_to_read += 1;
4237            if next_offset >= end_offset {
4238                return Ok(());
4239            }
4240
4241            // Decode unknown envelopes for gaps in ordinals.
4242            while _next_ordinal_to_read < 1 {
4243                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4244                _next_ordinal_to_read += 1;
4245                next_offset += envelope_size;
4246            }
4247
4248            let next_out_of_line = decoder.next_out_of_line();
4249            let handles_before = decoder.remaining_handles();
4250            if let Some((inlined, num_bytes, num_handles)) =
4251                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4252            {
4253                let member_inline_size =
4254                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
4255                        decoder.context,
4256                    );
4257                if inlined != (member_inline_size <= 4) {
4258                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4259                }
4260                let inner_offset;
4261                let mut inner_depth = depth.clone();
4262                if inlined {
4263                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4264                    inner_offset = next_offset;
4265                } else {
4266                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4267                    inner_depth.increment()?;
4268                }
4269                let val_ref = self
4270                    .peer_sta_address
4271                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
4272                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
4273                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4274                {
4275                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4276                }
4277                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4278                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4279                }
4280            }
4281
4282            next_offset += envelope_size;
4283            _next_ordinal_to_read += 1;
4284            if next_offset >= end_offset {
4285                return Ok(());
4286            }
4287
4288            // Decode unknown envelopes for gaps in ordinals.
4289            while _next_ordinal_to_read < 2 {
4290                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4291                _next_ordinal_to_read += 1;
4292                next_offset += envelope_size;
4293            }
4294
4295            let next_out_of_line = decoder.next_out_of_line();
4296            let handles_before = decoder.remaining_handles();
4297            if let Some((inlined, num_bytes, num_handles)) =
4298                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4299            {
4300                let member_inline_size =
4301                    <WlanAssocResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4302                if inlined != (member_inline_size <= 4) {
4303                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4304                }
4305                let inner_offset;
4306                let mut inner_depth = depth.clone();
4307                if inlined {
4308                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4309                    inner_offset = next_offset;
4310                } else {
4311                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4312                    inner_depth.increment()?;
4313                }
4314                let val_ref =
4315                    self.result_code.get_or_insert_with(|| fidl::new_empty!(WlanAssocResult, D));
4316                fidl::decode!(WlanAssocResult, D, val_ref, decoder, inner_offset, inner_depth)?;
4317                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4318                {
4319                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4320                }
4321                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4322                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4323                }
4324            }
4325
4326            next_offset += envelope_size;
4327            _next_ordinal_to_read += 1;
4328            if next_offset >= end_offset {
4329                return Ok(());
4330            }
4331
4332            // Decode unknown envelopes for gaps in ordinals.
4333            while _next_ordinal_to_read < 3 {
4334                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4335                _next_ordinal_to_read += 1;
4336                next_offset += envelope_size;
4337            }
4338
4339            let next_out_of_line = decoder.next_out_of_line();
4340            let handles_before = decoder.remaining_handles();
4341            if let Some((inlined, num_bytes, num_handles)) =
4342                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4343            {
4344                let member_inline_size =
4345                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4346                if inlined != (member_inline_size <= 4) {
4347                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4348                }
4349                let inner_offset;
4350                let mut inner_depth = depth.clone();
4351                if inlined {
4352                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4353                    inner_offset = next_offset;
4354                } else {
4355                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4356                    inner_depth.increment()?;
4357                }
4358                let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
4359                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4360                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4361                {
4362                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4363                }
4364                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4365                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4366                }
4367            }
4368
4369            next_offset += envelope_size;
4370
4371            // Decode the remaining unknown envelopes.
4372            while next_offset < end_offset {
4373                _next_ordinal_to_read += 1;
4374                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4375                next_offset += envelope_size;
4376            }
4377
4378            Ok(())
4379        }
4380    }
4381
4382    impl WlanFullmacImplAuthRespRequest {
4383        #[inline(always)]
4384        fn max_ordinal_present(&self) -> u64 {
4385            if let Some(_) = self.result_code {
4386                return 2;
4387            }
4388            if let Some(_) = self.peer_sta_address {
4389                return 1;
4390            }
4391            0
4392        }
4393    }
4394
4395    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplAuthRespRequest {
4396        type Borrowed<'a> = &'a Self;
4397        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4398            value
4399        }
4400    }
4401
4402    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplAuthRespRequest {
4403        type Owned = Self;
4404
4405        #[inline(always)]
4406        fn inline_align(_context: fidl::encoding::Context) -> usize {
4407            8
4408        }
4409
4410        #[inline(always)]
4411        fn inline_size(_context: fidl::encoding::Context) -> usize {
4412            16
4413        }
4414    }
4415
4416    unsafe impl<D: fidl::encoding::ResourceDialect>
4417        fidl::encoding::Encode<WlanFullmacImplAuthRespRequest, D>
4418        for &WlanFullmacImplAuthRespRequest
4419    {
4420        unsafe fn encode(
4421            self,
4422            encoder: &mut fidl::encoding::Encoder<'_, D>,
4423            offset: usize,
4424            mut depth: fidl::encoding::Depth,
4425        ) -> fidl::Result<()> {
4426            encoder.debug_check_bounds::<WlanFullmacImplAuthRespRequest>(offset);
4427            // Vector header
4428            let max_ordinal: u64 = self.max_ordinal_present();
4429            encoder.write_num(max_ordinal, offset);
4430            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4431            // Calling encoder.out_of_line_offset(0) is not allowed.
4432            if max_ordinal == 0 {
4433                return Ok(());
4434            }
4435            depth.increment()?;
4436            let envelope_size = 8;
4437            let bytes_len = max_ordinal as usize * envelope_size;
4438            #[allow(unused_variables)]
4439            let offset = encoder.out_of_line_offset(bytes_len);
4440            let mut _prev_end_offset: usize = 0;
4441            if 1 > max_ordinal {
4442                return Ok(());
4443            }
4444
4445            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4446            // are envelope_size bytes.
4447            let cur_offset: usize = (1 - 1) * envelope_size;
4448
4449            // Zero reserved fields.
4450            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4451
4452            // Safety:
4453            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4454            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4455            //   envelope_size bytes, there is always sufficient room.
4456            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
4457                self.peer_sta_address
4458                    .as_ref()
4459                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
4460                encoder,
4461                offset + cur_offset,
4462                depth,
4463            )?;
4464
4465            _prev_end_offset = cur_offset + envelope_size;
4466            if 2 > max_ordinal {
4467                return Ok(());
4468            }
4469
4470            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4471            // are envelope_size bytes.
4472            let cur_offset: usize = (2 - 1) * envelope_size;
4473
4474            // Zero reserved fields.
4475            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4476
4477            // Safety:
4478            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4479            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4480            //   envelope_size bytes, there is always sufficient room.
4481            fidl::encoding::encode_in_envelope_optional::<WlanAuthResult, D>(
4482                self.result_code
4483                    .as_ref()
4484                    .map(<WlanAuthResult as fidl::encoding::ValueTypeMarker>::borrow),
4485                encoder,
4486                offset + cur_offset,
4487                depth,
4488            )?;
4489
4490            _prev_end_offset = cur_offset + envelope_size;
4491
4492            Ok(())
4493        }
4494    }
4495
4496    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4497        for WlanFullmacImplAuthRespRequest
4498    {
4499        #[inline(always)]
4500        fn new_empty() -> Self {
4501            Self::default()
4502        }
4503
4504        unsafe fn decode(
4505            &mut self,
4506            decoder: &mut fidl::encoding::Decoder<'_, D>,
4507            offset: usize,
4508            mut depth: fidl::encoding::Depth,
4509        ) -> fidl::Result<()> {
4510            decoder.debug_check_bounds::<Self>(offset);
4511            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4512                None => return Err(fidl::Error::NotNullable),
4513                Some(len) => len,
4514            };
4515            // Calling decoder.out_of_line_offset(0) is not allowed.
4516            if len == 0 {
4517                return Ok(());
4518            };
4519            depth.increment()?;
4520            let envelope_size = 8;
4521            let bytes_len = len * envelope_size;
4522            let offset = decoder.out_of_line_offset(bytes_len)?;
4523            // Decode the envelope for each type.
4524            let mut _next_ordinal_to_read = 0;
4525            let mut next_offset = offset;
4526            let end_offset = offset + bytes_len;
4527            _next_ordinal_to_read += 1;
4528            if next_offset >= end_offset {
4529                return Ok(());
4530            }
4531
4532            // Decode unknown envelopes for gaps in ordinals.
4533            while _next_ordinal_to_read < 1 {
4534                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4535                _next_ordinal_to_read += 1;
4536                next_offset += envelope_size;
4537            }
4538
4539            let next_out_of_line = decoder.next_out_of_line();
4540            let handles_before = decoder.remaining_handles();
4541            if let Some((inlined, num_bytes, num_handles)) =
4542                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4543            {
4544                let member_inline_size =
4545                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
4546                        decoder.context,
4547                    );
4548                if inlined != (member_inline_size <= 4) {
4549                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4550                }
4551                let inner_offset;
4552                let mut inner_depth = depth.clone();
4553                if inlined {
4554                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4555                    inner_offset = next_offset;
4556                } else {
4557                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4558                    inner_depth.increment()?;
4559                }
4560                let val_ref = self
4561                    .peer_sta_address
4562                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
4563                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
4564                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4565                {
4566                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4567                }
4568                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4569                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4570                }
4571            }
4572
4573            next_offset += envelope_size;
4574            _next_ordinal_to_read += 1;
4575            if next_offset >= end_offset {
4576                return Ok(());
4577            }
4578
4579            // Decode unknown envelopes for gaps in ordinals.
4580            while _next_ordinal_to_read < 2 {
4581                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4582                _next_ordinal_to_read += 1;
4583                next_offset += envelope_size;
4584            }
4585
4586            let next_out_of_line = decoder.next_out_of_line();
4587            let handles_before = decoder.remaining_handles();
4588            if let Some((inlined, num_bytes, num_handles)) =
4589                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4590            {
4591                let member_inline_size =
4592                    <WlanAuthResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4593                if inlined != (member_inline_size <= 4) {
4594                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4595                }
4596                let inner_offset;
4597                let mut inner_depth = depth.clone();
4598                if inlined {
4599                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4600                    inner_offset = next_offset;
4601                } else {
4602                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4603                    inner_depth.increment()?;
4604                }
4605                let val_ref =
4606                    self.result_code.get_or_insert_with(|| fidl::new_empty!(WlanAuthResult, D));
4607                fidl::decode!(WlanAuthResult, D, val_ref, decoder, inner_offset, inner_depth)?;
4608                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4609                {
4610                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4611                }
4612                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4613                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4614                }
4615            }
4616
4617            next_offset += envelope_size;
4618
4619            // Decode the remaining unknown envelopes.
4620            while next_offset < end_offset {
4621                _next_ordinal_to_read += 1;
4622                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4623                next_offset += envelope_size;
4624            }
4625
4626            Ok(())
4627        }
4628    }
4629
4630    impl WlanFullmacImplConnectRequest {
4631        #[inline(always)]
4632        fn max_ordinal_present(&self) -> u64 {
4633            if let Some(_) = self.wep_key_desc {
4634                return 7;
4635            }
4636            if let Some(_) = self.security_ie {
4637                return 6;
4638            }
4639            if let Some(_) = self.wep_key {
4640                return 5;
4641            }
4642            if let Some(_) = self.sae_password {
4643                return 4;
4644            }
4645            if let Some(_) = self.auth_type {
4646                return 3;
4647            }
4648            if let Some(_) = self.connect_failure_timeout {
4649                return 2;
4650            }
4651            if let Some(_) = self.selected_bss {
4652                return 1;
4653            }
4654            0
4655        }
4656    }
4657
4658    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplConnectRequest {
4659        type Borrowed<'a> = &'a Self;
4660        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4661            value
4662        }
4663    }
4664
4665    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplConnectRequest {
4666        type Owned = Self;
4667
4668        #[inline(always)]
4669        fn inline_align(_context: fidl::encoding::Context) -> usize {
4670            8
4671        }
4672
4673        #[inline(always)]
4674        fn inline_size(_context: fidl::encoding::Context) -> usize {
4675            16
4676        }
4677    }
4678
4679    unsafe impl<D: fidl::encoding::ResourceDialect>
4680        fidl::encoding::Encode<WlanFullmacImplConnectRequest, D>
4681        for &WlanFullmacImplConnectRequest
4682    {
4683        unsafe fn encode(
4684            self,
4685            encoder: &mut fidl::encoding::Encoder<'_, D>,
4686            offset: usize,
4687            mut depth: fidl::encoding::Depth,
4688        ) -> fidl::Result<()> {
4689            encoder.debug_check_bounds::<WlanFullmacImplConnectRequest>(offset);
4690            // Vector header
4691            let max_ordinal: u64 = self.max_ordinal_present();
4692            encoder.write_num(max_ordinal, offset);
4693            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4694            // Calling encoder.out_of_line_offset(0) is not allowed.
4695            if max_ordinal == 0 {
4696                return Ok(());
4697            }
4698            depth.increment()?;
4699            let envelope_size = 8;
4700            let bytes_len = max_ordinal as usize * envelope_size;
4701            #[allow(unused_variables)]
4702            let offset = encoder.out_of_line_offset(bytes_len);
4703            let mut _prev_end_offset: usize = 0;
4704            if 1 > max_ordinal {
4705                return Ok(());
4706            }
4707
4708            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4709            // are envelope_size bytes.
4710            let cur_offset: usize = (1 - 1) * envelope_size;
4711
4712            // Zero reserved fields.
4713            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4714
4715            // Safety:
4716            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4717            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4718            //   envelope_size bytes, there is always sufficient room.
4719            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
4720            self.selected_bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
4721            encoder, offset + cur_offset, depth
4722        )?;
4723
4724            _prev_end_offset = cur_offset + envelope_size;
4725            if 2 > max_ordinal {
4726                return Ok(());
4727            }
4728
4729            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4730            // are envelope_size bytes.
4731            let cur_offset: usize = (2 - 1) * envelope_size;
4732
4733            // Zero reserved fields.
4734            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4735
4736            // Safety:
4737            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4738            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4739            //   envelope_size bytes, there is always sufficient room.
4740            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4741                self.connect_failure_timeout
4742                    .as_ref()
4743                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4744                encoder,
4745                offset + cur_offset,
4746                depth,
4747            )?;
4748
4749            _prev_end_offset = cur_offset + envelope_size;
4750            if 3 > max_ordinal {
4751                return Ok(());
4752            }
4753
4754            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4755            // are envelope_size bytes.
4756            let cur_offset: usize = (3 - 1) * envelope_size;
4757
4758            // Zero reserved fields.
4759            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4760
4761            // Safety:
4762            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4763            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4764            //   envelope_size bytes, there is always sufficient room.
4765            fidl::encoding::encode_in_envelope_optional::<WlanAuthType, D>(
4766                self.auth_type
4767                    .as_ref()
4768                    .map(<WlanAuthType as fidl::encoding::ValueTypeMarker>::borrow),
4769                encoder,
4770                offset + cur_offset,
4771                depth,
4772            )?;
4773
4774            _prev_end_offset = cur_offset + envelope_size;
4775            if 4 > max_ordinal {
4776                return Ok(());
4777            }
4778
4779            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4780            // are envelope_size bytes.
4781            let cur_offset: usize = (4 - 1) * envelope_size;
4782
4783            // Zero reserved fields.
4784            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4785
4786            // Safety:
4787            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4788            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4789            //   envelope_size bytes, there is always sufficient room.
4790            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
4791            self.sae_password.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
4792            encoder, offset + cur_offset, depth
4793        )?;
4794
4795            _prev_end_offset = cur_offset + envelope_size;
4796            if 5 > max_ordinal {
4797                return Ok(());
4798            }
4799
4800            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4801            // are envelope_size bytes.
4802            let cur_offset: usize = (5 - 1) * envelope_size;
4803
4804            // Zero reserved fields.
4805            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4806
4807            // Safety:
4808            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4809            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4810            //   envelope_size bytes, there is always sufficient room.
4811            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::WlanKeyConfig, D>(
4812            self.wep_key.as_ref().map(<fidl_fuchsia_wlan_common__common::WlanKeyConfig as fidl::encoding::ValueTypeMarker>::borrow),
4813            encoder, offset + cur_offset, depth
4814        )?;
4815
4816            _prev_end_offset = cur_offset + envelope_size;
4817            if 6 > max_ordinal {
4818                return Ok(());
4819            }
4820
4821            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4822            // are envelope_size bytes.
4823            let cur_offset: usize = (6 - 1) * envelope_size;
4824
4825            // Zero reserved fields.
4826            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4827
4828            // Safety:
4829            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4830            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4831            //   envelope_size bytes, there is always sufficient room.
4832            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 257>, D>(
4833                self.security_ie.as_ref().map(
4834                    <fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow,
4835                ),
4836                encoder,
4837                offset + cur_offset,
4838                depth,
4839            )?;
4840
4841            _prev_end_offset = cur_offset + envelope_size;
4842            if 7 > max_ordinal {
4843                return Ok(());
4844            }
4845
4846            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4847            // are envelope_size bytes.
4848            let cur_offset: usize = (7 - 1) * envelope_size;
4849
4850            // Zero reserved fields.
4851            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4852
4853            // Safety:
4854            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4855            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4856            //   envelope_size bytes, there is always sufficient room.
4857            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, D>(
4858            self.wep_key_desc.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor as fidl::encoding::ValueTypeMarker>::borrow),
4859            encoder, offset + cur_offset, depth
4860        )?;
4861
4862            _prev_end_offset = cur_offset + envelope_size;
4863
4864            Ok(())
4865        }
4866    }
4867
4868    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4869        for WlanFullmacImplConnectRequest
4870    {
4871        #[inline(always)]
4872        fn new_empty() -> Self {
4873            Self::default()
4874        }
4875
4876        unsafe fn decode(
4877            &mut self,
4878            decoder: &mut fidl::encoding::Decoder<'_, D>,
4879            offset: usize,
4880            mut depth: fidl::encoding::Depth,
4881        ) -> fidl::Result<()> {
4882            decoder.debug_check_bounds::<Self>(offset);
4883            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4884                None => return Err(fidl::Error::NotNullable),
4885                Some(len) => len,
4886            };
4887            // Calling decoder.out_of_line_offset(0) is not allowed.
4888            if len == 0 {
4889                return Ok(());
4890            };
4891            depth.increment()?;
4892            let envelope_size = 8;
4893            let bytes_len = len * envelope_size;
4894            let offset = decoder.out_of_line_offset(bytes_len)?;
4895            // Decode the envelope for each type.
4896            let mut _next_ordinal_to_read = 0;
4897            let mut next_offset = offset;
4898            let end_offset = offset + bytes_len;
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 < 1 {
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 = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4917                if inlined != (member_inline_size <= 4) {
4918                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4919                }
4920                let inner_offset;
4921                let mut inner_depth = depth.clone();
4922                if inlined {
4923                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4924                    inner_offset = next_offset;
4925                } else {
4926                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4927                    inner_depth.increment()?;
4928                }
4929                let val_ref = self.selected_bss.get_or_insert_with(|| {
4930                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
4931                });
4932                fidl::decode!(
4933                    fidl_fuchsia_wlan_common__common::BssDescription,
4934                    D,
4935                    val_ref,
4936                    decoder,
4937                    inner_offset,
4938                    inner_depth
4939                )?;
4940                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4941                {
4942                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4943                }
4944                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4945                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4946                }
4947            }
4948
4949            next_offset += envelope_size;
4950            _next_ordinal_to_read += 1;
4951            if next_offset >= end_offset {
4952                return Ok(());
4953            }
4954
4955            // Decode unknown envelopes for gaps in ordinals.
4956            while _next_ordinal_to_read < 2 {
4957                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4958                _next_ordinal_to_read += 1;
4959                next_offset += envelope_size;
4960            }
4961
4962            let next_out_of_line = decoder.next_out_of_line();
4963            let handles_before = decoder.remaining_handles();
4964            if let Some((inlined, num_bytes, num_handles)) =
4965                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4966            {
4967                let member_inline_size =
4968                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4969                if inlined != (member_inline_size <= 4) {
4970                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4971                }
4972                let inner_offset;
4973                let mut inner_depth = depth.clone();
4974                if inlined {
4975                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4976                    inner_offset = next_offset;
4977                } else {
4978                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4979                    inner_depth.increment()?;
4980                }
4981                let val_ref =
4982                    self.connect_failure_timeout.get_or_insert_with(|| fidl::new_empty!(u32, D));
4983                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4984                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4985                {
4986                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4987                }
4988                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4989                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4990                }
4991            }
4992
4993            next_offset += envelope_size;
4994            _next_ordinal_to_read += 1;
4995            if next_offset >= end_offset {
4996                return Ok(());
4997            }
4998
4999            // Decode unknown envelopes for gaps in ordinals.
5000            while _next_ordinal_to_read < 3 {
5001                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5002                _next_ordinal_to_read += 1;
5003                next_offset += envelope_size;
5004            }
5005
5006            let next_out_of_line = decoder.next_out_of_line();
5007            let handles_before = decoder.remaining_handles();
5008            if let Some((inlined, num_bytes, num_handles)) =
5009                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5010            {
5011                let member_inline_size =
5012                    <WlanAuthType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5013                if inlined != (member_inline_size <= 4) {
5014                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5015                }
5016                let inner_offset;
5017                let mut inner_depth = depth.clone();
5018                if inlined {
5019                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5020                    inner_offset = next_offset;
5021                } else {
5022                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5023                    inner_depth.increment()?;
5024                }
5025                let val_ref =
5026                    self.auth_type.get_or_insert_with(|| fidl::new_empty!(WlanAuthType, D));
5027                fidl::decode!(WlanAuthType, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 4 {
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::encoding::UnboundedVector<u8> 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.sae_password.get_or_insert_with(|| {
5069                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
5070                });
5071                fidl::decode!(
5072                    fidl::encoding::UnboundedVector<u8>,
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 < 5 {
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 = <fidl_fuchsia_wlan_common__common::WlanKeyConfig as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5107                if inlined != (member_inline_size <= 4) {
5108                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5109                }
5110                let inner_offset;
5111                let mut inner_depth = depth.clone();
5112                if inlined {
5113                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5114                    inner_offset = next_offset;
5115                } else {
5116                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5117                    inner_depth.increment()?;
5118                }
5119                let val_ref = self.wep_key.get_or_insert_with(|| {
5120                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanKeyConfig, D)
5121                });
5122                fidl::decode!(
5123                    fidl_fuchsia_wlan_common__common::WlanKeyConfig,
5124                    D,
5125                    val_ref,
5126                    decoder,
5127                    inner_offset,
5128                    inner_depth
5129                )?;
5130                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5131                {
5132                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5133                }
5134                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5135                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5136                }
5137            }
5138
5139            next_offset += envelope_size;
5140            _next_ordinal_to_read += 1;
5141            if next_offset >= end_offset {
5142                return Ok(());
5143            }
5144
5145            // Decode unknown envelopes for gaps in ordinals.
5146            while _next_ordinal_to_read < 6 {
5147                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5148                _next_ordinal_to_read += 1;
5149                next_offset += envelope_size;
5150            }
5151
5152            let next_out_of_line = decoder.next_out_of_line();
5153            let handles_before = decoder.remaining_handles();
5154            if let Some((inlined, num_bytes, num_handles)) =
5155                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5156            {
5157                let member_inline_size =
5158                    <fidl::encoding::Vector<u8, 257> as fidl::encoding::TypeMarker>::inline_size(
5159                        decoder.context,
5160                    );
5161                if inlined != (member_inline_size <= 4) {
5162                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5163                }
5164                let inner_offset;
5165                let mut inner_depth = depth.clone();
5166                if inlined {
5167                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5168                    inner_offset = next_offset;
5169                } else {
5170                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5171                    inner_depth.increment()?;
5172                }
5173                let val_ref = self
5174                    .security_ie
5175                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 257>, D));
5176                fidl::decode!(fidl::encoding::Vector<u8, 257>, D, val_ref, decoder, inner_offset, inner_depth)?;
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            _next_ordinal_to_read += 1;
5188            if next_offset >= end_offset {
5189                return Ok(());
5190            }
5191
5192            // Decode unknown envelopes for gaps in ordinals.
5193            while _next_ordinal_to_read < 7 {
5194                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5195                _next_ordinal_to_read += 1;
5196                next_offset += envelope_size;
5197            }
5198
5199            let next_out_of_line = decoder.next_out_of_line();
5200            let handles_before = decoder.remaining_handles();
5201            if let Some((inlined, num_bytes, num_handles)) =
5202                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5203            {
5204                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5205                if inlined != (member_inline_size <= 4) {
5206                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5207                }
5208                let inner_offset;
5209                let mut inner_depth = depth.clone();
5210                if inlined {
5211                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5212                    inner_offset = next_offset;
5213                } else {
5214                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5215                    inner_depth.increment()?;
5216                }
5217                let val_ref = self.wep_key_desc.get_or_insert_with(|| {
5218                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, D)
5219                });
5220                fidl::decode!(
5221                    fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor,
5222                    D,
5223                    val_ref,
5224                    decoder,
5225                    inner_offset,
5226                    inner_depth
5227                )?;
5228                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5229                {
5230                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5231                }
5232                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5233                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5234                }
5235            }
5236
5237            next_offset += envelope_size;
5238
5239            // Decode the remaining unknown envelopes.
5240            while next_offset < end_offset {
5241                _next_ordinal_to_read += 1;
5242                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5243                next_offset += envelope_size;
5244            }
5245
5246            Ok(())
5247        }
5248    }
5249
5250    impl WlanFullmacImplDeauthRequest {
5251        #[inline(always)]
5252        fn max_ordinal_present(&self) -> u64 {
5253            if let Some(_) = self.reason_code {
5254                return 2;
5255            }
5256            if let Some(_) = self.peer_sta_address {
5257                return 1;
5258            }
5259            0
5260        }
5261    }
5262
5263    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplDeauthRequest {
5264        type Borrowed<'a> = &'a Self;
5265        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5266            value
5267        }
5268    }
5269
5270    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplDeauthRequest {
5271        type Owned = Self;
5272
5273        #[inline(always)]
5274        fn inline_align(_context: fidl::encoding::Context) -> usize {
5275            8
5276        }
5277
5278        #[inline(always)]
5279        fn inline_size(_context: fidl::encoding::Context) -> usize {
5280            16
5281        }
5282    }
5283
5284    unsafe impl<D: fidl::encoding::ResourceDialect>
5285        fidl::encoding::Encode<WlanFullmacImplDeauthRequest, D> for &WlanFullmacImplDeauthRequest
5286    {
5287        unsafe fn encode(
5288            self,
5289            encoder: &mut fidl::encoding::Encoder<'_, D>,
5290            offset: usize,
5291            mut depth: fidl::encoding::Depth,
5292        ) -> fidl::Result<()> {
5293            encoder.debug_check_bounds::<WlanFullmacImplDeauthRequest>(offset);
5294            // Vector header
5295            let max_ordinal: u64 = self.max_ordinal_present();
5296            encoder.write_num(max_ordinal, offset);
5297            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5298            // Calling encoder.out_of_line_offset(0) is not allowed.
5299            if max_ordinal == 0 {
5300                return Ok(());
5301            }
5302            depth.increment()?;
5303            let envelope_size = 8;
5304            let bytes_len = max_ordinal as usize * envelope_size;
5305            #[allow(unused_variables)]
5306            let offset = encoder.out_of_line_offset(bytes_len);
5307            let mut _prev_end_offset: usize = 0;
5308            if 1 > max_ordinal {
5309                return Ok(());
5310            }
5311
5312            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5313            // are envelope_size bytes.
5314            let cur_offset: usize = (1 - 1) * envelope_size;
5315
5316            // Zero reserved fields.
5317            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5318
5319            // Safety:
5320            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5321            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5322            //   envelope_size bytes, there is always sufficient room.
5323            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5324                self.peer_sta_address
5325                    .as_ref()
5326                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5327                encoder,
5328                offset + cur_offset,
5329                depth,
5330            )?;
5331
5332            _prev_end_offset = cur_offset + envelope_size;
5333            if 2 > max_ordinal {
5334                return Ok(());
5335            }
5336
5337            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5338            // are envelope_size bytes.
5339            let cur_offset: usize = (2 - 1) * envelope_size;
5340
5341            // Zero reserved fields.
5342            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5343
5344            // Safety:
5345            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5346            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5347            //   envelope_size bytes, there is always sufficient room.
5348            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
5349            self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
5350            encoder, offset + cur_offset, depth
5351        )?;
5352
5353            _prev_end_offset = cur_offset + envelope_size;
5354
5355            Ok(())
5356        }
5357    }
5358
5359    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5360        for WlanFullmacImplDeauthRequest
5361    {
5362        #[inline(always)]
5363        fn new_empty() -> Self {
5364            Self::default()
5365        }
5366
5367        unsafe fn decode(
5368            &mut self,
5369            decoder: &mut fidl::encoding::Decoder<'_, D>,
5370            offset: usize,
5371            mut depth: fidl::encoding::Depth,
5372        ) -> fidl::Result<()> {
5373            decoder.debug_check_bounds::<Self>(offset);
5374            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5375                None => return Err(fidl::Error::NotNullable),
5376                Some(len) => len,
5377            };
5378            // Calling decoder.out_of_line_offset(0) is not allowed.
5379            if len == 0 {
5380                return Ok(());
5381            };
5382            depth.increment()?;
5383            let envelope_size = 8;
5384            let bytes_len = len * envelope_size;
5385            let offset = decoder.out_of_line_offset(bytes_len)?;
5386            // Decode the envelope for each type.
5387            let mut _next_ordinal_to_read = 0;
5388            let mut next_offset = offset;
5389            let end_offset = offset + bytes_len;
5390            _next_ordinal_to_read += 1;
5391            if next_offset >= end_offset {
5392                return Ok(());
5393            }
5394
5395            // Decode unknown envelopes for gaps in ordinals.
5396            while _next_ordinal_to_read < 1 {
5397                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5398                _next_ordinal_to_read += 1;
5399                next_offset += envelope_size;
5400            }
5401
5402            let next_out_of_line = decoder.next_out_of_line();
5403            let handles_before = decoder.remaining_handles();
5404            if let Some((inlined, num_bytes, num_handles)) =
5405                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5406            {
5407                let member_inline_size =
5408                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5409                        decoder.context,
5410                    );
5411                if inlined != (member_inline_size <= 4) {
5412                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5413                }
5414                let inner_offset;
5415                let mut inner_depth = depth.clone();
5416                if inlined {
5417                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5418                    inner_offset = next_offset;
5419                } else {
5420                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5421                    inner_depth.increment()?;
5422                }
5423                let val_ref = self
5424                    .peer_sta_address
5425                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5426                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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            _next_ordinal_to_read += 1;
5438            if next_offset >= end_offset {
5439                return Ok(());
5440            }
5441
5442            // Decode unknown envelopes for gaps in ordinals.
5443            while _next_ordinal_to_read < 2 {
5444                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5445                _next_ordinal_to_read += 1;
5446                next_offset += envelope_size;
5447            }
5448
5449            let next_out_of_line = decoder.next_out_of_line();
5450            let handles_before = decoder.remaining_handles();
5451            if let Some((inlined, num_bytes, num_handles)) =
5452                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5453            {
5454                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5455                if inlined != (member_inline_size <= 4) {
5456                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5457                }
5458                let inner_offset;
5459                let mut inner_depth = depth.clone();
5460                if inlined {
5461                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5462                    inner_offset = next_offset;
5463                } else {
5464                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5465                    inner_depth.increment()?;
5466                }
5467                let val_ref = self.reason_code.get_or_insert_with(|| {
5468                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
5469                });
5470                fidl::decode!(
5471                    fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
5472                    D,
5473                    val_ref,
5474                    decoder,
5475                    inner_offset,
5476                    inner_depth
5477                )?;
5478                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5479                {
5480                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5481                }
5482                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5483                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5484                }
5485            }
5486
5487            next_offset += envelope_size;
5488
5489            // Decode the remaining unknown envelopes.
5490            while next_offset < end_offset {
5491                _next_ordinal_to_read += 1;
5492                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5493                next_offset += envelope_size;
5494            }
5495
5496            Ok(())
5497        }
5498    }
5499
5500    impl WlanFullmacImplDisassocRequest {
5501        #[inline(always)]
5502        fn max_ordinal_present(&self) -> u64 {
5503            if let Some(_) = self.reason_code {
5504                return 2;
5505            }
5506            if let Some(_) = self.peer_sta_address {
5507                return 1;
5508            }
5509            0
5510        }
5511    }
5512
5513    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplDisassocRequest {
5514        type Borrowed<'a> = &'a Self;
5515        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5516            value
5517        }
5518    }
5519
5520    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplDisassocRequest {
5521        type Owned = Self;
5522
5523        #[inline(always)]
5524        fn inline_align(_context: fidl::encoding::Context) -> usize {
5525            8
5526        }
5527
5528        #[inline(always)]
5529        fn inline_size(_context: fidl::encoding::Context) -> usize {
5530            16
5531        }
5532    }
5533
5534    unsafe impl<D: fidl::encoding::ResourceDialect>
5535        fidl::encoding::Encode<WlanFullmacImplDisassocRequest, D>
5536        for &WlanFullmacImplDisassocRequest
5537    {
5538        unsafe fn encode(
5539            self,
5540            encoder: &mut fidl::encoding::Encoder<'_, D>,
5541            offset: usize,
5542            mut depth: fidl::encoding::Depth,
5543        ) -> fidl::Result<()> {
5544            encoder.debug_check_bounds::<WlanFullmacImplDisassocRequest>(offset);
5545            // Vector header
5546            let max_ordinal: u64 = self.max_ordinal_present();
5547            encoder.write_num(max_ordinal, offset);
5548            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5549            // Calling encoder.out_of_line_offset(0) is not allowed.
5550            if max_ordinal == 0 {
5551                return Ok(());
5552            }
5553            depth.increment()?;
5554            let envelope_size = 8;
5555            let bytes_len = max_ordinal as usize * envelope_size;
5556            #[allow(unused_variables)]
5557            let offset = encoder.out_of_line_offset(bytes_len);
5558            let mut _prev_end_offset: usize = 0;
5559            if 1 > max_ordinal {
5560                return Ok(());
5561            }
5562
5563            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5564            // are envelope_size bytes.
5565            let cur_offset: usize = (1 - 1) * envelope_size;
5566
5567            // Zero reserved fields.
5568            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5569
5570            // Safety:
5571            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5572            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5573            //   envelope_size bytes, there is always sufficient room.
5574            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5575                self.peer_sta_address
5576                    .as_ref()
5577                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5578                encoder,
5579                offset + cur_offset,
5580                depth,
5581            )?;
5582
5583            _prev_end_offset = cur_offset + envelope_size;
5584            if 2 > max_ordinal {
5585                return Ok(());
5586            }
5587
5588            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5589            // are envelope_size bytes.
5590            let cur_offset: usize = (2 - 1) * envelope_size;
5591
5592            // Zero reserved fields.
5593            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5594
5595            // Safety:
5596            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5597            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5598            //   envelope_size bytes, there is always sufficient room.
5599            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
5600            self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
5601            encoder, offset + cur_offset, depth
5602        )?;
5603
5604            _prev_end_offset = cur_offset + envelope_size;
5605
5606            Ok(())
5607        }
5608    }
5609
5610    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5611        for WlanFullmacImplDisassocRequest
5612    {
5613        #[inline(always)]
5614        fn new_empty() -> Self {
5615            Self::default()
5616        }
5617
5618        unsafe fn decode(
5619            &mut self,
5620            decoder: &mut fidl::encoding::Decoder<'_, D>,
5621            offset: usize,
5622            mut depth: fidl::encoding::Depth,
5623        ) -> fidl::Result<()> {
5624            decoder.debug_check_bounds::<Self>(offset);
5625            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5626                None => return Err(fidl::Error::NotNullable),
5627                Some(len) => len,
5628            };
5629            // Calling decoder.out_of_line_offset(0) is not allowed.
5630            if len == 0 {
5631                return Ok(());
5632            };
5633            depth.increment()?;
5634            let envelope_size = 8;
5635            let bytes_len = len * envelope_size;
5636            let offset = decoder.out_of_line_offset(bytes_len)?;
5637            // Decode the envelope for each type.
5638            let mut _next_ordinal_to_read = 0;
5639            let mut next_offset = offset;
5640            let end_offset = offset + bytes_len;
5641            _next_ordinal_to_read += 1;
5642            if next_offset >= end_offset {
5643                return Ok(());
5644            }
5645
5646            // Decode unknown envelopes for gaps in ordinals.
5647            while _next_ordinal_to_read < 1 {
5648                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5649                _next_ordinal_to_read += 1;
5650                next_offset += envelope_size;
5651            }
5652
5653            let next_out_of_line = decoder.next_out_of_line();
5654            let handles_before = decoder.remaining_handles();
5655            if let Some((inlined, num_bytes, num_handles)) =
5656                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5657            {
5658                let member_inline_size =
5659                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5660                        decoder.context,
5661                    );
5662                if inlined != (member_inline_size <= 4) {
5663                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5664                }
5665                let inner_offset;
5666                let mut inner_depth = depth.clone();
5667                if inlined {
5668                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5669                    inner_offset = next_offset;
5670                } else {
5671                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5672                    inner_depth.increment()?;
5673                }
5674                let val_ref = self
5675                    .peer_sta_address
5676                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5677                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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            _next_ordinal_to_read += 1;
5689            if next_offset >= end_offset {
5690                return Ok(());
5691            }
5692
5693            // Decode unknown envelopes for gaps in ordinals.
5694            while _next_ordinal_to_read < 2 {
5695                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5696                _next_ordinal_to_read += 1;
5697                next_offset += envelope_size;
5698            }
5699
5700            let next_out_of_line = decoder.next_out_of_line();
5701            let handles_before = decoder.remaining_handles();
5702            if let Some((inlined, num_bytes, num_handles)) =
5703                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5704            {
5705                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5706                if inlined != (member_inline_size <= 4) {
5707                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5708                }
5709                let inner_offset;
5710                let mut inner_depth = depth.clone();
5711                if inlined {
5712                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5713                    inner_offset = next_offset;
5714                } else {
5715                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5716                    inner_depth.increment()?;
5717                }
5718                let val_ref = self.reason_code.get_or_insert_with(|| {
5719                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
5720                });
5721                fidl::decode!(
5722                    fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
5723                    D,
5724                    val_ref,
5725                    decoder,
5726                    inner_offset,
5727                    inner_depth
5728                )?;
5729                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5730                {
5731                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5732                }
5733                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5734                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5735                }
5736            }
5737
5738            next_offset += envelope_size;
5739
5740            // Decode the remaining unknown envelopes.
5741            while next_offset < end_offset {
5742                _next_ordinal_to_read += 1;
5743                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5744                next_offset += envelope_size;
5745            }
5746
5747            Ok(())
5748        }
5749    }
5750
5751    impl WlanFullmacImplEapolTxRequest {
5752        #[inline(always)]
5753        fn max_ordinal_present(&self) -> u64 {
5754            if let Some(_) = self.data {
5755                return 3;
5756            }
5757            if let Some(_) = self.dst_addr {
5758                return 2;
5759            }
5760            if let Some(_) = self.src_addr {
5761                return 1;
5762            }
5763            0
5764        }
5765    }
5766
5767    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplEapolTxRequest {
5768        type Borrowed<'a> = &'a Self;
5769        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5770            value
5771        }
5772    }
5773
5774    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplEapolTxRequest {
5775        type Owned = Self;
5776
5777        #[inline(always)]
5778        fn inline_align(_context: fidl::encoding::Context) -> usize {
5779            8
5780        }
5781
5782        #[inline(always)]
5783        fn inline_size(_context: fidl::encoding::Context) -> usize {
5784            16
5785        }
5786    }
5787
5788    unsafe impl<D: fidl::encoding::ResourceDialect>
5789        fidl::encoding::Encode<WlanFullmacImplEapolTxRequest, D>
5790        for &WlanFullmacImplEapolTxRequest
5791    {
5792        unsafe fn encode(
5793            self,
5794            encoder: &mut fidl::encoding::Encoder<'_, D>,
5795            offset: usize,
5796            mut depth: fidl::encoding::Depth,
5797        ) -> fidl::Result<()> {
5798            encoder.debug_check_bounds::<WlanFullmacImplEapolTxRequest>(offset);
5799            // Vector header
5800            let max_ordinal: u64 = self.max_ordinal_present();
5801            encoder.write_num(max_ordinal, offset);
5802            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5803            // Calling encoder.out_of_line_offset(0) is not allowed.
5804            if max_ordinal == 0 {
5805                return Ok(());
5806            }
5807            depth.increment()?;
5808            let envelope_size = 8;
5809            let bytes_len = max_ordinal as usize * envelope_size;
5810            #[allow(unused_variables)]
5811            let offset = encoder.out_of_line_offset(bytes_len);
5812            let mut _prev_end_offset: usize = 0;
5813            if 1 > max_ordinal {
5814                return Ok(());
5815            }
5816
5817            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5818            // are envelope_size bytes.
5819            let cur_offset: usize = (1 - 1) * envelope_size;
5820
5821            // Zero reserved fields.
5822            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5823
5824            // Safety:
5825            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5826            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5827            //   envelope_size bytes, there is always sufficient room.
5828            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5829                self.src_addr
5830                    .as_ref()
5831                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5832                encoder,
5833                offset + cur_offset,
5834                depth,
5835            )?;
5836
5837            _prev_end_offset = cur_offset + envelope_size;
5838            if 2 > max_ordinal {
5839                return Ok(());
5840            }
5841
5842            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5843            // are envelope_size bytes.
5844            let cur_offset: usize = (2 - 1) * envelope_size;
5845
5846            // Zero reserved fields.
5847            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5848
5849            // Safety:
5850            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5851            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5852            //   envelope_size bytes, there is always sufficient room.
5853            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
5854                self.dst_addr
5855                    .as_ref()
5856                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
5857                encoder,
5858                offset + cur_offset,
5859                depth,
5860            )?;
5861
5862            _prev_end_offset = cur_offset + envelope_size;
5863            if 3 > max_ordinal {
5864                return Ok(());
5865            }
5866
5867            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5868            // are envelope_size bytes.
5869            let cur_offset: usize = (3 - 1) * envelope_size;
5870
5871            // Zero reserved fields.
5872            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5873
5874            // Safety:
5875            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5876            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5877            //   envelope_size bytes, there is always sufficient room.
5878            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
5879            self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
5880            encoder, offset + cur_offset, depth
5881        )?;
5882
5883            _prev_end_offset = cur_offset + envelope_size;
5884
5885            Ok(())
5886        }
5887    }
5888
5889    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5890        for WlanFullmacImplEapolTxRequest
5891    {
5892        #[inline(always)]
5893        fn new_empty() -> Self {
5894            Self::default()
5895        }
5896
5897        unsafe fn decode(
5898            &mut self,
5899            decoder: &mut fidl::encoding::Decoder<'_, D>,
5900            offset: usize,
5901            mut depth: fidl::encoding::Depth,
5902        ) -> fidl::Result<()> {
5903            decoder.debug_check_bounds::<Self>(offset);
5904            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5905                None => return Err(fidl::Error::NotNullable),
5906                Some(len) => len,
5907            };
5908            // Calling decoder.out_of_line_offset(0) is not allowed.
5909            if len == 0 {
5910                return Ok(());
5911            };
5912            depth.increment()?;
5913            let envelope_size = 8;
5914            let bytes_len = len * envelope_size;
5915            let offset = decoder.out_of_line_offset(bytes_len)?;
5916            // Decode the envelope for each type.
5917            let mut _next_ordinal_to_read = 0;
5918            let mut next_offset = offset;
5919            let end_offset = offset + bytes_len;
5920            _next_ordinal_to_read += 1;
5921            if next_offset >= end_offset {
5922                return Ok(());
5923            }
5924
5925            // Decode unknown envelopes for gaps in ordinals.
5926            while _next_ordinal_to_read < 1 {
5927                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5928                _next_ordinal_to_read += 1;
5929                next_offset += envelope_size;
5930            }
5931
5932            let next_out_of_line = decoder.next_out_of_line();
5933            let handles_before = decoder.remaining_handles();
5934            if let Some((inlined, num_bytes, num_handles)) =
5935                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5936            {
5937                let member_inline_size =
5938                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5939                        decoder.context,
5940                    );
5941                if inlined != (member_inline_size <= 4) {
5942                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5943                }
5944                let inner_offset;
5945                let mut inner_depth = depth.clone();
5946                if inlined {
5947                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5948                    inner_offset = next_offset;
5949                } else {
5950                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5951                    inner_depth.increment()?;
5952                }
5953                let val_ref = self
5954                    .src_addr
5955                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5956                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
5957                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5958                {
5959                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5960                }
5961                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5962                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5963                }
5964            }
5965
5966            next_offset += envelope_size;
5967            _next_ordinal_to_read += 1;
5968            if next_offset >= end_offset {
5969                return Ok(());
5970            }
5971
5972            // Decode unknown envelopes for gaps in ordinals.
5973            while _next_ordinal_to_read < 2 {
5974                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5975                _next_ordinal_to_read += 1;
5976                next_offset += envelope_size;
5977            }
5978
5979            let next_out_of_line = decoder.next_out_of_line();
5980            let handles_before = decoder.remaining_handles();
5981            if let Some((inlined, num_bytes, num_handles)) =
5982                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5983            {
5984                let member_inline_size =
5985                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
5986                        decoder.context,
5987                    );
5988                if inlined != (member_inline_size <= 4) {
5989                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5990                }
5991                let inner_offset;
5992                let mut inner_depth = depth.clone();
5993                if inlined {
5994                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5995                    inner_offset = next_offset;
5996                } else {
5997                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5998                    inner_depth.increment()?;
5999                }
6000                let val_ref = self
6001                    .dst_addr
6002                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
6003                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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            _next_ordinal_to_read += 1;
6015            if next_offset >= end_offset {
6016                return Ok(());
6017            }
6018
6019            // Decode unknown envelopes for gaps in ordinals.
6020            while _next_ordinal_to_read < 3 {
6021                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6022                _next_ordinal_to_read += 1;
6023                next_offset += envelope_size;
6024            }
6025
6026            let next_out_of_line = decoder.next_out_of_line();
6027            let handles_before = decoder.remaining_handles();
6028            if let Some((inlined, num_bytes, num_handles)) =
6029                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6030            {
6031                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6032                if inlined != (member_inline_size <= 4) {
6033                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6034                }
6035                let inner_offset;
6036                let mut inner_depth = depth.clone();
6037                if inlined {
6038                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6039                    inner_offset = next_offset;
6040                } else {
6041                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6042                    inner_depth.increment()?;
6043                }
6044                let val_ref = self.data.get_or_insert_with(|| {
6045                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
6046                });
6047                fidl::decode!(
6048                    fidl::encoding::UnboundedVector<u8>,
6049                    D,
6050                    val_ref,
6051                    decoder,
6052                    inner_offset,
6053                    inner_depth
6054                )?;
6055                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6056                {
6057                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6058                }
6059                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6060                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6061                }
6062            }
6063
6064            next_offset += envelope_size;
6065
6066            // Decode the remaining unknown envelopes.
6067            while next_offset < end_offset {
6068                _next_ordinal_to_read += 1;
6069                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6070                next_offset += envelope_size;
6071            }
6072
6073            Ok(())
6074        }
6075    }
6076
6077    impl WlanFullmacImplIfcAssocIndRequest {
6078        #[inline(always)]
6079        fn max_ordinal_present(&self) -> u64 {
6080            if let Some(_) = self.vendor_ie {
6081                return 5;
6082            }
6083            if let Some(_) = self.rsne {
6084                return 4;
6085            }
6086            if let Some(_) = self.ssid {
6087                return 3;
6088            }
6089            if let Some(_) = self.listen_interval {
6090                return 2;
6091            }
6092            if let Some(_) = self.peer_sta_address {
6093                return 1;
6094            }
6095            0
6096        }
6097    }
6098
6099    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcAssocIndRequest {
6100        type Borrowed<'a> = &'a Self;
6101        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6102            value
6103        }
6104    }
6105
6106    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcAssocIndRequest {
6107        type Owned = Self;
6108
6109        #[inline(always)]
6110        fn inline_align(_context: fidl::encoding::Context) -> usize {
6111            8
6112        }
6113
6114        #[inline(always)]
6115        fn inline_size(_context: fidl::encoding::Context) -> usize {
6116            16
6117        }
6118    }
6119
6120    unsafe impl<D: fidl::encoding::ResourceDialect>
6121        fidl::encoding::Encode<WlanFullmacImplIfcAssocIndRequest, D>
6122        for &WlanFullmacImplIfcAssocIndRequest
6123    {
6124        unsafe fn encode(
6125            self,
6126            encoder: &mut fidl::encoding::Encoder<'_, D>,
6127            offset: usize,
6128            mut depth: fidl::encoding::Depth,
6129        ) -> fidl::Result<()> {
6130            encoder.debug_check_bounds::<WlanFullmacImplIfcAssocIndRequest>(offset);
6131            // Vector header
6132            let max_ordinal: u64 = self.max_ordinal_present();
6133            encoder.write_num(max_ordinal, offset);
6134            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6135            // Calling encoder.out_of_line_offset(0) is not allowed.
6136            if max_ordinal == 0 {
6137                return Ok(());
6138            }
6139            depth.increment()?;
6140            let envelope_size = 8;
6141            let bytes_len = max_ordinal as usize * envelope_size;
6142            #[allow(unused_variables)]
6143            let offset = encoder.out_of_line_offset(bytes_len);
6144            let mut _prev_end_offset: usize = 0;
6145            if 1 > max_ordinal {
6146                return Ok(());
6147            }
6148
6149            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6150            // are envelope_size bytes.
6151            let cur_offset: usize = (1 - 1) * envelope_size;
6152
6153            // Zero reserved fields.
6154            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6155
6156            // Safety:
6157            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6158            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6159            //   envelope_size bytes, there is always sufficient room.
6160            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
6161                self.peer_sta_address
6162                    .as_ref()
6163                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
6164                encoder,
6165                offset + cur_offset,
6166                depth,
6167            )?;
6168
6169            _prev_end_offset = cur_offset + envelope_size;
6170            if 2 > max_ordinal {
6171                return Ok(());
6172            }
6173
6174            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6175            // are envelope_size bytes.
6176            let cur_offset: usize = (2 - 1) * envelope_size;
6177
6178            // Zero reserved fields.
6179            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6180
6181            // Safety:
6182            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6183            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6184            //   envelope_size bytes, there is always sufficient room.
6185            fidl::encoding::encode_in_envelope_optional::<u16, D>(
6186                self.listen_interval.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6187                encoder,
6188                offset + cur_offset,
6189                depth,
6190            )?;
6191
6192            _prev_end_offset = cur_offset + envelope_size;
6193            if 3 > max_ordinal {
6194                return Ok(());
6195            }
6196
6197            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6198            // are envelope_size bytes.
6199            let cur_offset: usize = (3 - 1) * envelope_size;
6200
6201            // Zero reserved fields.
6202            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6203
6204            // Safety:
6205            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6206            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6207            //   envelope_size bytes, there is always sufficient room.
6208            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
6209                self.ssid.as_ref().map(
6210                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
6211                ),
6212                encoder,
6213                offset + cur_offset,
6214                depth,
6215            )?;
6216
6217            _prev_end_offset = cur_offset + envelope_size;
6218            if 4 > max_ordinal {
6219                return Ok(());
6220            }
6221
6222            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6223            // are envelope_size bytes.
6224            let cur_offset: usize = (4 - 1) * envelope_size;
6225
6226            // Zero reserved fields.
6227            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6228
6229            // Safety:
6230            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6231            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6232            //   envelope_size bytes, there is always sufficient room.
6233            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 257>, D>(
6234                self.rsne.as_ref().map(
6235                    <fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow,
6236                ),
6237                encoder,
6238                offset + cur_offset,
6239                depth,
6240            )?;
6241
6242            _prev_end_offset = cur_offset + envelope_size;
6243            if 5 > max_ordinal {
6244                return Ok(());
6245            }
6246
6247            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6248            // are envelope_size bytes.
6249            let cur_offset: usize = (5 - 1) * envelope_size;
6250
6251            // Zero reserved fields.
6252            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6253
6254            // Safety:
6255            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6256            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6257            //   envelope_size bytes, there is always sufficient room.
6258            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 514>, D>(
6259                self.vendor_ie.as_ref().map(
6260                    <fidl::encoding::Vector<u8, 514> as fidl::encoding::ValueTypeMarker>::borrow,
6261                ),
6262                encoder,
6263                offset + cur_offset,
6264                depth,
6265            )?;
6266
6267            _prev_end_offset = cur_offset + envelope_size;
6268
6269            Ok(())
6270        }
6271    }
6272
6273    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6274        for WlanFullmacImplIfcAssocIndRequest
6275    {
6276        #[inline(always)]
6277        fn new_empty() -> Self {
6278            Self::default()
6279        }
6280
6281        unsafe fn decode(
6282            &mut self,
6283            decoder: &mut fidl::encoding::Decoder<'_, D>,
6284            offset: usize,
6285            mut depth: fidl::encoding::Depth,
6286        ) -> fidl::Result<()> {
6287            decoder.debug_check_bounds::<Self>(offset);
6288            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6289                None => return Err(fidl::Error::NotNullable),
6290                Some(len) => len,
6291            };
6292            // Calling decoder.out_of_line_offset(0) is not allowed.
6293            if len == 0 {
6294                return Ok(());
6295            };
6296            depth.increment()?;
6297            let envelope_size = 8;
6298            let bytes_len = len * envelope_size;
6299            let offset = decoder.out_of_line_offset(bytes_len)?;
6300            // Decode the envelope for each type.
6301            let mut _next_ordinal_to_read = 0;
6302            let mut next_offset = offset;
6303            let end_offset = offset + bytes_len;
6304            _next_ordinal_to_read += 1;
6305            if next_offset >= end_offset {
6306                return Ok(());
6307            }
6308
6309            // Decode unknown envelopes for gaps in ordinals.
6310            while _next_ordinal_to_read < 1 {
6311                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6312                _next_ordinal_to_read += 1;
6313                next_offset += envelope_size;
6314            }
6315
6316            let next_out_of_line = decoder.next_out_of_line();
6317            let handles_before = decoder.remaining_handles();
6318            if let Some((inlined, num_bytes, num_handles)) =
6319                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6320            {
6321                let member_inline_size =
6322                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
6323                        decoder.context,
6324                    );
6325                if inlined != (member_inline_size <= 4) {
6326                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6327                }
6328                let inner_offset;
6329                let mut inner_depth = depth.clone();
6330                if inlined {
6331                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6332                    inner_offset = next_offset;
6333                } else {
6334                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6335                    inner_depth.increment()?;
6336                }
6337                let val_ref = self
6338                    .peer_sta_address
6339                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
6340                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
6341                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6342                {
6343                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6344                }
6345                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6346                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6347                }
6348            }
6349
6350            next_offset += envelope_size;
6351            _next_ordinal_to_read += 1;
6352            if next_offset >= end_offset {
6353                return Ok(());
6354            }
6355
6356            // Decode unknown envelopes for gaps in ordinals.
6357            while _next_ordinal_to_read < 2 {
6358                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6359                _next_ordinal_to_read += 1;
6360                next_offset += envelope_size;
6361            }
6362
6363            let next_out_of_line = decoder.next_out_of_line();
6364            let handles_before = decoder.remaining_handles();
6365            if let Some((inlined, num_bytes, num_handles)) =
6366                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6367            {
6368                let member_inline_size =
6369                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6370                if inlined != (member_inline_size <= 4) {
6371                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6372                }
6373                let inner_offset;
6374                let mut inner_depth = depth.clone();
6375                if inlined {
6376                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6377                    inner_offset = next_offset;
6378                } else {
6379                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6380                    inner_depth.increment()?;
6381                }
6382                let val_ref = self.listen_interval.get_or_insert_with(|| fidl::new_empty!(u16, D));
6383                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6384                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6385                {
6386                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6387                }
6388                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6389                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6390                }
6391            }
6392
6393            next_offset += envelope_size;
6394            _next_ordinal_to_read += 1;
6395            if next_offset >= end_offset {
6396                return Ok(());
6397            }
6398
6399            // Decode unknown envelopes for gaps in ordinals.
6400            while _next_ordinal_to_read < 3 {
6401                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6402                _next_ordinal_to_read += 1;
6403                next_offset += envelope_size;
6404            }
6405
6406            let next_out_of_line = decoder.next_out_of_line();
6407            let handles_before = decoder.remaining_handles();
6408            if let Some((inlined, num_bytes, num_handles)) =
6409                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6410            {
6411                let member_inline_size =
6412                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
6413                        decoder.context,
6414                    );
6415                if inlined != (member_inline_size <= 4) {
6416                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6417                }
6418                let inner_offset;
6419                let mut inner_depth = depth.clone();
6420                if inlined {
6421                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6422                    inner_offset = next_offset;
6423                } else {
6424                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6425                    inner_depth.increment()?;
6426                }
6427                let val_ref = self
6428                    .ssid
6429                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
6430                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
6431                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6432                {
6433                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6434                }
6435                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6436                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6437                }
6438            }
6439
6440            next_offset += envelope_size;
6441            _next_ordinal_to_read += 1;
6442            if next_offset >= end_offset {
6443                return Ok(());
6444            }
6445
6446            // Decode unknown envelopes for gaps in ordinals.
6447            while _next_ordinal_to_read < 4 {
6448                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6449                _next_ordinal_to_read += 1;
6450                next_offset += envelope_size;
6451            }
6452
6453            let next_out_of_line = decoder.next_out_of_line();
6454            let handles_before = decoder.remaining_handles();
6455            if let Some((inlined, num_bytes, num_handles)) =
6456                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6457            {
6458                let member_inline_size =
6459                    <fidl::encoding::Vector<u8, 257> as fidl::encoding::TypeMarker>::inline_size(
6460                        decoder.context,
6461                    );
6462                if inlined != (member_inline_size <= 4) {
6463                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6464                }
6465                let inner_offset;
6466                let mut inner_depth = depth.clone();
6467                if inlined {
6468                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6469                    inner_offset = next_offset;
6470                } else {
6471                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6472                    inner_depth.increment()?;
6473                }
6474                let val_ref = self
6475                    .rsne
6476                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 257>, D));
6477                fidl::decode!(fidl::encoding::Vector<u8, 257>, D, val_ref, decoder, inner_offset, inner_depth)?;
6478                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6479                {
6480                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6481                }
6482                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6483                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6484                }
6485            }
6486
6487            next_offset += envelope_size;
6488            _next_ordinal_to_read += 1;
6489            if next_offset >= end_offset {
6490                return Ok(());
6491            }
6492
6493            // Decode unknown envelopes for gaps in ordinals.
6494            while _next_ordinal_to_read < 5 {
6495                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6496                _next_ordinal_to_read += 1;
6497                next_offset += envelope_size;
6498            }
6499
6500            let next_out_of_line = decoder.next_out_of_line();
6501            let handles_before = decoder.remaining_handles();
6502            if let Some((inlined, num_bytes, num_handles)) =
6503                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6504            {
6505                let member_inline_size =
6506                    <fidl::encoding::Vector<u8, 514> as fidl::encoding::TypeMarker>::inline_size(
6507                        decoder.context,
6508                    );
6509                if inlined != (member_inline_size <= 4) {
6510                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6511                }
6512                let inner_offset;
6513                let mut inner_depth = depth.clone();
6514                if inlined {
6515                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6516                    inner_offset = next_offset;
6517                } else {
6518                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6519                    inner_depth.increment()?;
6520                }
6521                let val_ref = self
6522                    .vendor_ie
6523                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 514>, D));
6524                fidl::decode!(fidl::encoding::Vector<u8, 514>, D, val_ref, decoder, inner_offset, inner_depth)?;
6525                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6526                {
6527                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6528                }
6529                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6530                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6531                }
6532            }
6533
6534            next_offset += envelope_size;
6535
6536            // Decode the remaining unknown envelopes.
6537            while next_offset < end_offset {
6538                _next_ordinal_to_read += 1;
6539                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6540                next_offset += envelope_size;
6541            }
6542
6543            Ok(())
6544        }
6545    }
6546
6547    impl WlanFullmacImplIfcAuthIndRequest {
6548        #[inline(always)]
6549        fn max_ordinal_present(&self) -> u64 {
6550            if let Some(_) = self.auth_type {
6551                return 2;
6552            }
6553            if let Some(_) = self.peer_sta_address {
6554                return 1;
6555            }
6556            0
6557        }
6558    }
6559
6560    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcAuthIndRequest {
6561        type Borrowed<'a> = &'a Self;
6562        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6563            value
6564        }
6565    }
6566
6567    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcAuthIndRequest {
6568        type Owned = Self;
6569
6570        #[inline(always)]
6571        fn inline_align(_context: fidl::encoding::Context) -> usize {
6572            8
6573        }
6574
6575        #[inline(always)]
6576        fn inline_size(_context: fidl::encoding::Context) -> usize {
6577            16
6578        }
6579    }
6580
6581    unsafe impl<D: fidl::encoding::ResourceDialect>
6582        fidl::encoding::Encode<WlanFullmacImplIfcAuthIndRequest, D>
6583        for &WlanFullmacImplIfcAuthIndRequest
6584    {
6585        unsafe fn encode(
6586            self,
6587            encoder: &mut fidl::encoding::Encoder<'_, D>,
6588            offset: usize,
6589            mut depth: fidl::encoding::Depth,
6590        ) -> fidl::Result<()> {
6591            encoder.debug_check_bounds::<WlanFullmacImplIfcAuthIndRequest>(offset);
6592            // Vector header
6593            let max_ordinal: u64 = self.max_ordinal_present();
6594            encoder.write_num(max_ordinal, offset);
6595            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6596            // Calling encoder.out_of_line_offset(0) is not allowed.
6597            if max_ordinal == 0 {
6598                return Ok(());
6599            }
6600            depth.increment()?;
6601            let envelope_size = 8;
6602            let bytes_len = max_ordinal as usize * envelope_size;
6603            #[allow(unused_variables)]
6604            let offset = encoder.out_of_line_offset(bytes_len);
6605            let mut _prev_end_offset: usize = 0;
6606            if 1 > max_ordinal {
6607                return Ok(());
6608            }
6609
6610            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6611            // are envelope_size bytes.
6612            let cur_offset: usize = (1 - 1) * envelope_size;
6613
6614            // Zero reserved fields.
6615            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6616
6617            // Safety:
6618            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6619            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6620            //   envelope_size bytes, there is always sufficient room.
6621            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
6622                self.peer_sta_address
6623                    .as_ref()
6624                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
6625                encoder,
6626                offset + cur_offset,
6627                depth,
6628            )?;
6629
6630            _prev_end_offset = cur_offset + envelope_size;
6631            if 2 > max_ordinal {
6632                return Ok(());
6633            }
6634
6635            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6636            // are envelope_size bytes.
6637            let cur_offset: usize = (2 - 1) * envelope_size;
6638
6639            // Zero reserved fields.
6640            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6641
6642            // Safety:
6643            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6644            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6645            //   envelope_size bytes, there is always sufficient room.
6646            fidl::encoding::encode_in_envelope_optional::<WlanAuthType, D>(
6647                self.auth_type
6648                    .as_ref()
6649                    .map(<WlanAuthType as fidl::encoding::ValueTypeMarker>::borrow),
6650                encoder,
6651                offset + cur_offset,
6652                depth,
6653            )?;
6654
6655            _prev_end_offset = cur_offset + envelope_size;
6656
6657            Ok(())
6658        }
6659    }
6660
6661    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6662        for WlanFullmacImplIfcAuthIndRequest
6663    {
6664        #[inline(always)]
6665        fn new_empty() -> Self {
6666            Self::default()
6667        }
6668
6669        unsafe fn decode(
6670            &mut self,
6671            decoder: &mut fidl::encoding::Decoder<'_, D>,
6672            offset: usize,
6673            mut depth: fidl::encoding::Depth,
6674        ) -> fidl::Result<()> {
6675            decoder.debug_check_bounds::<Self>(offset);
6676            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6677                None => return Err(fidl::Error::NotNullable),
6678                Some(len) => len,
6679            };
6680            // Calling decoder.out_of_line_offset(0) is not allowed.
6681            if len == 0 {
6682                return Ok(());
6683            };
6684            depth.increment()?;
6685            let envelope_size = 8;
6686            let bytes_len = len * envelope_size;
6687            let offset = decoder.out_of_line_offset(bytes_len)?;
6688            // Decode the envelope for each type.
6689            let mut _next_ordinal_to_read = 0;
6690            let mut next_offset = offset;
6691            let end_offset = offset + bytes_len;
6692            _next_ordinal_to_read += 1;
6693            if next_offset >= end_offset {
6694                return Ok(());
6695            }
6696
6697            // Decode unknown envelopes for gaps in ordinals.
6698            while _next_ordinal_to_read < 1 {
6699                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6700                _next_ordinal_to_read += 1;
6701                next_offset += envelope_size;
6702            }
6703
6704            let next_out_of_line = decoder.next_out_of_line();
6705            let handles_before = decoder.remaining_handles();
6706            if let Some((inlined, num_bytes, num_handles)) =
6707                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6708            {
6709                let member_inline_size =
6710                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
6711                        decoder.context,
6712                    );
6713                if inlined != (member_inline_size <= 4) {
6714                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6715                }
6716                let inner_offset;
6717                let mut inner_depth = depth.clone();
6718                if inlined {
6719                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6720                    inner_offset = next_offset;
6721                } else {
6722                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6723                    inner_depth.increment()?;
6724                }
6725                let val_ref = self
6726                    .peer_sta_address
6727                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
6728                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
6729                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6730                {
6731                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6732                }
6733                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6734                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6735                }
6736            }
6737
6738            next_offset += envelope_size;
6739            _next_ordinal_to_read += 1;
6740            if next_offset >= end_offset {
6741                return Ok(());
6742            }
6743
6744            // Decode unknown envelopes for gaps in ordinals.
6745            while _next_ordinal_to_read < 2 {
6746                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6747                _next_ordinal_to_read += 1;
6748                next_offset += envelope_size;
6749            }
6750
6751            let next_out_of_line = decoder.next_out_of_line();
6752            let handles_before = decoder.remaining_handles();
6753            if let Some((inlined, num_bytes, num_handles)) =
6754                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6755            {
6756                let member_inline_size =
6757                    <WlanAuthType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6758                if inlined != (member_inline_size <= 4) {
6759                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6760                }
6761                let inner_offset;
6762                let mut inner_depth = depth.clone();
6763                if inlined {
6764                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6765                    inner_offset = next_offset;
6766                } else {
6767                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6768                    inner_depth.increment()?;
6769                }
6770                let val_ref =
6771                    self.auth_type.get_or_insert_with(|| fidl::new_empty!(WlanAuthType, D));
6772                fidl::decode!(WlanAuthType, D, val_ref, decoder, inner_offset, inner_depth)?;
6773                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6774                {
6775                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6776                }
6777                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6778                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6779                }
6780            }
6781
6782            next_offset += envelope_size;
6783
6784            // Decode the remaining unknown envelopes.
6785            while next_offset < end_offset {
6786                _next_ordinal_to_read += 1;
6787                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6788                next_offset += envelope_size;
6789            }
6790
6791            Ok(())
6792        }
6793    }
6794
6795    impl WlanFullmacImplIfcConnectConfRequest {
6796        #[inline(always)]
6797        fn max_ordinal_present(&self) -> u64 {
6798            if let Some(_) = self.association_ies {
6799                return 4;
6800            }
6801            if let Some(_) = self.association_id {
6802                return 3;
6803            }
6804            if let Some(_) = self.result_code {
6805                return 2;
6806            }
6807            if let Some(_) = self.peer_sta_address {
6808                return 1;
6809            }
6810            0
6811        }
6812    }
6813
6814    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcConnectConfRequest {
6815        type Borrowed<'a> = &'a Self;
6816        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6817            value
6818        }
6819    }
6820
6821    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcConnectConfRequest {
6822        type Owned = Self;
6823
6824        #[inline(always)]
6825        fn inline_align(_context: fidl::encoding::Context) -> usize {
6826            8
6827        }
6828
6829        #[inline(always)]
6830        fn inline_size(_context: fidl::encoding::Context) -> usize {
6831            16
6832        }
6833    }
6834
6835    unsafe impl<D: fidl::encoding::ResourceDialect>
6836        fidl::encoding::Encode<WlanFullmacImplIfcConnectConfRequest, D>
6837        for &WlanFullmacImplIfcConnectConfRequest
6838    {
6839        unsafe fn encode(
6840            self,
6841            encoder: &mut fidl::encoding::Encoder<'_, D>,
6842            offset: usize,
6843            mut depth: fidl::encoding::Depth,
6844        ) -> fidl::Result<()> {
6845            encoder.debug_check_bounds::<WlanFullmacImplIfcConnectConfRequest>(offset);
6846            // Vector header
6847            let max_ordinal: u64 = self.max_ordinal_present();
6848            encoder.write_num(max_ordinal, offset);
6849            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6850            // Calling encoder.out_of_line_offset(0) is not allowed.
6851            if max_ordinal == 0 {
6852                return Ok(());
6853            }
6854            depth.increment()?;
6855            let envelope_size = 8;
6856            let bytes_len = max_ordinal as usize * envelope_size;
6857            #[allow(unused_variables)]
6858            let offset = encoder.out_of_line_offset(bytes_len);
6859            let mut _prev_end_offset: usize = 0;
6860            if 1 > max_ordinal {
6861                return Ok(());
6862            }
6863
6864            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6865            // are envelope_size bytes.
6866            let cur_offset: usize = (1 - 1) * envelope_size;
6867
6868            // Zero reserved fields.
6869            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6870
6871            // Safety:
6872            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6873            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6874            //   envelope_size bytes, there is always sufficient room.
6875            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
6876                self.peer_sta_address
6877                    .as_ref()
6878                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
6879                encoder,
6880                offset + cur_offset,
6881                depth,
6882            )?;
6883
6884            _prev_end_offset = cur_offset + envelope_size;
6885            if 2 > max_ordinal {
6886                return Ok(());
6887            }
6888
6889            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6890            // are envelope_size bytes.
6891            let cur_offset: usize = (2 - 1) * envelope_size;
6892
6893            // Zero reserved fields.
6894            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6895
6896            // Safety:
6897            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6898            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6899            //   envelope_size bytes, there is always sufficient room.
6900            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
6901            self.result_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
6902            encoder, offset + cur_offset, depth
6903        )?;
6904
6905            _prev_end_offset = cur_offset + envelope_size;
6906            if 3 > max_ordinal {
6907                return Ok(());
6908            }
6909
6910            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6911            // are envelope_size bytes.
6912            let cur_offset: usize = (3 - 1) * envelope_size;
6913
6914            // Zero reserved fields.
6915            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6916
6917            // Safety:
6918            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6919            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6920            //   envelope_size bytes, there is always sufficient room.
6921            fidl::encoding::encode_in_envelope_optional::<u16, D>(
6922                self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6923                encoder,
6924                offset + cur_offset,
6925                depth,
6926            )?;
6927
6928            _prev_end_offset = cur_offset + envelope_size;
6929            if 4 > max_ordinal {
6930                return Ok(());
6931            }
6932
6933            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6934            // are envelope_size bytes.
6935            let cur_offset: usize = (4 - 1) * envelope_size;
6936
6937            // Zero reserved fields.
6938            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6939
6940            // Safety:
6941            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6942            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6943            //   envelope_size bytes, there is always sufficient room.
6944            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
6945            self.association_ies.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
6946            encoder, offset + cur_offset, depth
6947        )?;
6948
6949            _prev_end_offset = cur_offset + envelope_size;
6950
6951            Ok(())
6952        }
6953    }
6954
6955    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6956        for WlanFullmacImplIfcConnectConfRequest
6957    {
6958        #[inline(always)]
6959        fn new_empty() -> Self {
6960            Self::default()
6961        }
6962
6963        unsafe fn decode(
6964            &mut self,
6965            decoder: &mut fidl::encoding::Decoder<'_, D>,
6966            offset: usize,
6967            mut depth: fidl::encoding::Depth,
6968        ) -> fidl::Result<()> {
6969            decoder.debug_check_bounds::<Self>(offset);
6970            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6971                None => return Err(fidl::Error::NotNullable),
6972                Some(len) => len,
6973            };
6974            // Calling decoder.out_of_line_offset(0) is not allowed.
6975            if len == 0 {
6976                return Ok(());
6977            };
6978            depth.increment()?;
6979            let envelope_size = 8;
6980            let bytes_len = len * envelope_size;
6981            let offset = decoder.out_of_line_offset(bytes_len)?;
6982            // Decode the envelope for each type.
6983            let mut _next_ordinal_to_read = 0;
6984            let mut next_offset = offset;
6985            let end_offset = offset + bytes_len;
6986            _next_ordinal_to_read += 1;
6987            if next_offset >= end_offset {
6988                return Ok(());
6989            }
6990
6991            // Decode unknown envelopes for gaps in ordinals.
6992            while _next_ordinal_to_read < 1 {
6993                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6994                _next_ordinal_to_read += 1;
6995                next_offset += envelope_size;
6996            }
6997
6998            let next_out_of_line = decoder.next_out_of_line();
6999            let handles_before = decoder.remaining_handles();
7000            if let Some((inlined, num_bytes, num_handles)) =
7001                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7002            {
7003                let member_inline_size =
7004                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
7005                        decoder.context,
7006                    );
7007                if inlined != (member_inline_size <= 4) {
7008                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7009                }
7010                let inner_offset;
7011                let mut inner_depth = depth.clone();
7012                if inlined {
7013                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7014                    inner_offset = next_offset;
7015                } else {
7016                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7017                    inner_depth.increment()?;
7018                }
7019                let val_ref = self
7020                    .peer_sta_address
7021                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
7022                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7051                if inlined != (member_inline_size <= 4) {
7052                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7053                }
7054                let inner_offset;
7055                let mut inner_depth = depth.clone();
7056                if inlined {
7057                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7058                    inner_offset = next_offset;
7059                } else {
7060                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7061                    inner_depth.increment()?;
7062                }
7063                let val_ref = self.result_code.get_or_insert_with(|| {
7064                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
7065                });
7066                fidl::decode!(
7067                    fidl_fuchsia_wlan_ieee80211__common::StatusCode,
7068                    D,
7069                    val_ref,
7070                    decoder,
7071                    inner_offset,
7072                    inner_depth
7073                )?;
7074                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7075                {
7076                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7077                }
7078                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7079                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7080                }
7081            }
7082
7083            next_offset += envelope_size;
7084            _next_ordinal_to_read += 1;
7085            if next_offset >= end_offset {
7086                return Ok(());
7087            }
7088
7089            // Decode unknown envelopes for gaps in ordinals.
7090            while _next_ordinal_to_read < 3 {
7091                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7092                _next_ordinal_to_read += 1;
7093                next_offset += envelope_size;
7094            }
7095
7096            let next_out_of_line = decoder.next_out_of_line();
7097            let handles_before = decoder.remaining_handles();
7098            if let Some((inlined, num_bytes, num_handles)) =
7099                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7100            {
7101                let member_inline_size =
7102                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7103                if inlined != (member_inline_size <= 4) {
7104                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7105                }
7106                let inner_offset;
7107                let mut inner_depth = depth.clone();
7108                if inlined {
7109                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7110                    inner_offset = next_offset;
7111                } else {
7112                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7113                    inner_depth.increment()?;
7114                }
7115                let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
7116                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
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            _next_ordinal_to_read += 1;
7128            if next_offset >= end_offset {
7129                return Ok(());
7130            }
7131
7132            // Decode unknown envelopes for gaps in ordinals.
7133            while _next_ordinal_to_read < 4 {
7134                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7135                _next_ordinal_to_read += 1;
7136                next_offset += envelope_size;
7137            }
7138
7139            let next_out_of_line = decoder.next_out_of_line();
7140            let handles_before = decoder.remaining_handles();
7141            if let Some((inlined, num_bytes, num_handles)) =
7142                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7143            {
7144                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7145                if inlined != (member_inline_size <= 4) {
7146                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7147                }
7148                let inner_offset;
7149                let mut inner_depth = depth.clone();
7150                if inlined {
7151                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7152                    inner_offset = next_offset;
7153                } else {
7154                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7155                    inner_depth.increment()?;
7156                }
7157                let val_ref = self.association_ies.get_or_insert_with(|| {
7158                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
7159                });
7160                fidl::decode!(
7161                    fidl::encoding::UnboundedVector<u8>,
7162                    D,
7163                    val_ref,
7164                    decoder,
7165                    inner_offset,
7166                    inner_depth
7167                )?;
7168                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7169                {
7170                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7171                }
7172                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7173                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7174                }
7175            }
7176
7177            next_offset += envelope_size;
7178
7179            // Decode the remaining unknown envelopes.
7180            while next_offset < end_offset {
7181                _next_ordinal_to_read += 1;
7182                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7183                next_offset += envelope_size;
7184            }
7185
7186            Ok(())
7187        }
7188    }
7189
7190    impl WlanFullmacImplIfcDeauthConfRequest {
7191        #[inline(always)]
7192        fn max_ordinal_present(&self) -> u64 {
7193            if let Some(_) = self.peer_sta_address {
7194                return 1;
7195            }
7196            0
7197        }
7198    }
7199
7200    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDeauthConfRequest {
7201        type Borrowed<'a> = &'a Self;
7202        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7203            value
7204        }
7205    }
7206
7207    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDeauthConfRequest {
7208        type Owned = Self;
7209
7210        #[inline(always)]
7211        fn inline_align(_context: fidl::encoding::Context) -> usize {
7212            8
7213        }
7214
7215        #[inline(always)]
7216        fn inline_size(_context: fidl::encoding::Context) -> usize {
7217            16
7218        }
7219    }
7220
7221    unsafe impl<D: fidl::encoding::ResourceDialect>
7222        fidl::encoding::Encode<WlanFullmacImplIfcDeauthConfRequest, D>
7223        for &WlanFullmacImplIfcDeauthConfRequest
7224    {
7225        unsafe fn encode(
7226            self,
7227            encoder: &mut fidl::encoding::Encoder<'_, D>,
7228            offset: usize,
7229            mut depth: fidl::encoding::Depth,
7230        ) -> fidl::Result<()> {
7231            encoder.debug_check_bounds::<WlanFullmacImplIfcDeauthConfRequest>(offset);
7232            // Vector header
7233            let max_ordinal: u64 = self.max_ordinal_present();
7234            encoder.write_num(max_ordinal, offset);
7235            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7236            // Calling encoder.out_of_line_offset(0) is not allowed.
7237            if max_ordinal == 0 {
7238                return Ok(());
7239            }
7240            depth.increment()?;
7241            let envelope_size = 8;
7242            let bytes_len = max_ordinal as usize * envelope_size;
7243            #[allow(unused_variables)]
7244            let offset = encoder.out_of_line_offset(bytes_len);
7245            let mut _prev_end_offset: usize = 0;
7246            if 1 > max_ordinal {
7247                return Ok(());
7248            }
7249
7250            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7251            // are envelope_size bytes.
7252            let cur_offset: usize = (1 - 1) * envelope_size;
7253
7254            // Zero reserved fields.
7255            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7256
7257            // Safety:
7258            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7259            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7260            //   envelope_size bytes, there is always sufficient room.
7261            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
7262                self.peer_sta_address
7263                    .as_ref()
7264                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
7265                encoder,
7266                offset + cur_offset,
7267                depth,
7268            )?;
7269
7270            _prev_end_offset = cur_offset + envelope_size;
7271
7272            Ok(())
7273        }
7274    }
7275
7276    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7277        for WlanFullmacImplIfcDeauthConfRequest
7278    {
7279        #[inline(always)]
7280        fn new_empty() -> Self {
7281            Self::default()
7282        }
7283
7284        unsafe fn decode(
7285            &mut self,
7286            decoder: &mut fidl::encoding::Decoder<'_, D>,
7287            offset: usize,
7288            mut depth: fidl::encoding::Depth,
7289        ) -> fidl::Result<()> {
7290            decoder.debug_check_bounds::<Self>(offset);
7291            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7292                None => return Err(fidl::Error::NotNullable),
7293                Some(len) => len,
7294            };
7295            // Calling decoder.out_of_line_offset(0) is not allowed.
7296            if len == 0 {
7297                return Ok(());
7298            };
7299            depth.increment()?;
7300            let envelope_size = 8;
7301            let bytes_len = len * envelope_size;
7302            let offset = decoder.out_of_line_offset(bytes_len)?;
7303            // Decode the envelope for each type.
7304            let mut _next_ordinal_to_read = 0;
7305            let mut next_offset = offset;
7306            let end_offset = offset + bytes_len;
7307            _next_ordinal_to_read += 1;
7308            if next_offset >= end_offset {
7309                return Ok(());
7310            }
7311
7312            // Decode unknown envelopes for gaps in ordinals.
7313            while _next_ordinal_to_read < 1 {
7314                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7315                _next_ordinal_to_read += 1;
7316                next_offset += envelope_size;
7317            }
7318
7319            let next_out_of_line = decoder.next_out_of_line();
7320            let handles_before = decoder.remaining_handles();
7321            if let Some((inlined, num_bytes, num_handles)) =
7322                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7323            {
7324                let member_inline_size =
7325                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
7326                        decoder.context,
7327                    );
7328                if inlined != (member_inline_size <= 4) {
7329                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7330                }
7331                let inner_offset;
7332                let mut inner_depth = depth.clone();
7333                if inlined {
7334                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7335                    inner_offset = next_offset;
7336                } else {
7337                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7338                    inner_depth.increment()?;
7339                }
7340                let val_ref = self
7341                    .peer_sta_address
7342                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
7343                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
7344                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7345                {
7346                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7347                }
7348                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7349                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7350                }
7351            }
7352
7353            next_offset += envelope_size;
7354
7355            // Decode the remaining unknown envelopes.
7356            while next_offset < end_offset {
7357                _next_ordinal_to_read += 1;
7358                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7359                next_offset += envelope_size;
7360            }
7361
7362            Ok(())
7363        }
7364    }
7365
7366    impl WlanFullmacImplIfcDeauthIndRequest {
7367        #[inline(always)]
7368        fn max_ordinal_present(&self) -> u64 {
7369            if let Some(_) = self.locally_initiated {
7370                return 3;
7371            }
7372            if let Some(_) = self.reason_code {
7373                return 2;
7374            }
7375            if let Some(_) = self.peer_sta_address {
7376                return 1;
7377            }
7378            0
7379        }
7380    }
7381
7382    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDeauthIndRequest {
7383        type Borrowed<'a> = &'a Self;
7384        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7385            value
7386        }
7387    }
7388
7389    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDeauthIndRequest {
7390        type Owned = Self;
7391
7392        #[inline(always)]
7393        fn inline_align(_context: fidl::encoding::Context) -> usize {
7394            8
7395        }
7396
7397        #[inline(always)]
7398        fn inline_size(_context: fidl::encoding::Context) -> usize {
7399            16
7400        }
7401    }
7402
7403    unsafe impl<D: fidl::encoding::ResourceDialect>
7404        fidl::encoding::Encode<WlanFullmacImplIfcDeauthIndRequest, D>
7405        for &WlanFullmacImplIfcDeauthIndRequest
7406    {
7407        unsafe fn encode(
7408            self,
7409            encoder: &mut fidl::encoding::Encoder<'_, D>,
7410            offset: usize,
7411            mut depth: fidl::encoding::Depth,
7412        ) -> fidl::Result<()> {
7413            encoder.debug_check_bounds::<WlanFullmacImplIfcDeauthIndRequest>(offset);
7414            // Vector header
7415            let max_ordinal: u64 = self.max_ordinal_present();
7416            encoder.write_num(max_ordinal, offset);
7417            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7418            // Calling encoder.out_of_line_offset(0) is not allowed.
7419            if max_ordinal == 0 {
7420                return Ok(());
7421            }
7422            depth.increment()?;
7423            let envelope_size = 8;
7424            let bytes_len = max_ordinal as usize * envelope_size;
7425            #[allow(unused_variables)]
7426            let offset = encoder.out_of_line_offset(bytes_len);
7427            let mut _prev_end_offset: usize = 0;
7428            if 1 > max_ordinal {
7429                return Ok(());
7430            }
7431
7432            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7433            // are envelope_size bytes.
7434            let cur_offset: usize = (1 - 1) * envelope_size;
7435
7436            // Zero reserved fields.
7437            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7438
7439            // Safety:
7440            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7441            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7442            //   envelope_size bytes, there is always sufficient room.
7443            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
7444                self.peer_sta_address
7445                    .as_ref()
7446                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
7447                encoder,
7448                offset + cur_offset,
7449                depth,
7450            )?;
7451
7452            _prev_end_offset = cur_offset + envelope_size;
7453            if 2 > max_ordinal {
7454                return Ok(());
7455            }
7456
7457            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7458            // are envelope_size bytes.
7459            let cur_offset: usize = (2 - 1) * envelope_size;
7460
7461            // Zero reserved fields.
7462            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7463
7464            // Safety:
7465            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7466            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7467            //   envelope_size bytes, there is always sufficient room.
7468            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
7469            self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
7470            encoder, offset + cur_offset, depth
7471        )?;
7472
7473            _prev_end_offset = cur_offset + envelope_size;
7474            if 3 > max_ordinal {
7475                return Ok(());
7476            }
7477
7478            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7479            // are envelope_size bytes.
7480            let cur_offset: usize = (3 - 1) * envelope_size;
7481
7482            // Zero reserved fields.
7483            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7484
7485            // Safety:
7486            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7487            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7488            //   envelope_size bytes, there is always sufficient room.
7489            fidl::encoding::encode_in_envelope_optional::<bool, D>(
7490                self.locally_initiated
7491                    .as_ref()
7492                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7493                encoder,
7494                offset + cur_offset,
7495                depth,
7496            )?;
7497
7498            _prev_end_offset = cur_offset + envelope_size;
7499
7500            Ok(())
7501        }
7502    }
7503
7504    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7505        for WlanFullmacImplIfcDeauthIndRequest
7506    {
7507        #[inline(always)]
7508        fn new_empty() -> Self {
7509            Self::default()
7510        }
7511
7512        unsafe fn decode(
7513            &mut self,
7514            decoder: &mut fidl::encoding::Decoder<'_, D>,
7515            offset: usize,
7516            mut depth: fidl::encoding::Depth,
7517        ) -> fidl::Result<()> {
7518            decoder.debug_check_bounds::<Self>(offset);
7519            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7520                None => return Err(fidl::Error::NotNullable),
7521                Some(len) => len,
7522            };
7523            // Calling decoder.out_of_line_offset(0) is not allowed.
7524            if len == 0 {
7525                return Ok(());
7526            };
7527            depth.increment()?;
7528            let envelope_size = 8;
7529            let bytes_len = len * envelope_size;
7530            let offset = decoder.out_of_line_offset(bytes_len)?;
7531            // Decode the envelope for each type.
7532            let mut _next_ordinal_to_read = 0;
7533            let mut next_offset = offset;
7534            let end_offset = offset + bytes_len;
7535            _next_ordinal_to_read += 1;
7536            if next_offset >= end_offset {
7537                return Ok(());
7538            }
7539
7540            // Decode unknown envelopes for gaps in ordinals.
7541            while _next_ordinal_to_read < 1 {
7542                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7543                _next_ordinal_to_read += 1;
7544                next_offset += envelope_size;
7545            }
7546
7547            let next_out_of_line = decoder.next_out_of_line();
7548            let handles_before = decoder.remaining_handles();
7549            if let Some((inlined, num_bytes, num_handles)) =
7550                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7551            {
7552                let member_inline_size =
7553                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
7554                        decoder.context,
7555                    );
7556                if inlined != (member_inline_size <= 4) {
7557                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7558                }
7559                let inner_offset;
7560                let mut inner_depth = depth.clone();
7561                if inlined {
7562                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7563                    inner_offset = next_offset;
7564                } else {
7565                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7566                    inner_depth.increment()?;
7567                }
7568                let val_ref = self
7569                    .peer_sta_address
7570                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
7571                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7600                if inlined != (member_inline_size <= 4) {
7601                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7602                }
7603                let inner_offset;
7604                let mut inner_depth = depth.clone();
7605                if inlined {
7606                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7607                    inner_offset = next_offset;
7608                } else {
7609                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7610                    inner_depth.increment()?;
7611                }
7612                let val_ref = self.reason_code.get_or_insert_with(|| {
7613                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
7614                });
7615                fidl::decode!(
7616                    fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
7617                    D,
7618                    val_ref,
7619                    decoder,
7620                    inner_offset,
7621                    inner_depth
7622                )?;
7623                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7624                {
7625                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7626                }
7627                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7628                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7629                }
7630            }
7631
7632            next_offset += envelope_size;
7633            _next_ordinal_to_read += 1;
7634            if next_offset >= end_offset {
7635                return Ok(());
7636            }
7637
7638            // Decode unknown envelopes for gaps in ordinals.
7639            while _next_ordinal_to_read < 3 {
7640                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7641                _next_ordinal_to_read += 1;
7642                next_offset += envelope_size;
7643            }
7644
7645            let next_out_of_line = decoder.next_out_of_line();
7646            let handles_before = decoder.remaining_handles();
7647            if let Some((inlined, num_bytes, num_handles)) =
7648                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7649            {
7650                let member_inline_size =
7651                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7652                if inlined != (member_inline_size <= 4) {
7653                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7654                }
7655                let inner_offset;
7656                let mut inner_depth = depth.clone();
7657                if inlined {
7658                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7659                    inner_offset = next_offset;
7660                } else {
7661                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7662                    inner_depth.increment()?;
7663                }
7664                let val_ref =
7665                    self.locally_initiated.get_or_insert_with(|| fidl::new_empty!(bool, D));
7666                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7667                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7668                {
7669                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7670                }
7671                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7672                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7673                }
7674            }
7675
7676            next_offset += envelope_size;
7677
7678            // Decode the remaining unknown envelopes.
7679            while next_offset < end_offset {
7680                _next_ordinal_to_read += 1;
7681                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7682                next_offset += envelope_size;
7683            }
7684
7685            Ok(())
7686        }
7687    }
7688
7689    impl WlanFullmacImplIfcDisassocConfRequest {
7690        #[inline(always)]
7691        fn max_ordinal_present(&self) -> u64 {
7692            if let Some(_) = self.status {
7693                return 1;
7694            }
7695            0
7696        }
7697    }
7698
7699    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDisassocConfRequest {
7700        type Borrowed<'a> = &'a Self;
7701        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7702            value
7703        }
7704    }
7705
7706    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDisassocConfRequest {
7707        type Owned = Self;
7708
7709        #[inline(always)]
7710        fn inline_align(_context: fidl::encoding::Context) -> usize {
7711            8
7712        }
7713
7714        #[inline(always)]
7715        fn inline_size(_context: fidl::encoding::Context) -> usize {
7716            16
7717        }
7718    }
7719
7720    unsafe impl<D: fidl::encoding::ResourceDialect>
7721        fidl::encoding::Encode<WlanFullmacImplIfcDisassocConfRequest, D>
7722        for &WlanFullmacImplIfcDisassocConfRequest
7723    {
7724        unsafe fn encode(
7725            self,
7726            encoder: &mut fidl::encoding::Encoder<'_, D>,
7727            offset: usize,
7728            mut depth: fidl::encoding::Depth,
7729        ) -> fidl::Result<()> {
7730            encoder.debug_check_bounds::<WlanFullmacImplIfcDisassocConfRequest>(offset);
7731            // Vector header
7732            let max_ordinal: u64 = self.max_ordinal_present();
7733            encoder.write_num(max_ordinal, offset);
7734            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7735            // Calling encoder.out_of_line_offset(0) is not allowed.
7736            if max_ordinal == 0 {
7737                return Ok(());
7738            }
7739            depth.increment()?;
7740            let envelope_size = 8;
7741            let bytes_len = max_ordinal as usize * envelope_size;
7742            #[allow(unused_variables)]
7743            let offset = encoder.out_of_line_offset(bytes_len);
7744            let mut _prev_end_offset: usize = 0;
7745            if 1 > max_ordinal {
7746                return Ok(());
7747            }
7748
7749            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7750            // are envelope_size bytes.
7751            let cur_offset: usize = (1 - 1) * envelope_size;
7752
7753            // Zero reserved fields.
7754            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7755
7756            // Safety:
7757            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7758            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7759            //   envelope_size bytes, there is always sufficient room.
7760            fidl::encoding::encode_in_envelope_optional::<i32, D>(
7761                self.status.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
7762                encoder,
7763                offset + cur_offset,
7764                depth,
7765            )?;
7766
7767            _prev_end_offset = cur_offset + envelope_size;
7768
7769            Ok(())
7770        }
7771    }
7772
7773    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7774        for WlanFullmacImplIfcDisassocConfRequest
7775    {
7776        #[inline(always)]
7777        fn new_empty() -> Self {
7778            Self::default()
7779        }
7780
7781        unsafe fn decode(
7782            &mut self,
7783            decoder: &mut fidl::encoding::Decoder<'_, D>,
7784            offset: usize,
7785            mut depth: fidl::encoding::Depth,
7786        ) -> fidl::Result<()> {
7787            decoder.debug_check_bounds::<Self>(offset);
7788            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7789                None => return Err(fidl::Error::NotNullable),
7790                Some(len) => len,
7791            };
7792            // Calling decoder.out_of_line_offset(0) is not allowed.
7793            if len == 0 {
7794                return Ok(());
7795            };
7796            depth.increment()?;
7797            let envelope_size = 8;
7798            let bytes_len = len * envelope_size;
7799            let offset = decoder.out_of_line_offset(bytes_len)?;
7800            // Decode the envelope for each type.
7801            let mut _next_ordinal_to_read = 0;
7802            let mut next_offset = offset;
7803            let end_offset = offset + bytes_len;
7804            _next_ordinal_to_read += 1;
7805            if next_offset >= end_offset {
7806                return Ok(());
7807            }
7808
7809            // Decode unknown envelopes for gaps in ordinals.
7810            while _next_ordinal_to_read < 1 {
7811                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7812                _next_ordinal_to_read += 1;
7813                next_offset += envelope_size;
7814            }
7815
7816            let next_out_of_line = decoder.next_out_of_line();
7817            let handles_before = decoder.remaining_handles();
7818            if let Some((inlined, num_bytes, num_handles)) =
7819                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7820            {
7821                let member_inline_size =
7822                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7823                if inlined != (member_inline_size <= 4) {
7824                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7825                }
7826                let inner_offset;
7827                let mut inner_depth = depth.clone();
7828                if inlined {
7829                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7830                    inner_offset = next_offset;
7831                } else {
7832                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7833                    inner_depth.increment()?;
7834                }
7835                let val_ref = self.status.get_or_insert_with(|| fidl::new_empty!(i32, D));
7836                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
7837                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7838                {
7839                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7840                }
7841                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7842                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7843                }
7844            }
7845
7846            next_offset += envelope_size;
7847
7848            // Decode the remaining unknown envelopes.
7849            while next_offset < end_offset {
7850                _next_ordinal_to_read += 1;
7851                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7852                next_offset += envelope_size;
7853            }
7854
7855            Ok(())
7856        }
7857    }
7858
7859    impl WlanFullmacImplIfcDisassocIndRequest {
7860        #[inline(always)]
7861        fn max_ordinal_present(&self) -> u64 {
7862            if let Some(_) = self.locally_initiated {
7863                return 3;
7864            }
7865            if let Some(_) = self.reason_code {
7866                return 2;
7867            }
7868            if let Some(_) = self.peer_sta_address {
7869                return 1;
7870            }
7871            0
7872        }
7873    }
7874
7875    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcDisassocIndRequest {
7876        type Borrowed<'a> = &'a Self;
7877        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7878            value
7879        }
7880    }
7881
7882    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcDisassocIndRequest {
7883        type Owned = Self;
7884
7885        #[inline(always)]
7886        fn inline_align(_context: fidl::encoding::Context) -> usize {
7887            8
7888        }
7889
7890        #[inline(always)]
7891        fn inline_size(_context: fidl::encoding::Context) -> usize {
7892            16
7893        }
7894    }
7895
7896    unsafe impl<D: fidl::encoding::ResourceDialect>
7897        fidl::encoding::Encode<WlanFullmacImplIfcDisassocIndRequest, D>
7898        for &WlanFullmacImplIfcDisassocIndRequest
7899    {
7900        unsafe fn encode(
7901            self,
7902            encoder: &mut fidl::encoding::Encoder<'_, D>,
7903            offset: usize,
7904            mut depth: fidl::encoding::Depth,
7905        ) -> fidl::Result<()> {
7906            encoder.debug_check_bounds::<WlanFullmacImplIfcDisassocIndRequest>(offset);
7907            // Vector header
7908            let max_ordinal: u64 = self.max_ordinal_present();
7909            encoder.write_num(max_ordinal, offset);
7910            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7911            // Calling encoder.out_of_line_offset(0) is not allowed.
7912            if max_ordinal == 0 {
7913                return Ok(());
7914            }
7915            depth.increment()?;
7916            let envelope_size = 8;
7917            let bytes_len = max_ordinal as usize * envelope_size;
7918            #[allow(unused_variables)]
7919            let offset = encoder.out_of_line_offset(bytes_len);
7920            let mut _prev_end_offset: usize = 0;
7921            if 1 > max_ordinal {
7922                return Ok(());
7923            }
7924
7925            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7926            // are envelope_size bytes.
7927            let cur_offset: usize = (1 - 1) * envelope_size;
7928
7929            // Zero reserved fields.
7930            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7931
7932            // Safety:
7933            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7934            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7935            //   envelope_size bytes, there is always sufficient room.
7936            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
7937                self.peer_sta_address
7938                    .as_ref()
7939                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
7940                encoder,
7941                offset + cur_offset,
7942                depth,
7943            )?;
7944
7945            _prev_end_offset = cur_offset + envelope_size;
7946            if 2 > max_ordinal {
7947                return Ok(());
7948            }
7949
7950            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7951            // are envelope_size bytes.
7952            let cur_offset: usize = (2 - 1) * envelope_size;
7953
7954            // Zero reserved fields.
7955            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7956
7957            // Safety:
7958            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7959            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7960            //   envelope_size bytes, there is always sufficient room.
7961            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>(
7962            self.reason_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow),
7963            encoder, offset + cur_offset, depth
7964        )?;
7965
7966            _prev_end_offset = cur_offset + envelope_size;
7967            if 3 > max_ordinal {
7968                return Ok(());
7969            }
7970
7971            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7972            // are envelope_size bytes.
7973            let cur_offset: usize = (3 - 1) * envelope_size;
7974
7975            // Zero reserved fields.
7976            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7977
7978            // Safety:
7979            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7980            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7981            //   envelope_size bytes, there is always sufficient room.
7982            fidl::encoding::encode_in_envelope_optional::<bool, D>(
7983                self.locally_initiated
7984                    .as_ref()
7985                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7986                encoder,
7987                offset + cur_offset,
7988                depth,
7989            )?;
7990
7991            _prev_end_offset = cur_offset + envelope_size;
7992
7993            Ok(())
7994        }
7995    }
7996
7997    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7998        for WlanFullmacImplIfcDisassocIndRequest
7999    {
8000        #[inline(always)]
8001        fn new_empty() -> Self {
8002            Self::default()
8003        }
8004
8005        unsafe fn decode(
8006            &mut self,
8007            decoder: &mut fidl::encoding::Decoder<'_, D>,
8008            offset: usize,
8009            mut depth: fidl::encoding::Depth,
8010        ) -> fidl::Result<()> {
8011            decoder.debug_check_bounds::<Self>(offset);
8012            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8013                None => return Err(fidl::Error::NotNullable),
8014                Some(len) => len,
8015            };
8016            // Calling decoder.out_of_line_offset(0) is not allowed.
8017            if len == 0 {
8018                return Ok(());
8019            };
8020            depth.increment()?;
8021            let envelope_size = 8;
8022            let bytes_len = len * envelope_size;
8023            let offset = decoder.out_of_line_offset(bytes_len)?;
8024            // Decode the envelope for each type.
8025            let mut _next_ordinal_to_read = 0;
8026            let mut next_offset = offset;
8027            let end_offset = offset + bytes_len;
8028            _next_ordinal_to_read += 1;
8029            if next_offset >= end_offset {
8030                return Ok(());
8031            }
8032
8033            // Decode unknown envelopes for gaps in ordinals.
8034            while _next_ordinal_to_read < 1 {
8035                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8036                _next_ordinal_to_read += 1;
8037                next_offset += envelope_size;
8038            }
8039
8040            let next_out_of_line = decoder.next_out_of_line();
8041            let handles_before = decoder.remaining_handles();
8042            if let Some((inlined, num_bytes, num_handles)) =
8043                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8044            {
8045                let member_inline_size =
8046                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
8047                        decoder.context,
8048                    );
8049                if inlined != (member_inline_size <= 4) {
8050                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8051                }
8052                let inner_offset;
8053                let mut inner_depth = depth.clone();
8054                if inlined {
8055                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8056                    inner_offset = next_offset;
8057                } else {
8058                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8059                    inner_depth.increment()?;
8060                }
8061                let val_ref = self
8062                    .peer_sta_address
8063                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8064                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8093                if inlined != (member_inline_size <= 4) {
8094                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8095                }
8096                let inner_offset;
8097                let mut inner_depth = depth.clone();
8098                if inlined {
8099                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8100                    inner_offset = next_offset;
8101                } else {
8102                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8103                    inner_depth.increment()?;
8104                }
8105                let val_ref = self.reason_code.get_or_insert_with(|| {
8106                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D)
8107                });
8108                fidl::decode!(
8109                    fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
8110                    D,
8111                    val_ref,
8112                    decoder,
8113                    inner_offset,
8114                    inner_depth
8115                )?;
8116                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8117                {
8118                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8119                }
8120                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8121                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8122                }
8123            }
8124
8125            next_offset += envelope_size;
8126            _next_ordinal_to_read += 1;
8127            if next_offset >= end_offset {
8128                return Ok(());
8129            }
8130
8131            // Decode unknown envelopes for gaps in ordinals.
8132            while _next_ordinal_to_read < 3 {
8133                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8134                _next_ordinal_to_read += 1;
8135                next_offset += envelope_size;
8136            }
8137
8138            let next_out_of_line = decoder.next_out_of_line();
8139            let handles_before = decoder.remaining_handles();
8140            if let Some((inlined, num_bytes, num_handles)) =
8141                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8142            {
8143                let member_inline_size =
8144                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8145                if inlined != (member_inline_size <= 4) {
8146                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8147                }
8148                let inner_offset;
8149                let mut inner_depth = depth.clone();
8150                if inlined {
8151                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8152                    inner_offset = next_offset;
8153                } else {
8154                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8155                    inner_depth.increment()?;
8156                }
8157                let val_ref =
8158                    self.locally_initiated.get_or_insert_with(|| fidl::new_empty!(bool, D));
8159                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8160                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8161                {
8162                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8163                }
8164                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8165                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8166                }
8167            }
8168
8169            next_offset += envelope_size;
8170
8171            // Decode the remaining unknown envelopes.
8172            while next_offset < end_offset {
8173                _next_ordinal_to_read += 1;
8174                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8175                next_offset += envelope_size;
8176            }
8177
8178            Ok(())
8179        }
8180    }
8181
8182    impl WlanFullmacImplIfcEapolConfRequest {
8183        #[inline(always)]
8184        fn max_ordinal_present(&self) -> u64 {
8185            if let Some(_) = self.dst_addr {
8186                return 2;
8187            }
8188            if let Some(_) = self.result_code {
8189                return 1;
8190            }
8191            0
8192        }
8193    }
8194
8195    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcEapolConfRequest {
8196        type Borrowed<'a> = &'a Self;
8197        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8198            value
8199        }
8200    }
8201
8202    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcEapolConfRequest {
8203        type Owned = Self;
8204
8205        #[inline(always)]
8206        fn inline_align(_context: fidl::encoding::Context) -> usize {
8207            8
8208        }
8209
8210        #[inline(always)]
8211        fn inline_size(_context: fidl::encoding::Context) -> usize {
8212            16
8213        }
8214    }
8215
8216    unsafe impl<D: fidl::encoding::ResourceDialect>
8217        fidl::encoding::Encode<WlanFullmacImplIfcEapolConfRequest, D>
8218        for &WlanFullmacImplIfcEapolConfRequest
8219    {
8220        unsafe fn encode(
8221            self,
8222            encoder: &mut fidl::encoding::Encoder<'_, D>,
8223            offset: usize,
8224            mut depth: fidl::encoding::Depth,
8225        ) -> fidl::Result<()> {
8226            encoder.debug_check_bounds::<WlanFullmacImplIfcEapolConfRequest>(offset);
8227            // Vector header
8228            let max_ordinal: u64 = self.max_ordinal_present();
8229            encoder.write_num(max_ordinal, offset);
8230            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8231            // Calling encoder.out_of_line_offset(0) is not allowed.
8232            if max_ordinal == 0 {
8233                return Ok(());
8234            }
8235            depth.increment()?;
8236            let envelope_size = 8;
8237            let bytes_len = max_ordinal as usize * envelope_size;
8238            #[allow(unused_variables)]
8239            let offset = encoder.out_of_line_offset(bytes_len);
8240            let mut _prev_end_offset: usize = 0;
8241            if 1 > max_ordinal {
8242                return Ok(());
8243            }
8244
8245            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8246            // are envelope_size bytes.
8247            let cur_offset: usize = (1 - 1) * envelope_size;
8248
8249            // Zero reserved fields.
8250            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8251
8252            // Safety:
8253            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8254            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8255            //   envelope_size bytes, there is always sufficient room.
8256            fidl::encoding::encode_in_envelope_optional::<EapolTxResult, D>(
8257                self.result_code
8258                    .as_ref()
8259                    .map(<EapolTxResult as fidl::encoding::ValueTypeMarker>::borrow),
8260                encoder,
8261                offset + cur_offset,
8262                depth,
8263            )?;
8264
8265            _prev_end_offset = cur_offset + envelope_size;
8266            if 2 > max_ordinal {
8267                return Ok(());
8268            }
8269
8270            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8271            // are envelope_size bytes.
8272            let cur_offset: usize = (2 - 1) * envelope_size;
8273
8274            // Zero reserved fields.
8275            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8276
8277            // Safety:
8278            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8279            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8280            //   envelope_size bytes, there is always sufficient room.
8281            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
8282                self.dst_addr
8283                    .as_ref()
8284                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
8285                encoder,
8286                offset + cur_offset,
8287                depth,
8288            )?;
8289
8290            _prev_end_offset = cur_offset + envelope_size;
8291
8292            Ok(())
8293        }
8294    }
8295
8296    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8297        for WlanFullmacImplIfcEapolConfRequest
8298    {
8299        #[inline(always)]
8300        fn new_empty() -> Self {
8301            Self::default()
8302        }
8303
8304        unsafe fn decode(
8305            &mut self,
8306            decoder: &mut fidl::encoding::Decoder<'_, D>,
8307            offset: usize,
8308            mut depth: fidl::encoding::Depth,
8309        ) -> fidl::Result<()> {
8310            decoder.debug_check_bounds::<Self>(offset);
8311            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8312                None => return Err(fidl::Error::NotNullable),
8313                Some(len) => len,
8314            };
8315            // Calling decoder.out_of_line_offset(0) is not allowed.
8316            if len == 0 {
8317                return Ok(());
8318            };
8319            depth.increment()?;
8320            let envelope_size = 8;
8321            let bytes_len = len * envelope_size;
8322            let offset = decoder.out_of_line_offset(bytes_len)?;
8323            // Decode the envelope for each type.
8324            let mut _next_ordinal_to_read = 0;
8325            let mut next_offset = offset;
8326            let end_offset = offset + bytes_len;
8327            _next_ordinal_to_read += 1;
8328            if next_offset >= end_offset {
8329                return Ok(());
8330            }
8331
8332            // Decode unknown envelopes for gaps in ordinals.
8333            while _next_ordinal_to_read < 1 {
8334                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8335                _next_ordinal_to_read += 1;
8336                next_offset += envelope_size;
8337            }
8338
8339            let next_out_of_line = decoder.next_out_of_line();
8340            let handles_before = decoder.remaining_handles();
8341            if let Some((inlined, num_bytes, num_handles)) =
8342                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8343            {
8344                let member_inline_size =
8345                    <EapolTxResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8346                if inlined != (member_inline_size <= 4) {
8347                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8348                }
8349                let inner_offset;
8350                let mut inner_depth = depth.clone();
8351                if inlined {
8352                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8353                    inner_offset = next_offset;
8354                } else {
8355                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8356                    inner_depth.increment()?;
8357                }
8358                let val_ref =
8359                    self.result_code.get_or_insert_with(|| fidl::new_empty!(EapolTxResult, D));
8360                fidl::decode!(EapolTxResult, D, val_ref, decoder, inner_offset, inner_depth)?;
8361                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8362                {
8363                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8364                }
8365                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8366                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8367                }
8368            }
8369
8370            next_offset += envelope_size;
8371            _next_ordinal_to_read += 1;
8372            if next_offset >= end_offset {
8373                return Ok(());
8374            }
8375
8376            // Decode unknown envelopes for gaps in ordinals.
8377            while _next_ordinal_to_read < 2 {
8378                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8379                _next_ordinal_to_read += 1;
8380                next_offset += envelope_size;
8381            }
8382
8383            let next_out_of_line = decoder.next_out_of_line();
8384            let handles_before = decoder.remaining_handles();
8385            if let Some((inlined, num_bytes, num_handles)) =
8386                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8387            {
8388                let member_inline_size =
8389                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
8390                        decoder.context,
8391                    );
8392                if inlined != (member_inline_size <= 4) {
8393                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8394                }
8395                let inner_offset;
8396                let mut inner_depth = depth.clone();
8397                if inlined {
8398                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8399                    inner_offset = next_offset;
8400                } else {
8401                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8402                    inner_depth.increment()?;
8403                }
8404                let val_ref = self
8405                    .dst_addr
8406                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8407                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
8408                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8409                {
8410                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8411                }
8412                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8413                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8414                }
8415            }
8416
8417            next_offset += envelope_size;
8418
8419            // Decode the remaining unknown envelopes.
8420            while next_offset < end_offset {
8421                _next_ordinal_to_read += 1;
8422                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8423                next_offset += envelope_size;
8424            }
8425
8426            Ok(())
8427        }
8428    }
8429
8430    impl WlanFullmacImplIfcEapolIndRequest {
8431        #[inline(always)]
8432        fn max_ordinal_present(&self) -> u64 {
8433            if let Some(_) = self.data {
8434                return 3;
8435            }
8436            if let Some(_) = self.dst_addr {
8437                return 2;
8438            }
8439            if let Some(_) = self.src_addr {
8440                return 1;
8441            }
8442            0
8443        }
8444    }
8445
8446    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcEapolIndRequest {
8447        type Borrowed<'a> = &'a Self;
8448        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8449            value
8450        }
8451    }
8452
8453    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcEapolIndRequest {
8454        type Owned = Self;
8455
8456        #[inline(always)]
8457        fn inline_align(_context: fidl::encoding::Context) -> usize {
8458            8
8459        }
8460
8461        #[inline(always)]
8462        fn inline_size(_context: fidl::encoding::Context) -> usize {
8463            16
8464        }
8465    }
8466
8467    unsafe impl<D: fidl::encoding::ResourceDialect>
8468        fidl::encoding::Encode<WlanFullmacImplIfcEapolIndRequest, D>
8469        for &WlanFullmacImplIfcEapolIndRequest
8470    {
8471        unsafe fn encode(
8472            self,
8473            encoder: &mut fidl::encoding::Encoder<'_, D>,
8474            offset: usize,
8475            mut depth: fidl::encoding::Depth,
8476        ) -> fidl::Result<()> {
8477            encoder.debug_check_bounds::<WlanFullmacImplIfcEapolIndRequest>(offset);
8478            // Vector header
8479            let max_ordinal: u64 = self.max_ordinal_present();
8480            encoder.write_num(max_ordinal, offset);
8481            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8482            // Calling encoder.out_of_line_offset(0) is not allowed.
8483            if max_ordinal == 0 {
8484                return Ok(());
8485            }
8486            depth.increment()?;
8487            let envelope_size = 8;
8488            let bytes_len = max_ordinal as usize * envelope_size;
8489            #[allow(unused_variables)]
8490            let offset = encoder.out_of_line_offset(bytes_len);
8491            let mut _prev_end_offset: usize = 0;
8492            if 1 > max_ordinal {
8493                return Ok(());
8494            }
8495
8496            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8497            // are envelope_size bytes.
8498            let cur_offset: usize = (1 - 1) * envelope_size;
8499
8500            // Zero reserved fields.
8501            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8502
8503            // Safety:
8504            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8505            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8506            //   envelope_size bytes, there is always sufficient room.
8507            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
8508                self.src_addr
8509                    .as_ref()
8510                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
8511                encoder,
8512                offset + cur_offset,
8513                depth,
8514            )?;
8515
8516            _prev_end_offset = cur_offset + envelope_size;
8517            if 2 > max_ordinal {
8518                return Ok(());
8519            }
8520
8521            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8522            // are envelope_size bytes.
8523            let cur_offset: usize = (2 - 1) * envelope_size;
8524
8525            // Zero reserved fields.
8526            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8527
8528            // Safety:
8529            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8530            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8531            //   envelope_size bytes, there is always sufficient room.
8532            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
8533                self.dst_addr
8534                    .as_ref()
8535                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
8536                encoder,
8537                offset + cur_offset,
8538                depth,
8539            )?;
8540
8541            _prev_end_offset = cur_offset + envelope_size;
8542            if 3 > max_ordinal {
8543                return Ok(());
8544            }
8545
8546            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8547            // are envelope_size bytes.
8548            let cur_offset: usize = (3 - 1) * envelope_size;
8549
8550            // Zero reserved fields.
8551            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8552
8553            // Safety:
8554            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8555            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8556            //   envelope_size bytes, there is always sufficient room.
8557            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8558            self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8559            encoder, offset + cur_offset, depth
8560        )?;
8561
8562            _prev_end_offset = cur_offset + envelope_size;
8563
8564            Ok(())
8565        }
8566    }
8567
8568    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8569        for WlanFullmacImplIfcEapolIndRequest
8570    {
8571        #[inline(always)]
8572        fn new_empty() -> Self {
8573            Self::default()
8574        }
8575
8576        unsafe fn decode(
8577            &mut self,
8578            decoder: &mut fidl::encoding::Decoder<'_, D>,
8579            offset: usize,
8580            mut depth: fidl::encoding::Depth,
8581        ) -> fidl::Result<()> {
8582            decoder.debug_check_bounds::<Self>(offset);
8583            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8584                None => return Err(fidl::Error::NotNullable),
8585                Some(len) => len,
8586            };
8587            // Calling decoder.out_of_line_offset(0) is not allowed.
8588            if len == 0 {
8589                return Ok(());
8590            };
8591            depth.increment()?;
8592            let envelope_size = 8;
8593            let bytes_len = len * envelope_size;
8594            let offset = decoder.out_of_line_offset(bytes_len)?;
8595            // Decode the envelope for each type.
8596            let mut _next_ordinal_to_read = 0;
8597            let mut next_offset = offset;
8598            let end_offset = offset + bytes_len;
8599            _next_ordinal_to_read += 1;
8600            if next_offset >= end_offset {
8601                return Ok(());
8602            }
8603
8604            // Decode unknown envelopes for gaps in ordinals.
8605            while _next_ordinal_to_read < 1 {
8606                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8607                _next_ordinal_to_read += 1;
8608                next_offset += envelope_size;
8609            }
8610
8611            let next_out_of_line = decoder.next_out_of_line();
8612            let handles_before = decoder.remaining_handles();
8613            if let Some((inlined, num_bytes, num_handles)) =
8614                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8615            {
8616                let member_inline_size =
8617                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
8618                        decoder.context,
8619                    );
8620                if inlined != (member_inline_size <= 4) {
8621                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8622                }
8623                let inner_offset;
8624                let mut inner_depth = depth.clone();
8625                if inlined {
8626                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8627                    inner_offset = next_offset;
8628                } else {
8629                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8630                    inner_depth.increment()?;
8631                }
8632                let val_ref = self
8633                    .src_addr
8634                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8635                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
8636                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8637                {
8638                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8639                }
8640                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8641                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8642                }
8643            }
8644
8645            next_offset += envelope_size;
8646            _next_ordinal_to_read += 1;
8647            if next_offset >= end_offset {
8648                return Ok(());
8649            }
8650
8651            // Decode unknown envelopes for gaps in ordinals.
8652            while _next_ordinal_to_read < 2 {
8653                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8654                _next_ordinal_to_read += 1;
8655                next_offset += envelope_size;
8656            }
8657
8658            let next_out_of_line = decoder.next_out_of_line();
8659            let handles_before = decoder.remaining_handles();
8660            if let Some((inlined, num_bytes, num_handles)) =
8661                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8662            {
8663                let member_inline_size =
8664                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
8665                        decoder.context,
8666                    );
8667                if inlined != (member_inline_size <= 4) {
8668                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8669                }
8670                let inner_offset;
8671                let mut inner_depth = depth.clone();
8672                if inlined {
8673                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8674                    inner_offset = next_offset;
8675                } else {
8676                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8677                    inner_depth.increment()?;
8678                }
8679                let val_ref = self
8680                    .dst_addr
8681                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
8682                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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            _next_ordinal_to_read += 1;
8694            if next_offset >= end_offset {
8695                return Ok(());
8696            }
8697
8698            // Decode unknown envelopes for gaps in ordinals.
8699            while _next_ordinal_to_read < 3 {
8700                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8701                _next_ordinal_to_read += 1;
8702                next_offset += envelope_size;
8703            }
8704
8705            let next_out_of_line = decoder.next_out_of_line();
8706            let handles_before = decoder.remaining_handles();
8707            if let Some((inlined, num_bytes, num_handles)) =
8708                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8709            {
8710                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8711                if inlined != (member_inline_size <= 4) {
8712                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8713                }
8714                let inner_offset;
8715                let mut inner_depth = depth.clone();
8716                if inlined {
8717                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8718                    inner_offset = next_offset;
8719                } else {
8720                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8721                    inner_depth.increment()?;
8722                }
8723                let val_ref = self.data.get_or_insert_with(|| {
8724                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
8725                });
8726                fidl::decode!(
8727                    fidl::encoding::UnboundedVector<u8>,
8728                    D,
8729                    val_ref,
8730                    decoder,
8731                    inner_offset,
8732                    inner_depth
8733                )?;
8734                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8735                {
8736                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8737                }
8738                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8739                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8740                }
8741            }
8742
8743            next_offset += envelope_size;
8744
8745            // Decode the remaining unknown envelopes.
8746            while next_offset < end_offset {
8747                _next_ordinal_to_read += 1;
8748                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8749                next_offset += envelope_size;
8750            }
8751
8752            Ok(())
8753        }
8754    }
8755
8756    impl WlanFullmacImplIfcOnPmkAvailableRequest {
8757        #[inline(always)]
8758        fn max_ordinal_present(&self) -> u64 {
8759            if let Some(_) = self.pmkid {
8760                return 2;
8761            }
8762            if let Some(_) = self.pmk {
8763                return 1;
8764            }
8765            0
8766        }
8767    }
8768
8769    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnPmkAvailableRequest {
8770        type Borrowed<'a> = &'a Self;
8771        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8772            value
8773        }
8774    }
8775
8776    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnPmkAvailableRequest {
8777        type Owned = Self;
8778
8779        #[inline(always)]
8780        fn inline_align(_context: fidl::encoding::Context) -> usize {
8781            8
8782        }
8783
8784        #[inline(always)]
8785        fn inline_size(_context: fidl::encoding::Context) -> usize {
8786            16
8787        }
8788    }
8789
8790    unsafe impl<D: fidl::encoding::ResourceDialect>
8791        fidl::encoding::Encode<WlanFullmacImplIfcOnPmkAvailableRequest, D>
8792        for &WlanFullmacImplIfcOnPmkAvailableRequest
8793    {
8794        unsafe fn encode(
8795            self,
8796            encoder: &mut fidl::encoding::Encoder<'_, D>,
8797            offset: usize,
8798            mut depth: fidl::encoding::Depth,
8799        ) -> fidl::Result<()> {
8800            encoder.debug_check_bounds::<WlanFullmacImplIfcOnPmkAvailableRequest>(offset);
8801            // Vector header
8802            let max_ordinal: u64 = self.max_ordinal_present();
8803            encoder.write_num(max_ordinal, offset);
8804            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8805            // Calling encoder.out_of_line_offset(0) is not allowed.
8806            if max_ordinal == 0 {
8807                return Ok(());
8808            }
8809            depth.increment()?;
8810            let envelope_size = 8;
8811            let bytes_len = max_ordinal as usize * envelope_size;
8812            #[allow(unused_variables)]
8813            let offset = encoder.out_of_line_offset(bytes_len);
8814            let mut _prev_end_offset: usize = 0;
8815            if 1 > max_ordinal {
8816                return Ok(());
8817            }
8818
8819            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8820            // are envelope_size bytes.
8821            let cur_offset: usize = (1 - 1) * envelope_size;
8822
8823            // Zero reserved fields.
8824            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8825
8826            // Safety:
8827            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8828            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8829            //   envelope_size bytes, there is always sufficient room.
8830            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8831            self.pmk.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8832            encoder, offset + cur_offset, depth
8833        )?;
8834
8835            _prev_end_offset = cur_offset + envelope_size;
8836            if 2 > max_ordinal {
8837                return Ok(());
8838            }
8839
8840            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8841            // are envelope_size bytes.
8842            let cur_offset: usize = (2 - 1) * envelope_size;
8843
8844            // Zero reserved fields.
8845            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8846
8847            // Safety:
8848            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8849            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8850            //   envelope_size bytes, there is always sufficient room.
8851            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8852            self.pmkid.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8853            encoder, offset + cur_offset, depth
8854        )?;
8855
8856            _prev_end_offset = cur_offset + envelope_size;
8857
8858            Ok(())
8859        }
8860    }
8861
8862    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8863        for WlanFullmacImplIfcOnPmkAvailableRequest
8864    {
8865        #[inline(always)]
8866        fn new_empty() -> Self {
8867            Self::default()
8868        }
8869
8870        unsafe fn decode(
8871            &mut self,
8872            decoder: &mut fidl::encoding::Decoder<'_, D>,
8873            offset: usize,
8874            mut depth: fidl::encoding::Depth,
8875        ) -> fidl::Result<()> {
8876            decoder.debug_check_bounds::<Self>(offset);
8877            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8878                None => return Err(fidl::Error::NotNullable),
8879                Some(len) => len,
8880            };
8881            // Calling decoder.out_of_line_offset(0) is not allowed.
8882            if len == 0 {
8883                return Ok(());
8884            };
8885            depth.increment()?;
8886            let envelope_size = 8;
8887            let bytes_len = len * envelope_size;
8888            let offset = decoder.out_of_line_offset(bytes_len)?;
8889            // Decode the envelope for each type.
8890            let mut _next_ordinal_to_read = 0;
8891            let mut next_offset = offset;
8892            let end_offset = offset + bytes_len;
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 < 1 {
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.pmk.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            _next_ordinal_to_read += 1;
8945            if next_offset >= end_offset {
8946                return Ok(());
8947            }
8948
8949            // Decode unknown envelopes for gaps in ordinals.
8950            while _next_ordinal_to_read < 2 {
8951                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8952                _next_ordinal_to_read += 1;
8953                next_offset += envelope_size;
8954            }
8955
8956            let next_out_of_line = decoder.next_out_of_line();
8957            let handles_before = decoder.remaining_handles();
8958            if let Some((inlined, num_bytes, num_handles)) =
8959                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8960            {
8961                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8962                if inlined != (member_inline_size <= 4) {
8963                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8964                }
8965                let inner_offset;
8966                let mut inner_depth = depth.clone();
8967                if inlined {
8968                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8969                    inner_offset = next_offset;
8970                } else {
8971                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8972                    inner_depth.increment()?;
8973                }
8974                let val_ref = self.pmkid.get_or_insert_with(|| {
8975                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
8976                });
8977                fidl::decode!(
8978                    fidl::encoding::UnboundedVector<u8>,
8979                    D,
8980                    val_ref,
8981                    decoder,
8982                    inner_offset,
8983                    inner_depth
8984                )?;
8985                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8986                {
8987                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8988                }
8989                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8990                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8991                }
8992            }
8993
8994            next_offset += envelope_size;
8995
8996            // Decode the remaining unknown envelopes.
8997            while next_offset < end_offset {
8998                _next_ordinal_to_read += 1;
8999                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9000                next_offset += envelope_size;
9001            }
9002
9003            Ok(())
9004        }
9005    }
9006
9007    impl WlanFullmacImplIfcOnScanEndRequest {
9008        #[inline(always)]
9009        fn max_ordinal_present(&self) -> u64 {
9010            if let Some(_) = self.code {
9011                return 2;
9012            }
9013            if let Some(_) = self.txn_id {
9014                return 1;
9015            }
9016            0
9017        }
9018    }
9019
9020    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnScanEndRequest {
9021        type Borrowed<'a> = &'a Self;
9022        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9023            value
9024        }
9025    }
9026
9027    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnScanEndRequest {
9028        type Owned = Self;
9029
9030        #[inline(always)]
9031        fn inline_align(_context: fidl::encoding::Context) -> usize {
9032            8
9033        }
9034
9035        #[inline(always)]
9036        fn inline_size(_context: fidl::encoding::Context) -> usize {
9037            16
9038        }
9039    }
9040
9041    unsafe impl<D: fidl::encoding::ResourceDialect>
9042        fidl::encoding::Encode<WlanFullmacImplIfcOnScanEndRequest, D>
9043        for &WlanFullmacImplIfcOnScanEndRequest
9044    {
9045        unsafe fn encode(
9046            self,
9047            encoder: &mut fidl::encoding::Encoder<'_, D>,
9048            offset: usize,
9049            mut depth: fidl::encoding::Depth,
9050        ) -> fidl::Result<()> {
9051            encoder.debug_check_bounds::<WlanFullmacImplIfcOnScanEndRequest>(offset);
9052            // Vector header
9053            let max_ordinal: u64 = self.max_ordinal_present();
9054            encoder.write_num(max_ordinal, offset);
9055            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9056            // Calling encoder.out_of_line_offset(0) is not allowed.
9057            if max_ordinal == 0 {
9058                return Ok(());
9059            }
9060            depth.increment()?;
9061            let envelope_size = 8;
9062            let bytes_len = max_ordinal as usize * envelope_size;
9063            #[allow(unused_variables)]
9064            let offset = encoder.out_of_line_offset(bytes_len);
9065            let mut _prev_end_offset: usize = 0;
9066            if 1 > max_ordinal {
9067                return Ok(());
9068            }
9069
9070            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9071            // are envelope_size bytes.
9072            let cur_offset: usize = (1 - 1) * envelope_size;
9073
9074            // Zero reserved fields.
9075            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9076
9077            // Safety:
9078            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9079            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9080            //   envelope_size bytes, there is always sufficient room.
9081            fidl::encoding::encode_in_envelope_optional::<u64, D>(
9082                self.txn_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9083                encoder,
9084                offset + cur_offset,
9085                depth,
9086            )?;
9087
9088            _prev_end_offset = cur_offset + envelope_size;
9089            if 2 > max_ordinal {
9090                return Ok(());
9091            }
9092
9093            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9094            // are envelope_size bytes.
9095            let cur_offset: usize = (2 - 1) * envelope_size;
9096
9097            // Zero reserved fields.
9098            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9099
9100            // Safety:
9101            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9102            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9103            //   envelope_size bytes, there is always sufficient room.
9104            fidl::encoding::encode_in_envelope_optional::<WlanScanResult, D>(
9105                self.code.as_ref().map(<WlanScanResult as fidl::encoding::ValueTypeMarker>::borrow),
9106                encoder,
9107                offset + cur_offset,
9108                depth,
9109            )?;
9110
9111            _prev_end_offset = cur_offset + envelope_size;
9112
9113            Ok(())
9114        }
9115    }
9116
9117    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9118        for WlanFullmacImplIfcOnScanEndRequest
9119    {
9120        #[inline(always)]
9121        fn new_empty() -> Self {
9122            Self::default()
9123        }
9124
9125        unsafe fn decode(
9126            &mut self,
9127            decoder: &mut fidl::encoding::Decoder<'_, D>,
9128            offset: usize,
9129            mut depth: fidl::encoding::Depth,
9130        ) -> fidl::Result<()> {
9131            decoder.debug_check_bounds::<Self>(offset);
9132            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9133                None => return Err(fidl::Error::NotNullable),
9134                Some(len) => len,
9135            };
9136            // Calling decoder.out_of_line_offset(0) is not allowed.
9137            if len == 0 {
9138                return Ok(());
9139            };
9140            depth.increment()?;
9141            let envelope_size = 8;
9142            let bytes_len = len * envelope_size;
9143            let offset = decoder.out_of_line_offset(bytes_len)?;
9144            // Decode the envelope for each type.
9145            let mut _next_ordinal_to_read = 0;
9146            let mut next_offset = offset;
9147            let end_offset = offset + bytes_len;
9148            _next_ordinal_to_read += 1;
9149            if next_offset >= end_offset {
9150                return Ok(());
9151            }
9152
9153            // Decode unknown envelopes for gaps in ordinals.
9154            while _next_ordinal_to_read < 1 {
9155                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9156                _next_ordinal_to_read += 1;
9157                next_offset += envelope_size;
9158            }
9159
9160            let next_out_of_line = decoder.next_out_of_line();
9161            let handles_before = decoder.remaining_handles();
9162            if let Some((inlined, num_bytes, num_handles)) =
9163                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9164            {
9165                let member_inline_size =
9166                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9167                if inlined != (member_inline_size <= 4) {
9168                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9169                }
9170                let inner_offset;
9171                let mut inner_depth = depth.clone();
9172                if inlined {
9173                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9174                    inner_offset = next_offset;
9175                } else {
9176                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9177                    inner_depth.increment()?;
9178                }
9179                let val_ref = self.txn_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
9180                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9181                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9182                {
9183                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9184                }
9185                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9186                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9187                }
9188            }
9189
9190            next_offset += envelope_size;
9191            _next_ordinal_to_read += 1;
9192            if next_offset >= end_offset {
9193                return Ok(());
9194            }
9195
9196            // Decode unknown envelopes for gaps in ordinals.
9197            while _next_ordinal_to_read < 2 {
9198                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9199                _next_ordinal_to_read += 1;
9200                next_offset += envelope_size;
9201            }
9202
9203            let next_out_of_line = decoder.next_out_of_line();
9204            let handles_before = decoder.remaining_handles();
9205            if let Some((inlined, num_bytes, num_handles)) =
9206                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9207            {
9208                let member_inline_size =
9209                    <WlanScanResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9210                if inlined != (member_inline_size <= 4) {
9211                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9212                }
9213                let inner_offset;
9214                let mut inner_depth = depth.clone();
9215                if inlined {
9216                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9217                    inner_offset = next_offset;
9218                } else {
9219                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9220                    inner_depth.increment()?;
9221                }
9222                let val_ref = self.code.get_or_insert_with(|| fidl::new_empty!(WlanScanResult, D));
9223                fidl::decode!(WlanScanResult, D, val_ref, decoder, inner_offset, inner_depth)?;
9224                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9225                {
9226                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9227                }
9228                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9229                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9230                }
9231            }
9232
9233            next_offset += envelope_size;
9234
9235            // Decode the remaining unknown envelopes.
9236            while next_offset < end_offset {
9237                _next_ordinal_to_read += 1;
9238                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9239                next_offset += envelope_size;
9240            }
9241
9242            Ok(())
9243        }
9244    }
9245
9246    impl WlanFullmacImplIfcOnScanResultRequest {
9247        #[inline(always)]
9248        fn max_ordinal_present(&self) -> u64 {
9249            if let Some(_) = self.bss {
9250                return 3;
9251            }
9252            if let Some(_) = self.timestamp_nanos {
9253                return 2;
9254            }
9255            if let Some(_) = self.txn_id {
9256                return 1;
9257            }
9258            0
9259        }
9260    }
9261
9262    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcOnScanResultRequest {
9263        type Borrowed<'a> = &'a Self;
9264        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9265            value
9266        }
9267    }
9268
9269    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcOnScanResultRequest {
9270        type Owned = Self;
9271
9272        #[inline(always)]
9273        fn inline_align(_context: fidl::encoding::Context) -> usize {
9274            8
9275        }
9276
9277        #[inline(always)]
9278        fn inline_size(_context: fidl::encoding::Context) -> usize {
9279            16
9280        }
9281    }
9282
9283    unsafe impl<D: fidl::encoding::ResourceDialect>
9284        fidl::encoding::Encode<WlanFullmacImplIfcOnScanResultRequest, D>
9285        for &WlanFullmacImplIfcOnScanResultRequest
9286    {
9287        unsafe fn encode(
9288            self,
9289            encoder: &mut fidl::encoding::Encoder<'_, D>,
9290            offset: usize,
9291            mut depth: fidl::encoding::Depth,
9292        ) -> fidl::Result<()> {
9293            encoder.debug_check_bounds::<WlanFullmacImplIfcOnScanResultRequest>(offset);
9294            // Vector header
9295            let max_ordinal: u64 = self.max_ordinal_present();
9296            encoder.write_num(max_ordinal, offset);
9297            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9298            // Calling encoder.out_of_line_offset(0) is not allowed.
9299            if max_ordinal == 0 {
9300                return Ok(());
9301            }
9302            depth.increment()?;
9303            let envelope_size = 8;
9304            let bytes_len = max_ordinal as usize * envelope_size;
9305            #[allow(unused_variables)]
9306            let offset = encoder.out_of_line_offset(bytes_len);
9307            let mut _prev_end_offset: usize = 0;
9308            if 1 > max_ordinal {
9309                return Ok(());
9310            }
9311
9312            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9313            // are envelope_size bytes.
9314            let cur_offset: usize = (1 - 1) * envelope_size;
9315
9316            // Zero reserved fields.
9317            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9318
9319            // Safety:
9320            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9321            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9322            //   envelope_size bytes, there is always sufficient room.
9323            fidl::encoding::encode_in_envelope_optional::<u64, D>(
9324                self.txn_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9325                encoder,
9326                offset + cur_offset,
9327                depth,
9328            )?;
9329
9330            _prev_end_offset = cur_offset + envelope_size;
9331            if 2 > max_ordinal {
9332                return Ok(());
9333            }
9334
9335            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9336            // are envelope_size bytes.
9337            let cur_offset: usize = (2 - 1) * envelope_size;
9338
9339            // Zero reserved fields.
9340            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9341
9342            // Safety:
9343            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9344            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9345            //   envelope_size bytes, there is always sufficient room.
9346            fidl::encoding::encode_in_envelope_optional::<i64, D>(
9347                self.timestamp_nanos.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
9348                encoder,
9349                offset + cur_offset,
9350                depth,
9351            )?;
9352
9353            _prev_end_offset = cur_offset + envelope_size;
9354            if 3 > max_ordinal {
9355                return Ok(());
9356            }
9357
9358            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9359            // are envelope_size bytes.
9360            let cur_offset: usize = (3 - 1) * envelope_size;
9361
9362            // Zero reserved fields.
9363            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9364
9365            // Safety:
9366            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9367            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9368            //   envelope_size bytes, there is always sufficient room.
9369            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
9370            self.bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
9371            encoder, offset + cur_offset, depth
9372        )?;
9373
9374            _prev_end_offset = cur_offset + envelope_size;
9375
9376            Ok(())
9377        }
9378    }
9379
9380    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9381        for WlanFullmacImplIfcOnScanResultRequest
9382    {
9383        #[inline(always)]
9384        fn new_empty() -> Self {
9385            Self::default()
9386        }
9387
9388        unsafe fn decode(
9389            &mut self,
9390            decoder: &mut fidl::encoding::Decoder<'_, D>,
9391            offset: usize,
9392            mut depth: fidl::encoding::Depth,
9393        ) -> fidl::Result<()> {
9394            decoder.debug_check_bounds::<Self>(offset);
9395            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9396                None => return Err(fidl::Error::NotNullable),
9397                Some(len) => len,
9398            };
9399            // Calling decoder.out_of_line_offset(0) is not allowed.
9400            if len == 0 {
9401                return Ok(());
9402            };
9403            depth.increment()?;
9404            let envelope_size = 8;
9405            let bytes_len = len * envelope_size;
9406            let offset = decoder.out_of_line_offset(bytes_len)?;
9407            // Decode the envelope for each type.
9408            let mut _next_ordinal_to_read = 0;
9409            let mut next_offset = offset;
9410            let end_offset = offset + bytes_len;
9411            _next_ordinal_to_read += 1;
9412            if next_offset >= end_offset {
9413                return Ok(());
9414            }
9415
9416            // Decode unknown envelopes for gaps in ordinals.
9417            while _next_ordinal_to_read < 1 {
9418                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9419                _next_ordinal_to_read += 1;
9420                next_offset += envelope_size;
9421            }
9422
9423            let next_out_of_line = decoder.next_out_of_line();
9424            let handles_before = decoder.remaining_handles();
9425            if let Some((inlined, num_bytes, num_handles)) =
9426                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9427            {
9428                let member_inline_size =
9429                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9430                if inlined != (member_inline_size <= 4) {
9431                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9432                }
9433                let inner_offset;
9434                let mut inner_depth = depth.clone();
9435                if inlined {
9436                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9437                    inner_offset = next_offset;
9438                } else {
9439                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9440                    inner_depth.increment()?;
9441                }
9442                let val_ref = self.txn_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
9443                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9444                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9445                {
9446                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9447                }
9448                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9449                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9450                }
9451            }
9452
9453            next_offset += envelope_size;
9454            _next_ordinal_to_read += 1;
9455            if next_offset >= end_offset {
9456                return Ok(());
9457            }
9458
9459            // Decode unknown envelopes for gaps in ordinals.
9460            while _next_ordinal_to_read < 2 {
9461                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9462                _next_ordinal_to_read += 1;
9463                next_offset += envelope_size;
9464            }
9465
9466            let next_out_of_line = decoder.next_out_of_line();
9467            let handles_before = decoder.remaining_handles();
9468            if let Some((inlined, num_bytes, num_handles)) =
9469                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9470            {
9471                let member_inline_size =
9472                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9473                if inlined != (member_inline_size <= 4) {
9474                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9475                }
9476                let inner_offset;
9477                let mut inner_depth = depth.clone();
9478                if inlined {
9479                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9480                    inner_offset = next_offset;
9481                } else {
9482                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9483                    inner_depth.increment()?;
9484                }
9485                let val_ref = self.timestamp_nanos.get_or_insert_with(|| fidl::new_empty!(i64, D));
9486                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
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            _next_ordinal_to_read += 1;
9498            if next_offset >= end_offset {
9499                return Ok(());
9500            }
9501
9502            // Decode unknown envelopes for gaps in ordinals.
9503            while _next_ordinal_to_read < 3 {
9504                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9505                _next_ordinal_to_read += 1;
9506                next_offset += envelope_size;
9507            }
9508
9509            let next_out_of_line = decoder.next_out_of_line();
9510            let handles_before = decoder.remaining_handles();
9511            if let Some((inlined, num_bytes, num_handles)) =
9512                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9513            {
9514                let member_inline_size = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9515                if inlined != (member_inline_size <= 4) {
9516                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9517                }
9518                let inner_offset;
9519                let mut inner_depth = depth.clone();
9520                if inlined {
9521                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9522                    inner_offset = next_offset;
9523                } else {
9524                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9525                    inner_depth.increment()?;
9526                }
9527                let val_ref = self.bss.get_or_insert_with(|| {
9528                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
9529                });
9530                fidl::decode!(
9531                    fidl_fuchsia_wlan_common__common::BssDescription,
9532                    D,
9533                    val_ref,
9534                    decoder,
9535                    inner_offset,
9536                    inner_depth
9537                )?;
9538                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9539                {
9540                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9541                }
9542                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9543                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9544                }
9545            }
9546
9547            next_offset += envelope_size;
9548
9549            // Decode the remaining unknown envelopes.
9550            while next_offset < end_offset {
9551                _next_ordinal_to_read += 1;
9552                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9553                next_offset += envelope_size;
9554            }
9555
9556            Ok(())
9557        }
9558    }
9559
9560    impl WlanFullmacImplIfcRoamConfRequest {
9561        #[inline(always)]
9562        fn max_ordinal_present(&self) -> u64 {
9563            if let Some(_) = self.association_ies {
9564                return 6;
9565            }
9566            if let Some(_) = self.association_id {
9567                return 5;
9568            }
9569            if let Some(_) = self.target_bss_authenticated {
9570                return 4;
9571            }
9572            if let Some(_) = self.original_association_maintained {
9573                return 3;
9574            }
9575            if let Some(_) = self.status_code {
9576                return 2;
9577            }
9578            if let Some(_) = self.selected_bssid {
9579                return 1;
9580            }
9581            0
9582        }
9583    }
9584
9585    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcRoamConfRequest {
9586        type Borrowed<'a> = &'a Self;
9587        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9588            value
9589        }
9590    }
9591
9592    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcRoamConfRequest {
9593        type Owned = Self;
9594
9595        #[inline(always)]
9596        fn inline_align(_context: fidl::encoding::Context) -> usize {
9597            8
9598        }
9599
9600        #[inline(always)]
9601        fn inline_size(_context: fidl::encoding::Context) -> usize {
9602            16
9603        }
9604    }
9605
9606    unsafe impl<D: fidl::encoding::ResourceDialect>
9607        fidl::encoding::Encode<WlanFullmacImplIfcRoamConfRequest, D>
9608        for &WlanFullmacImplIfcRoamConfRequest
9609    {
9610        unsafe fn encode(
9611            self,
9612            encoder: &mut fidl::encoding::Encoder<'_, D>,
9613            offset: usize,
9614            mut depth: fidl::encoding::Depth,
9615        ) -> fidl::Result<()> {
9616            encoder.debug_check_bounds::<WlanFullmacImplIfcRoamConfRequest>(offset);
9617            // Vector header
9618            let max_ordinal: u64 = self.max_ordinal_present();
9619            encoder.write_num(max_ordinal, offset);
9620            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9621            // Calling encoder.out_of_line_offset(0) is not allowed.
9622            if max_ordinal == 0 {
9623                return Ok(());
9624            }
9625            depth.increment()?;
9626            let envelope_size = 8;
9627            let bytes_len = max_ordinal as usize * envelope_size;
9628            #[allow(unused_variables)]
9629            let offset = encoder.out_of_line_offset(bytes_len);
9630            let mut _prev_end_offset: usize = 0;
9631            if 1 > max_ordinal {
9632                return Ok(());
9633            }
9634
9635            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9636            // are envelope_size bytes.
9637            let cur_offset: usize = (1 - 1) * envelope_size;
9638
9639            // Zero reserved fields.
9640            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9641
9642            // Safety:
9643            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9644            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9645            //   envelope_size bytes, there is always sufficient room.
9646            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
9647                self.selected_bssid
9648                    .as_ref()
9649                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
9650                encoder,
9651                offset + cur_offset,
9652                depth,
9653            )?;
9654
9655            _prev_end_offset = cur_offset + envelope_size;
9656            if 2 > max_ordinal {
9657                return Ok(());
9658            }
9659
9660            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9661            // are envelope_size bytes.
9662            let cur_offset: usize = (2 - 1) * envelope_size;
9663
9664            // Zero reserved fields.
9665            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9666
9667            // Safety:
9668            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9669            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9670            //   envelope_size bytes, there is always sufficient room.
9671            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
9672            self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
9673            encoder, offset + cur_offset, depth
9674        )?;
9675
9676            _prev_end_offset = cur_offset + envelope_size;
9677            if 3 > max_ordinal {
9678                return Ok(());
9679            }
9680
9681            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9682            // are envelope_size bytes.
9683            let cur_offset: usize = (3 - 1) * envelope_size;
9684
9685            // Zero reserved fields.
9686            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9687
9688            // Safety:
9689            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9690            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9691            //   envelope_size bytes, there is always sufficient room.
9692            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9693                self.original_association_maintained
9694                    .as_ref()
9695                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9696                encoder,
9697                offset + cur_offset,
9698                depth,
9699            )?;
9700
9701            _prev_end_offset = cur_offset + envelope_size;
9702            if 4 > max_ordinal {
9703                return Ok(());
9704            }
9705
9706            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9707            // are envelope_size bytes.
9708            let cur_offset: usize = (4 - 1) * envelope_size;
9709
9710            // Zero reserved fields.
9711            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9712
9713            // Safety:
9714            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9715            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9716            //   envelope_size bytes, there is always sufficient room.
9717            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9718                self.target_bss_authenticated
9719                    .as_ref()
9720                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9721                encoder,
9722                offset + cur_offset,
9723                depth,
9724            )?;
9725
9726            _prev_end_offset = cur_offset + envelope_size;
9727            if 5 > max_ordinal {
9728                return Ok(());
9729            }
9730
9731            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9732            // are envelope_size bytes.
9733            let cur_offset: usize = (5 - 1) * envelope_size;
9734
9735            // Zero reserved fields.
9736            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9737
9738            // Safety:
9739            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9740            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9741            //   envelope_size bytes, there is always sufficient room.
9742            fidl::encoding::encode_in_envelope_optional::<u16, D>(
9743                self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
9744                encoder,
9745                offset + cur_offset,
9746                depth,
9747            )?;
9748
9749            _prev_end_offset = cur_offset + envelope_size;
9750            if 6 > max_ordinal {
9751                return Ok(());
9752            }
9753
9754            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9755            // are envelope_size bytes.
9756            let cur_offset: usize = (6 - 1) * envelope_size;
9757
9758            // Zero reserved fields.
9759            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9760
9761            // Safety:
9762            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9763            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9764            //   envelope_size bytes, there is always sufficient room.
9765            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
9766            self.association_ies.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
9767            encoder, offset + cur_offset, depth
9768        )?;
9769
9770            _prev_end_offset = cur_offset + envelope_size;
9771
9772            Ok(())
9773        }
9774    }
9775
9776    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9777        for WlanFullmacImplIfcRoamConfRequest
9778    {
9779        #[inline(always)]
9780        fn new_empty() -> Self {
9781            Self::default()
9782        }
9783
9784        unsafe fn decode(
9785            &mut self,
9786            decoder: &mut fidl::encoding::Decoder<'_, D>,
9787            offset: usize,
9788            mut depth: fidl::encoding::Depth,
9789        ) -> fidl::Result<()> {
9790            decoder.debug_check_bounds::<Self>(offset);
9791            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9792                None => return Err(fidl::Error::NotNullable),
9793                Some(len) => len,
9794            };
9795            // Calling decoder.out_of_line_offset(0) is not allowed.
9796            if len == 0 {
9797                return Ok(());
9798            };
9799            depth.increment()?;
9800            let envelope_size = 8;
9801            let bytes_len = len * envelope_size;
9802            let offset = decoder.out_of_line_offset(bytes_len)?;
9803            // Decode the envelope for each type.
9804            let mut _next_ordinal_to_read = 0;
9805            let mut next_offset = offset;
9806            let end_offset = offset + bytes_len;
9807            _next_ordinal_to_read += 1;
9808            if next_offset >= end_offset {
9809                return Ok(());
9810            }
9811
9812            // Decode unknown envelopes for gaps in ordinals.
9813            while _next_ordinal_to_read < 1 {
9814                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9815                _next_ordinal_to_read += 1;
9816                next_offset += envelope_size;
9817            }
9818
9819            let next_out_of_line = decoder.next_out_of_line();
9820            let handles_before = decoder.remaining_handles();
9821            if let Some((inlined, num_bytes, num_handles)) =
9822                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9823            {
9824                let member_inline_size =
9825                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
9826                        decoder.context,
9827                    );
9828                if inlined != (member_inline_size <= 4) {
9829                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9830                }
9831                let inner_offset;
9832                let mut inner_depth = depth.clone();
9833                if inlined {
9834                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9835                    inner_offset = next_offset;
9836                } else {
9837                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9838                    inner_depth.increment()?;
9839                }
9840                let val_ref = self
9841                    .selected_bssid
9842                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
9843                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9872                if inlined != (member_inline_size <= 4) {
9873                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9874                }
9875                let inner_offset;
9876                let mut inner_depth = depth.clone();
9877                if inlined {
9878                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9879                    inner_offset = next_offset;
9880                } else {
9881                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9882                    inner_depth.increment()?;
9883                }
9884                let val_ref = self.status_code.get_or_insert_with(|| {
9885                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
9886                });
9887                fidl::decode!(
9888                    fidl_fuchsia_wlan_ieee80211__common::StatusCode,
9889                    D,
9890                    val_ref,
9891                    decoder,
9892                    inner_offset,
9893                    inner_depth
9894                )?;
9895                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9896                {
9897                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9898                }
9899                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9900                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9901                }
9902            }
9903
9904            next_offset += envelope_size;
9905            _next_ordinal_to_read += 1;
9906            if next_offset >= end_offset {
9907                return Ok(());
9908            }
9909
9910            // Decode unknown envelopes for gaps in ordinals.
9911            while _next_ordinal_to_read < 3 {
9912                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9913                _next_ordinal_to_read += 1;
9914                next_offset += envelope_size;
9915            }
9916
9917            let next_out_of_line = decoder.next_out_of_line();
9918            let handles_before = decoder.remaining_handles();
9919            if let Some((inlined, num_bytes, num_handles)) =
9920                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9921            {
9922                let member_inline_size =
9923                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9924                if inlined != (member_inline_size <= 4) {
9925                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9926                }
9927                let inner_offset;
9928                let mut inner_depth = depth.clone();
9929                if inlined {
9930                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9931                    inner_offset = next_offset;
9932                } else {
9933                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9934                    inner_depth.increment()?;
9935                }
9936                let val_ref = self
9937                    .original_association_maintained
9938                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
9939                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9940                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9941                {
9942                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9943                }
9944                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9945                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9946                }
9947            }
9948
9949            next_offset += envelope_size;
9950            _next_ordinal_to_read += 1;
9951            if next_offset >= end_offset {
9952                return Ok(());
9953            }
9954
9955            // Decode unknown envelopes for gaps in ordinals.
9956            while _next_ordinal_to_read < 4 {
9957                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9958                _next_ordinal_to_read += 1;
9959                next_offset += envelope_size;
9960            }
9961
9962            let next_out_of_line = decoder.next_out_of_line();
9963            let handles_before = decoder.remaining_handles();
9964            if let Some((inlined, num_bytes, num_handles)) =
9965                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9966            {
9967                let member_inline_size =
9968                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9969                if inlined != (member_inline_size <= 4) {
9970                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9971                }
9972                let inner_offset;
9973                let mut inner_depth = depth.clone();
9974                if inlined {
9975                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9976                    inner_offset = next_offset;
9977                } else {
9978                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9979                    inner_depth.increment()?;
9980                }
9981                let val_ref =
9982                    self.target_bss_authenticated.get_or_insert_with(|| fidl::new_empty!(bool, D));
9983                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9984                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9985                {
9986                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9987                }
9988                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9989                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9990                }
9991            }
9992
9993            next_offset += envelope_size;
9994            _next_ordinal_to_read += 1;
9995            if next_offset >= end_offset {
9996                return Ok(());
9997            }
9998
9999            // Decode unknown envelopes for gaps in ordinals.
10000            while _next_ordinal_to_read < 5 {
10001                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10002                _next_ordinal_to_read += 1;
10003                next_offset += envelope_size;
10004            }
10005
10006            let next_out_of_line = decoder.next_out_of_line();
10007            let handles_before = decoder.remaining_handles();
10008            if let Some((inlined, num_bytes, num_handles)) =
10009                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10010            {
10011                let member_inline_size =
10012                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10013                if inlined != (member_inline_size <= 4) {
10014                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10015                }
10016                let inner_offset;
10017                let mut inner_depth = depth.clone();
10018                if inlined {
10019                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10020                    inner_offset = next_offset;
10021                } else {
10022                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10023                    inner_depth.increment()?;
10024                }
10025                let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
10026                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
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            _next_ordinal_to_read += 1;
10038            if next_offset >= end_offset {
10039                return Ok(());
10040            }
10041
10042            // Decode unknown envelopes for gaps in ordinals.
10043            while _next_ordinal_to_read < 6 {
10044                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10045                _next_ordinal_to_read += 1;
10046                next_offset += envelope_size;
10047            }
10048
10049            let next_out_of_line = decoder.next_out_of_line();
10050            let handles_before = decoder.remaining_handles();
10051            if let Some((inlined, num_bytes, num_handles)) =
10052                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10053            {
10054                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10055                if inlined != (member_inline_size <= 4) {
10056                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10057                }
10058                let inner_offset;
10059                let mut inner_depth = depth.clone();
10060                if inlined {
10061                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10062                    inner_offset = next_offset;
10063                } else {
10064                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10065                    inner_depth.increment()?;
10066                }
10067                let val_ref = self.association_ies.get_or_insert_with(|| {
10068                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
10069                });
10070                fidl::decode!(
10071                    fidl::encoding::UnboundedVector<u8>,
10072                    D,
10073                    val_ref,
10074                    decoder,
10075                    inner_offset,
10076                    inner_depth
10077                )?;
10078                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10079                {
10080                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10081                }
10082                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10083                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10084                }
10085            }
10086
10087            next_offset += envelope_size;
10088
10089            // Decode the remaining unknown envelopes.
10090            while next_offset < end_offset {
10091                _next_ordinal_to_read += 1;
10092                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10093                next_offset += envelope_size;
10094            }
10095
10096            Ok(())
10097        }
10098    }
10099
10100    impl WlanFullmacImplIfcRoamResultIndRequest {
10101        #[inline(always)]
10102        fn max_ordinal_present(&self) -> u64 {
10103            if let Some(_) = self.association_ies {
10104                return 6;
10105            }
10106            if let Some(_) = self.association_id {
10107                return 5;
10108            }
10109            if let Some(_) = self.target_bss_authenticated {
10110                return 4;
10111            }
10112            if let Some(_) = self.original_association_maintained {
10113                return 3;
10114            }
10115            if let Some(_) = self.status_code {
10116                return 2;
10117            }
10118            if let Some(_) = self.selected_bssid {
10119                return 1;
10120            }
10121            0
10122        }
10123    }
10124
10125    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcRoamResultIndRequest {
10126        type Borrowed<'a> = &'a Self;
10127        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10128            value
10129        }
10130    }
10131
10132    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcRoamResultIndRequest {
10133        type Owned = Self;
10134
10135        #[inline(always)]
10136        fn inline_align(_context: fidl::encoding::Context) -> usize {
10137            8
10138        }
10139
10140        #[inline(always)]
10141        fn inline_size(_context: fidl::encoding::Context) -> usize {
10142            16
10143        }
10144    }
10145
10146    unsafe impl<D: fidl::encoding::ResourceDialect>
10147        fidl::encoding::Encode<WlanFullmacImplIfcRoamResultIndRequest, D>
10148        for &WlanFullmacImplIfcRoamResultIndRequest
10149    {
10150        unsafe fn encode(
10151            self,
10152            encoder: &mut fidl::encoding::Encoder<'_, D>,
10153            offset: usize,
10154            mut depth: fidl::encoding::Depth,
10155        ) -> fidl::Result<()> {
10156            encoder.debug_check_bounds::<WlanFullmacImplIfcRoamResultIndRequest>(offset);
10157            // Vector header
10158            let max_ordinal: u64 = self.max_ordinal_present();
10159            encoder.write_num(max_ordinal, offset);
10160            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10161            // Calling encoder.out_of_line_offset(0) is not allowed.
10162            if max_ordinal == 0 {
10163                return Ok(());
10164            }
10165            depth.increment()?;
10166            let envelope_size = 8;
10167            let bytes_len = max_ordinal as usize * envelope_size;
10168            #[allow(unused_variables)]
10169            let offset = encoder.out_of_line_offset(bytes_len);
10170            let mut _prev_end_offset: usize = 0;
10171            if 1 > max_ordinal {
10172                return Ok(());
10173            }
10174
10175            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10176            // are envelope_size bytes.
10177            let cur_offset: usize = (1 - 1) * envelope_size;
10178
10179            // Zero reserved fields.
10180            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10181
10182            // Safety:
10183            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10184            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10185            //   envelope_size bytes, there is always sufficient room.
10186            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
10187                self.selected_bssid
10188                    .as_ref()
10189                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
10190                encoder,
10191                offset + cur_offset,
10192                depth,
10193            )?;
10194
10195            _prev_end_offset = cur_offset + envelope_size;
10196            if 2 > max_ordinal {
10197                return Ok(());
10198            }
10199
10200            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10201            // are envelope_size bytes.
10202            let cur_offset: usize = (2 - 1) * envelope_size;
10203
10204            // Zero reserved fields.
10205            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10206
10207            // Safety:
10208            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10209            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10210            //   envelope_size bytes, there is always sufficient room.
10211            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
10212            self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
10213            encoder, offset + cur_offset, depth
10214        )?;
10215
10216            _prev_end_offset = cur_offset + envelope_size;
10217            if 3 > max_ordinal {
10218                return Ok(());
10219            }
10220
10221            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10222            // are envelope_size bytes.
10223            let cur_offset: usize = (3 - 1) * envelope_size;
10224
10225            // Zero reserved fields.
10226            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10227
10228            // Safety:
10229            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10230            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10231            //   envelope_size bytes, there is always sufficient room.
10232            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10233                self.original_association_maintained
10234                    .as_ref()
10235                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10236                encoder,
10237                offset + cur_offset,
10238                depth,
10239            )?;
10240
10241            _prev_end_offset = cur_offset + envelope_size;
10242            if 4 > max_ordinal {
10243                return Ok(());
10244            }
10245
10246            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10247            // are envelope_size bytes.
10248            let cur_offset: usize = (4 - 1) * envelope_size;
10249
10250            // Zero reserved fields.
10251            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10252
10253            // Safety:
10254            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10255            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10256            //   envelope_size bytes, there is always sufficient room.
10257            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10258                self.target_bss_authenticated
10259                    .as_ref()
10260                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10261                encoder,
10262                offset + cur_offset,
10263                depth,
10264            )?;
10265
10266            _prev_end_offset = cur_offset + envelope_size;
10267            if 5 > max_ordinal {
10268                return Ok(());
10269            }
10270
10271            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10272            // are envelope_size bytes.
10273            let cur_offset: usize = (5 - 1) * envelope_size;
10274
10275            // Zero reserved fields.
10276            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10277
10278            // Safety:
10279            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10280            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10281            //   envelope_size bytes, there is always sufficient room.
10282            fidl::encoding::encode_in_envelope_optional::<u16, D>(
10283                self.association_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
10284                encoder,
10285                offset + cur_offset,
10286                depth,
10287            )?;
10288
10289            _prev_end_offset = cur_offset + envelope_size;
10290            if 6 > max_ordinal {
10291                return Ok(());
10292            }
10293
10294            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10295            // are envelope_size bytes.
10296            let cur_offset: usize = (6 - 1) * envelope_size;
10297
10298            // Zero reserved fields.
10299            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10300
10301            // Safety:
10302            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10303            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10304            //   envelope_size bytes, there is always sufficient room.
10305            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
10306            self.association_ies.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
10307            encoder, offset + cur_offset, depth
10308        )?;
10309
10310            _prev_end_offset = cur_offset + envelope_size;
10311
10312            Ok(())
10313        }
10314    }
10315
10316    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10317        for WlanFullmacImplIfcRoamResultIndRequest
10318    {
10319        #[inline(always)]
10320        fn new_empty() -> Self {
10321            Self::default()
10322        }
10323
10324        unsafe fn decode(
10325            &mut self,
10326            decoder: &mut fidl::encoding::Decoder<'_, D>,
10327            offset: usize,
10328            mut depth: fidl::encoding::Depth,
10329        ) -> fidl::Result<()> {
10330            decoder.debug_check_bounds::<Self>(offset);
10331            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10332                None => return Err(fidl::Error::NotNullable),
10333                Some(len) => len,
10334            };
10335            // Calling decoder.out_of_line_offset(0) is not allowed.
10336            if len == 0 {
10337                return Ok(());
10338            };
10339            depth.increment()?;
10340            let envelope_size = 8;
10341            let bytes_len = len * envelope_size;
10342            let offset = decoder.out_of_line_offset(bytes_len)?;
10343            // Decode the envelope for each type.
10344            let mut _next_ordinal_to_read = 0;
10345            let mut next_offset = offset;
10346            let end_offset = offset + bytes_len;
10347            _next_ordinal_to_read += 1;
10348            if next_offset >= end_offset {
10349                return Ok(());
10350            }
10351
10352            // Decode unknown envelopes for gaps in ordinals.
10353            while _next_ordinal_to_read < 1 {
10354                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10355                _next_ordinal_to_read += 1;
10356                next_offset += envelope_size;
10357            }
10358
10359            let next_out_of_line = decoder.next_out_of_line();
10360            let handles_before = decoder.remaining_handles();
10361            if let Some((inlined, num_bytes, num_handles)) =
10362                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10363            {
10364                let member_inline_size =
10365                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
10366                        decoder.context,
10367                    );
10368                if inlined != (member_inline_size <= 4) {
10369                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10370                }
10371                let inner_offset;
10372                let mut inner_depth = depth.clone();
10373                if inlined {
10374                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10375                    inner_offset = next_offset;
10376                } else {
10377                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10378                    inner_depth.increment()?;
10379                }
10380                let val_ref = self
10381                    .selected_bssid
10382                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
10383                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10412                if inlined != (member_inline_size <= 4) {
10413                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10414                }
10415                let inner_offset;
10416                let mut inner_depth = depth.clone();
10417                if inlined {
10418                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10419                    inner_offset = next_offset;
10420                } else {
10421                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10422                    inner_depth.increment()?;
10423                }
10424                let val_ref = self.status_code.get_or_insert_with(|| {
10425                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
10426                });
10427                fidl::decode!(
10428                    fidl_fuchsia_wlan_ieee80211__common::StatusCode,
10429                    D,
10430                    val_ref,
10431                    decoder,
10432                    inner_offset,
10433                    inner_depth
10434                )?;
10435                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10436                {
10437                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10438                }
10439                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10440                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10441                }
10442            }
10443
10444            next_offset += envelope_size;
10445            _next_ordinal_to_read += 1;
10446            if next_offset >= end_offset {
10447                return Ok(());
10448            }
10449
10450            // Decode unknown envelopes for gaps in ordinals.
10451            while _next_ordinal_to_read < 3 {
10452                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10453                _next_ordinal_to_read += 1;
10454                next_offset += envelope_size;
10455            }
10456
10457            let next_out_of_line = decoder.next_out_of_line();
10458            let handles_before = decoder.remaining_handles();
10459            if let Some((inlined, num_bytes, num_handles)) =
10460                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10461            {
10462                let member_inline_size =
10463                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10464                if inlined != (member_inline_size <= 4) {
10465                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10466                }
10467                let inner_offset;
10468                let mut inner_depth = depth.clone();
10469                if inlined {
10470                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10471                    inner_offset = next_offset;
10472                } else {
10473                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10474                    inner_depth.increment()?;
10475                }
10476                let val_ref = self
10477                    .original_association_maintained
10478                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
10479                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10480                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10481                {
10482                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10483                }
10484                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10485                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10486                }
10487            }
10488
10489            next_offset += envelope_size;
10490            _next_ordinal_to_read += 1;
10491            if next_offset >= end_offset {
10492                return Ok(());
10493            }
10494
10495            // Decode unknown envelopes for gaps in ordinals.
10496            while _next_ordinal_to_read < 4 {
10497                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10498                _next_ordinal_to_read += 1;
10499                next_offset += envelope_size;
10500            }
10501
10502            let next_out_of_line = decoder.next_out_of_line();
10503            let handles_before = decoder.remaining_handles();
10504            if let Some((inlined, num_bytes, num_handles)) =
10505                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10506            {
10507                let member_inline_size =
10508                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10509                if inlined != (member_inline_size <= 4) {
10510                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10511                }
10512                let inner_offset;
10513                let mut inner_depth = depth.clone();
10514                if inlined {
10515                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10516                    inner_offset = next_offset;
10517                } else {
10518                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10519                    inner_depth.increment()?;
10520                }
10521                let val_ref =
10522                    self.target_bss_authenticated.get_or_insert_with(|| fidl::new_empty!(bool, D));
10523                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10524                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10525                {
10526                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10527                }
10528                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10529                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10530                }
10531            }
10532
10533            next_offset += envelope_size;
10534            _next_ordinal_to_read += 1;
10535            if next_offset >= end_offset {
10536                return Ok(());
10537            }
10538
10539            // Decode unknown envelopes for gaps in ordinals.
10540            while _next_ordinal_to_read < 5 {
10541                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10542                _next_ordinal_to_read += 1;
10543                next_offset += envelope_size;
10544            }
10545
10546            let next_out_of_line = decoder.next_out_of_line();
10547            let handles_before = decoder.remaining_handles();
10548            if let Some((inlined, num_bytes, num_handles)) =
10549                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10550            {
10551                let member_inline_size =
10552                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10553                if inlined != (member_inline_size <= 4) {
10554                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10555                }
10556                let inner_offset;
10557                let mut inner_depth = depth.clone();
10558                if inlined {
10559                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10560                    inner_offset = next_offset;
10561                } else {
10562                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10563                    inner_depth.increment()?;
10564                }
10565                let val_ref = self.association_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
10566                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
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            _next_ordinal_to_read += 1;
10578            if next_offset >= end_offset {
10579                return Ok(());
10580            }
10581
10582            // Decode unknown envelopes for gaps in ordinals.
10583            while _next_ordinal_to_read < 6 {
10584                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10585                _next_ordinal_to_read += 1;
10586                next_offset += envelope_size;
10587            }
10588
10589            let next_out_of_line = decoder.next_out_of_line();
10590            let handles_before = decoder.remaining_handles();
10591            if let Some((inlined, num_bytes, num_handles)) =
10592                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10593            {
10594                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10595                if inlined != (member_inline_size <= 4) {
10596                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10597                }
10598                let inner_offset;
10599                let mut inner_depth = depth.clone();
10600                if inlined {
10601                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10602                    inner_offset = next_offset;
10603                } else {
10604                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10605                    inner_depth.increment()?;
10606                }
10607                let val_ref = self.association_ies.get_or_insert_with(|| {
10608                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
10609                });
10610                fidl::decode!(
10611                    fidl::encoding::UnboundedVector<u8>,
10612                    D,
10613                    val_ref,
10614                    decoder,
10615                    inner_offset,
10616                    inner_depth
10617                )?;
10618                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10619                {
10620                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10621                }
10622                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10623                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10624                }
10625            }
10626
10627            next_offset += envelope_size;
10628
10629            // Decode the remaining unknown envelopes.
10630            while next_offset < end_offset {
10631                _next_ordinal_to_read += 1;
10632                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10633                next_offset += envelope_size;
10634            }
10635
10636            Ok(())
10637        }
10638    }
10639
10640    impl WlanFullmacImplIfcRoamStartIndRequest {
10641        #[inline(always)]
10642        fn max_ordinal_present(&self) -> u64 {
10643            if let Some(_) = self.original_association_maintained {
10644                return 3;
10645            }
10646            if let Some(_) = self.selected_bss {
10647                return 2;
10648            }
10649            if let Some(_) = self.selected_bssid {
10650                return 1;
10651            }
10652            0
10653        }
10654    }
10655
10656    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcRoamStartIndRequest {
10657        type Borrowed<'a> = &'a Self;
10658        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10659            value
10660        }
10661    }
10662
10663    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcRoamStartIndRequest {
10664        type Owned = Self;
10665
10666        #[inline(always)]
10667        fn inline_align(_context: fidl::encoding::Context) -> usize {
10668            8
10669        }
10670
10671        #[inline(always)]
10672        fn inline_size(_context: fidl::encoding::Context) -> usize {
10673            16
10674        }
10675    }
10676
10677    unsafe impl<D: fidl::encoding::ResourceDialect>
10678        fidl::encoding::Encode<WlanFullmacImplIfcRoamStartIndRequest, D>
10679        for &WlanFullmacImplIfcRoamStartIndRequest
10680    {
10681        unsafe fn encode(
10682            self,
10683            encoder: &mut fidl::encoding::Encoder<'_, D>,
10684            offset: usize,
10685            mut depth: fidl::encoding::Depth,
10686        ) -> fidl::Result<()> {
10687            encoder.debug_check_bounds::<WlanFullmacImplIfcRoamStartIndRequest>(offset);
10688            // Vector header
10689            let max_ordinal: u64 = self.max_ordinal_present();
10690            encoder.write_num(max_ordinal, offset);
10691            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10692            // Calling encoder.out_of_line_offset(0) is not allowed.
10693            if max_ordinal == 0 {
10694                return Ok(());
10695            }
10696            depth.increment()?;
10697            let envelope_size = 8;
10698            let bytes_len = max_ordinal as usize * envelope_size;
10699            #[allow(unused_variables)]
10700            let offset = encoder.out_of_line_offset(bytes_len);
10701            let mut _prev_end_offset: usize = 0;
10702            if 1 > max_ordinal {
10703                return Ok(());
10704            }
10705
10706            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10707            // are envelope_size bytes.
10708            let cur_offset: usize = (1 - 1) * envelope_size;
10709
10710            // Zero reserved fields.
10711            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10712
10713            // Safety:
10714            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10715            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10716            //   envelope_size bytes, there is always sufficient room.
10717            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
10718                self.selected_bssid
10719                    .as_ref()
10720                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
10721                encoder,
10722                offset + cur_offset,
10723                depth,
10724            )?;
10725
10726            _prev_end_offset = cur_offset + envelope_size;
10727            if 2 > max_ordinal {
10728                return Ok(());
10729            }
10730
10731            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10732            // are envelope_size bytes.
10733            let cur_offset: usize = (2 - 1) * envelope_size;
10734
10735            // Zero reserved fields.
10736            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10737
10738            // Safety:
10739            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10740            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10741            //   envelope_size bytes, there is always sufficient room.
10742            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
10743            self.selected_bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
10744            encoder, offset + cur_offset, depth
10745        )?;
10746
10747            _prev_end_offset = cur_offset + envelope_size;
10748            if 3 > max_ordinal {
10749                return Ok(());
10750            }
10751
10752            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10753            // are envelope_size bytes.
10754            let cur_offset: usize = (3 - 1) * envelope_size;
10755
10756            // Zero reserved fields.
10757            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10758
10759            // Safety:
10760            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10761            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10762            //   envelope_size bytes, there is always sufficient room.
10763            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10764                self.original_association_maintained
10765                    .as_ref()
10766                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10767                encoder,
10768                offset + cur_offset,
10769                depth,
10770            )?;
10771
10772            _prev_end_offset = cur_offset + envelope_size;
10773
10774            Ok(())
10775        }
10776    }
10777
10778    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10779        for WlanFullmacImplIfcRoamStartIndRequest
10780    {
10781        #[inline(always)]
10782        fn new_empty() -> Self {
10783            Self::default()
10784        }
10785
10786        unsafe fn decode(
10787            &mut self,
10788            decoder: &mut fidl::encoding::Decoder<'_, D>,
10789            offset: usize,
10790            mut depth: fidl::encoding::Depth,
10791        ) -> fidl::Result<()> {
10792            decoder.debug_check_bounds::<Self>(offset);
10793            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10794                None => return Err(fidl::Error::NotNullable),
10795                Some(len) => len,
10796            };
10797            // Calling decoder.out_of_line_offset(0) is not allowed.
10798            if len == 0 {
10799                return Ok(());
10800            };
10801            depth.increment()?;
10802            let envelope_size = 8;
10803            let bytes_len = len * envelope_size;
10804            let offset = decoder.out_of_line_offset(bytes_len)?;
10805            // Decode the envelope for each type.
10806            let mut _next_ordinal_to_read = 0;
10807            let mut next_offset = offset;
10808            let end_offset = offset + bytes_len;
10809            _next_ordinal_to_read += 1;
10810            if next_offset >= end_offset {
10811                return Ok(());
10812            }
10813
10814            // Decode unknown envelopes for gaps in ordinals.
10815            while _next_ordinal_to_read < 1 {
10816                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10817                _next_ordinal_to_read += 1;
10818                next_offset += envelope_size;
10819            }
10820
10821            let next_out_of_line = decoder.next_out_of_line();
10822            let handles_before = decoder.remaining_handles();
10823            if let Some((inlined, num_bytes, num_handles)) =
10824                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10825            {
10826                let member_inline_size =
10827                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
10828                        decoder.context,
10829                    );
10830                if inlined != (member_inline_size <= 4) {
10831                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10832                }
10833                let inner_offset;
10834                let mut inner_depth = depth.clone();
10835                if inlined {
10836                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10837                    inner_offset = next_offset;
10838                } else {
10839                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10840                    inner_depth.increment()?;
10841                }
10842                let val_ref = self
10843                    .selected_bssid
10844                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
10845                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10874                if inlined != (member_inline_size <= 4) {
10875                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10876                }
10877                let inner_offset;
10878                let mut inner_depth = depth.clone();
10879                if inlined {
10880                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10881                    inner_offset = next_offset;
10882                } else {
10883                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10884                    inner_depth.increment()?;
10885                }
10886                let val_ref = self.selected_bss.get_or_insert_with(|| {
10887                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
10888                });
10889                fidl::decode!(
10890                    fidl_fuchsia_wlan_common__common::BssDescription,
10891                    D,
10892                    val_ref,
10893                    decoder,
10894                    inner_offset,
10895                    inner_depth
10896                )?;
10897                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10898                {
10899                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10900                }
10901                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10902                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10903                }
10904            }
10905
10906            next_offset += envelope_size;
10907            _next_ordinal_to_read += 1;
10908            if next_offset >= end_offset {
10909                return Ok(());
10910            }
10911
10912            // Decode unknown envelopes for gaps in ordinals.
10913            while _next_ordinal_to_read < 3 {
10914                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10915                _next_ordinal_to_read += 1;
10916                next_offset += envelope_size;
10917            }
10918
10919            let next_out_of_line = decoder.next_out_of_line();
10920            let handles_before = decoder.remaining_handles();
10921            if let Some((inlined, num_bytes, num_handles)) =
10922                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10923            {
10924                let member_inline_size =
10925                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10926                if inlined != (member_inline_size <= 4) {
10927                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10928                }
10929                let inner_offset;
10930                let mut inner_depth = depth.clone();
10931                if inlined {
10932                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10933                    inner_offset = next_offset;
10934                } else {
10935                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10936                    inner_depth.increment()?;
10937                }
10938                let val_ref = self
10939                    .original_association_maintained
10940                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
10941                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10942                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10943                {
10944                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10945                }
10946                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10947                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10948                }
10949            }
10950
10951            next_offset += envelope_size;
10952
10953            // Decode the remaining unknown envelopes.
10954            while next_offset < end_offset {
10955                _next_ordinal_to_read += 1;
10956                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10957                next_offset += envelope_size;
10958            }
10959
10960            Ok(())
10961        }
10962    }
10963
10964    impl WlanFullmacImplIfcSaeHandshakeIndRequest {
10965        #[inline(always)]
10966        fn max_ordinal_present(&self) -> u64 {
10967            if let Some(_) = self.peer_sta_address {
10968                return 1;
10969            }
10970            0
10971        }
10972    }
10973
10974    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcSaeHandshakeIndRequest {
10975        type Borrowed<'a> = &'a Self;
10976        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10977            value
10978        }
10979    }
10980
10981    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcSaeHandshakeIndRequest {
10982        type Owned = Self;
10983
10984        #[inline(always)]
10985        fn inline_align(_context: fidl::encoding::Context) -> usize {
10986            8
10987        }
10988
10989        #[inline(always)]
10990        fn inline_size(_context: fidl::encoding::Context) -> usize {
10991            16
10992        }
10993    }
10994
10995    unsafe impl<D: fidl::encoding::ResourceDialect>
10996        fidl::encoding::Encode<WlanFullmacImplIfcSaeHandshakeIndRequest, D>
10997        for &WlanFullmacImplIfcSaeHandshakeIndRequest
10998    {
10999        unsafe fn encode(
11000            self,
11001            encoder: &mut fidl::encoding::Encoder<'_, D>,
11002            offset: usize,
11003            mut depth: fidl::encoding::Depth,
11004        ) -> fidl::Result<()> {
11005            encoder.debug_check_bounds::<WlanFullmacImplIfcSaeHandshakeIndRequest>(offset);
11006            // Vector header
11007            let max_ordinal: u64 = self.max_ordinal_present();
11008            encoder.write_num(max_ordinal, offset);
11009            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11010            // Calling encoder.out_of_line_offset(0) is not allowed.
11011            if max_ordinal == 0 {
11012                return Ok(());
11013            }
11014            depth.increment()?;
11015            let envelope_size = 8;
11016            let bytes_len = max_ordinal as usize * envelope_size;
11017            #[allow(unused_variables)]
11018            let offset = encoder.out_of_line_offset(bytes_len);
11019            let mut _prev_end_offset: usize = 0;
11020            if 1 > max_ordinal {
11021                return Ok(());
11022            }
11023
11024            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11025            // are envelope_size bytes.
11026            let cur_offset: usize = (1 - 1) * envelope_size;
11027
11028            // Zero reserved fields.
11029            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11030
11031            // Safety:
11032            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11033            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11034            //   envelope_size bytes, there is always sufficient room.
11035            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
11036                self.peer_sta_address
11037                    .as_ref()
11038                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
11039                encoder,
11040                offset + cur_offset,
11041                depth,
11042            )?;
11043
11044            _prev_end_offset = cur_offset + envelope_size;
11045
11046            Ok(())
11047        }
11048    }
11049
11050    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11051        for WlanFullmacImplIfcSaeHandshakeIndRequest
11052    {
11053        #[inline(always)]
11054        fn new_empty() -> Self {
11055            Self::default()
11056        }
11057
11058        unsafe fn decode(
11059            &mut self,
11060            decoder: &mut fidl::encoding::Decoder<'_, D>,
11061            offset: usize,
11062            mut depth: fidl::encoding::Depth,
11063        ) -> fidl::Result<()> {
11064            decoder.debug_check_bounds::<Self>(offset);
11065            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11066                None => return Err(fidl::Error::NotNullable),
11067                Some(len) => len,
11068            };
11069            // Calling decoder.out_of_line_offset(0) is not allowed.
11070            if len == 0 {
11071                return Ok(());
11072            };
11073            depth.increment()?;
11074            let envelope_size = 8;
11075            let bytes_len = len * envelope_size;
11076            let offset = decoder.out_of_line_offset(bytes_len)?;
11077            // Decode the envelope for each type.
11078            let mut _next_ordinal_to_read = 0;
11079            let mut next_offset = offset;
11080            let end_offset = offset + bytes_len;
11081            _next_ordinal_to_read += 1;
11082            if next_offset >= end_offset {
11083                return Ok(());
11084            }
11085
11086            // Decode unknown envelopes for gaps in ordinals.
11087            while _next_ordinal_to_read < 1 {
11088                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11089                _next_ordinal_to_read += 1;
11090                next_offset += envelope_size;
11091            }
11092
11093            let next_out_of_line = decoder.next_out_of_line();
11094            let handles_before = decoder.remaining_handles();
11095            if let Some((inlined, num_bytes, num_handles)) =
11096                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11097            {
11098                let member_inline_size =
11099                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
11100                        decoder.context,
11101                    );
11102                if inlined != (member_inline_size <= 4) {
11103                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11104                }
11105                let inner_offset;
11106                let mut inner_depth = depth.clone();
11107                if inlined {
11108                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11109                    inner_offset = next_offset;
11110                } else {
11111                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11112                    inner_depth.increment()?;
11113                }
11114                let val_ref = self
11115                    .peer_sta_address
11116                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
11117                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
11118                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11119                {
11120                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11121                }
11122                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11123                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11124                }
11125            }
11126
11127            next_offset += envelope_size;
11128
11129            // Decode the remaining unknown envelopes.
11130            while next_offset < end_offset {
11131                _next_ordinal_to_read += 1;
11132                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11133                next_offset += envelope_size;
11134            }
11135
11136            Ok(())
11137        }
11138    }
11139
11140    impl WlanFullmacImplIfcStartConfRequest {
11141        #[inline(always)]
11142        fn max_ordinal_present(&self) -> u64 {
11143            if let Some(_) = self.result_code {
11144                return 1;
11145            }
11146            0
11147        }
11148    }
11149
11150    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcStartConfRequest {
11151        type Borrowed<'a> = &'a Self;
11152        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11153            value
11154        }
11155    }
11156
11157    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcStartConfRequest {
11158        type Owned = Self;
11159
11160        #[inline(always)]
11161        fn inline_align(_context: fidl::encoding::Context) -> usize {
11162            8
11163        }
11164
11165        #[inline(always)]
11166        fn inline_size(_context: fidl::encoding::Context) -> usize {
11167            16
11168        }
11169    }
11170
11171    unsafe impl<D: fidl::encoding::ResourceDialect>
11172        fidl::encoding::Encode<WlanFullmacImplIfcStartConfRequest, D>
11173        for &WlanFullmacImplIfcStartConfRequest
11174    {
11175        unsafe fn encode(
11176            self,
11177            encoder: &mut fidl::encoding::Encoder<'_, D>,
11178            offset: usize,
11179            mut depth: fidl::encoding::Depth,
11180        ) -> fidl::Result<()> {
11181            encoder.debug_check_bounds::<WlanFullmacImplIfcStartConfRequest>(offset);
11182            // Vector header
11183            let max_ordinal: u64 = self.max_ordinal_present();
11184            encoder.write_num(max_ordinal, offset);
11185            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11186            // Calling encoder.out_of_line_offset(0) is not allowed.
11187            if max_ordinal == 0 {
11188                return Ok(());
11189            }
11190            depth.increment()?;
11191            let envelope_size = 8;
11192            let bytes_len = max_ordinal as usize * envelope_size;
11193            #[allow(unused_variables)]
11194            let offset = encoder.out_of_line_offset(bytes_len);
11195            let mut _prev_end_offset: usize = 0;
11196            if 1 > max_ordinal {
11197                return Ok(());
11198            }
11199
11200            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11201            // are envelope_size bytes.
11202            let cur_offset: usize = (1 - 1) * envelope_size;
11203
11204            // Zero reserved fields.
11205            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11206
11207            // Safety:
11208            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11209            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11210            //   envelope_size bytes, there is always sufficient room.
11211            fidl::encoding::encode_in_envelope_optional::<StartResult, D>(
11212                self.result_code
11213                    .as_ref()
11214                    .map(<StartResult as fidl::encoding::ValueTypeMarker>::borrow),
11215                encoder,
11216                offset + cur_offset,
11217                depth,
11218            )?;
11219
11220            _prev_end_offset = cur_offset + envelope_size;
11221
11222            Ok(())
11223        }
11224    }
11225
11226    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11227        for WlanFullmacImplIfcStartConfRequest
11228    {
11229        #[inline(always)]
11230        fn new_empty() -> Self {
11231            Self::default()
11232        }
11233
11234        unsafe fn decode(
11235            &mut self,
11236            decoder: &mut fidl::encoding::Decoder<'_, D>,
11237            offset: usize,
11238            mut depth: fidl::encoding::Depth,
11239        ) -> fidl::Result<()> {
11240            decoder.debug_check_bounds::<Self>(offset);
11241            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11242                None => return Err(fidl::Error::NotNullable),
11243                Some(len) => len,
11244            };
11245            // Calling decoder.out_of_line_offset(0) is not allowed.
11246            if len == 0 {
11247                return Ok(());
11248            };
11249            depth.increment()?;
11250            let envelope_size = 8;
11251            let bytes_len = len * envelope_size;
11252            let offset = decoder.out_of_line_offset(bytes_len)?;
11253            // Decode the envelope for each type.
11254            let mut _next_ordinal_to_read = 0;
11255            let mut next_offset = offset;
11256            let end_offset = offset + bytes_len;
11257            _next_ordinal_to_read += 1;
11258            if next_offset >= end_offset {
11259                return Ok(());
11260            }
11261
11262            // Decode unknown envelopes for gaps in ordinals.
11263            while _next_ordinal_to_read < 1 {
11264                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11265                _next_ordinal_to_read += 1;
11266                next_offset += envelope_size;
11267            }
11268
11269            let next_out_of_line = decoder.next_out_of_line();
11270            let handles_before = decoder.remaining_handles();
11271            if let Some((inlined, num_bytes, num_handles)) =
11272                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11273            {
11274                let member_inline_size =
11275                    <StartResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11276                if inlined != (member_inline_size <= 4) {
11277                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11278                }
11279                let inner_offset;
11280                let mut inner_depth = depth.clone();
11281                if inlined {
11282                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11283                    inner_offset = next_offset;
11284                } else {
11285                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11286                    inner_depth.increment()?;
11287                }
11288                let val_ref =
11289                    self.result_code.get_or_insert_with(|| fidl::new_empty!(StartResult, D));
11290                fidl::decode!(StartResult, D, val_ref, decoder, inner_offset, inner_depth)?;
11291                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11292                {
11293                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11294                }
11295                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11296                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11297                }
11298            }
11299
11300            next_offset += envelope_size;
11301
11302            // Decode the remaining unknown envelopes.
11303            while next_offset < end_offset {
11304                _next_ordinal_to_read += 1;
11305                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11306                next_offset += envelope_size;
11307            }
11308
11309            Ok(())
11310        }
11311    }
11312
11313    impl WlanFullmacImplIfcStopConfRequest {
11314        #[inline(always)]
11315        fn max_ordinal_present(&self) -> u64 {
11316            if let Some(_) = self.result_code {
11317                return 1;
11318            }
11319            0
11320        }
11321    }
11322
11323    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplIfcStopConfRequest {
11324        type Borrowed<'a> = &'a Self;
11325        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11326            value
11327        }
11328    }
11329
11330    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplIfcStopConfRequest {
11331        type Owned = Self;
11332
11333        #[inline(always)]
11334        fn inline_align(_context: fidl::encoding::Context) -> usize {
11335            8
11336        }
11337
11338        #[inline(always)]
11339        fn inline_size(_context: fidl::encoding::Context) -> usize {
11340            16
11341        }
11342    }
11343
11344    unsafe impl<D: fidl::encoding::ResourceDialect>
11345        fidl::encoding::Encode<WlanFullmacImplIfcStopConfRequest, D>
11346        for &WlanFullmacImplIfcStopConfRequest
11347    {
11348        unsafe fn encode(
11349            self,
11350            encoder: &mut fidl::encoding::Encoder<'_, D>,
11351            offset: usize,
11352            mut depth: fidl::encoding::Depth,
11353        ) -> fidl::Result<()> {
11354            encoder.debug_check_bounds::<WlanFullmacImplIfcStopConfRequest>(offset);
11355            // Vector header
11356            let max_ordinal: u64 = self.max_ordinal_present();
11357            encoder.write_num(max_ordinal, offset);
11358            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11359            // Calling encoder.out_of_line_offset(0) is not allowed.
11360            if max_ordinal == 0 {
11361                return Ok(());
11362            }
11363            depth.increment()?;
11364            let envelope_size = 8;
11365            let bytes_len = max_ordinal as usize * envelope_size;
11366            #[allow(unused_variables)]
11367            let offset = encoder.out_of_line_offset(bytes_len);
11368            let mut _prev_end_offset: usize = 0;
11369            if 1 > max_ordinal {
11370                return Ok(());
11371            }
11372
11373            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11374            // are envelope_size bytes.
11375            let cur_offset: usize = (1 - 1) * envelope_size;
11376
11377            // Zero reserved fields.
11378            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11379
11380            // Safety:
11381            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11382            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11383            //   envelope_size bytes, there is always sufficient room.
11384            fidl::encoding::encode_in_envelope_optional::<StopResult, D>(
11385                self.result_code
11386                    .as_ref()
11387                    .map(<StopResult as fidl::encoding::ValueTypeMarker>::borrow),
11388                encoder,
11389                offset + cur_offset,
11390                depth,
11391            )?;
11392
11393            _prev_end_offset = cur_offset + envelope_size;
11394
11395            Ok(())
11396        }
11397    }
11398
11399    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11400        for WlanFullmacImplIfcStopConfRequest
11401    {
11402        #[inline(always)]
11403        fn new_empty() -> Self {
11404            Self::default()
11405        }
11406
11407        unsafe fn decode(
11408            &mut self,
11409            decoder: &mut fidl::encoding::Decoder<'_, D>,
11410            offset: usize,
11411            mut depth: fidl::encoding::Depth,
11412        ) -> fidl::Result<()> {
11413            decoder.debug_check_bounds::<Self>(offset);
11414            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11415                None => return Err(fidl::Error::NotNullable),
11416                Some(len) => len,
11417            };
11418            // Calling decoder.out_of_line_offset(0) is not allowed.
11419            if len == 0 {
11420                return Ok(());
11421            };
11422            depth.increment()?;
11423            let envelope_size = 8;
11424            let bytes_len = len * envelope_size;
11425            let offset = decoder.out_of_line_offset(bytes_len)?;
11426            // Decode the envelope for each type.
11427            let mut _next_ordinal_to_read = 0;
11428            let mut next_offset = offset;
11429            let end_offset = offset + bytes_len;
11430            _next_ordinal_to_read += 1;
11431            if next_offset >= end_offset {
11432                return Ok(());
11433            }
11434
11435            // Decode unknown envelopes for gaps in ordinals.
11436            while _next_ordinal_to_read < 1 {
11437                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11438                _next_ordinal_to_read += 1;
11439                next_offset += envelope_size;
11440            }
11441
11442            let next_out_of_line = decoder.next_out_of_line();
11443            let handles_before = decoder.remaining_handles();
11444            if let Some((inlined, num_bytes, num_handles)) =
11445                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11446            {
11447                let member_inline_size =
11448                    <StopResult as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11449                if inlined != (member_inline_size <= 4) {
11450                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11451                }
11452                let inner_offset;
11453                let mut inner_depth = depth.clone();
11454                if inlined {
11455                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11456                    inner_offset = next_offset;
11457                } else {
11458                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11459                    inner_depth.increment()?;
11460                }
11461                let val_ref =
11462                    self.result_code.get_or_insert_with(|| fidl::new_empty!(StopResult, D));
11463                fidl::decode!(StopResult, D, val_ref, decoder, inner_offset, inner_depth)?;
11464                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11465                {
11466                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11467                }
11468                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11469                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11470                }
11471            }
11472
11473            next_offset += envelope_size;
11474
11475            // Decode the remaining unknown envelopes.
11476            while next_offset < end_offset {
11477                _next_ordinal_to_read += 1;
11478                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11479                next_offset += envelope_size;
11480            }
11481
11482            Ok(())
11483        }
11484    }
11485
11486    impl WlanFullmacImplOnLinkStateChangedRequest {
11487        #[inline(always)]
11488        fn max_ordinal_present(&self) -> u64 {
11489            if let Some(_) = self.online {
11490                return 1;
11491            }
11492            0
11493        }
11494    }
11495
11496    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplOnLinkStateChangedRequest {
11497        type Borrowed<'a> = &'a Self;
11498        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11499            value
11500        }
11501    }
11502
11503    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplOnLinkStateChangedRequest {
11504        type Owned = Self;
11505
11506        #[inline(always)]
11507        fn inline_align(_context: fidl::encoding::Context) -> usize {
11508            8
11509        }
11510
11511        #[inline(always)]
11512        fn inline_size(_context: fidl::encoding::Context) -> usize {
11513            16
11514        }
11515    }
11516
11517    unsafe impl<D: fidl::encoding::ResourceDialect>
11518        fidl::encoding::Encode<WlanFullmacImplOnLinkStateChangedRequest, D>
11519        for &WlanFullmacImplOnLinkStateChangedRequest
11520    {
11521        unsafe fn encode(
11522            self,
11523            encoder: &mut fidl::encoding::Encoder<'_, D>,
11524            offset: usize,
11525            mut depth: fidl::encoding::Depth,
11526        ) -> fidl::Result<()> {
11527            encoder.debug_check_bounds::<WlanFullmacImplOnLinkStateChangedRequest>(offset);
11528            // Vector header
11529            let max_ordinal: u64 = self.max_ordinal_present();
11530            encoder.write_num(max_ordinal, offset);
11531            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11532            // Calling encoder.out_of_line_offset(0) is not allowed.
11533            if max_ordinal == 0 {
11534                return Ok(());
11535            }
11536            depth.increment()?;
11537            let envelope_size = 8;
11538            let bytes_len = max_ordinal as usize * envelope_size;
11539            #[allow(unused_variables)]
11540            let offset = encoder.out_of_line_offset(bytes_len);
11541            let mut _prev_end_offset: usize = 0;
11542            if 1 > max_ordinal {
11543                return Ok(());
11544            }
11545
11546            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11547            // are envelope_size bytes.
11548            let cur_offset: usize = (1 - 1) * envelope_size;
11549
11550            // Zero reserved fields.
11551            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11552
11553            // Safety:
11554            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11555            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11556            //   envelope_size bytes, there is always sufficient room.
11557            fidl::encoding::encode_in_envelope_optional::<bool, D>(
11558                self.online.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
11559                encoder,
11560                offset + cur_offset,
11561                depth,
11562            )?;
11563
11564            _prev_end_offset = cur_offset + envelope_size;
11565
11566            Ok(())
11567        }
11568    }
11569
11570    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11571        for WlanFullmacImplOnLinkStateChangedRequest
11572    {
11573        #[inline(always)]
11574        fn new_empty() -> Self {
11575            Self::default()
11576        }
11577
11578        unsafe fn decode(
11579            &mut self,
11580            decoder: &mut fidl::encoding::Decoder<'_, D>,
11581            offset: usize,
11582            mut depth: fidl::encoding::Depth,
11583        ) -> fidl::Result<()> {
11584            decoder.debug_check_bounds::<Self>(offset);
11585            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11586                None => return Err(fidl::Error::NotNullable),
11587                Some(len) => len,
11588            };
11589            // Calling decoder.out_of_line_offset(0) is not allowed.
11590            if len == 0 {
11591                return Ok(());
11592            };
11593            depth.increment()?;
11594            let envelope_size = 8;
11595            let bytes_len = len * envelope_size;
11596            let offset = decoder.out_of_line_offset(bytes_len)?;
11597            // Decode the envelope for each type.
11598            let mut _next_ordinal_to_read = 0;
11599            let mut next_offset = offset;
11600            let end_offset = offset + bytes_len;
11601            _next_ordinal_to_read += 1;
11602            if next_offset >= end_offset {
11603                return Ok(());
11604            }
11605
11606            // Decode unknown envelopes for gaps in ordinals.
11607            while _next_ordinal_to_read < 1 {
11608                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11609                _next_ordinal_to_read += 1;
11610                next_offset += envelope_size;
11611            }
11612
11613            let next_out_of_line = decoder.next_out_of_line();
11614            let handles_before = decoder.remaining_handles();
11615            if let Some((inlined, num_bytes, num_handles)) =
11616                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11617            {
11618                let member_inline_size =
11619                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11620                if inlined != (member_inline_size <= 4) {
11621                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11622                }
11623                let inner_offset;
11624                let mut inner_depth = depth.clone();
11625                if inlined {
11626                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11627                    inner_offset = next_offset;
11628                } else {
11629                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11630                    inner_depth.increment()?;
11631                }
11632                let val_ref = self.online.get_or_insert_with(|| fidl::new_empty!(bool, D));
11633                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11634                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11635                {
11636                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11637                }
11638                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11639                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11640                }
11641            }
11642
11643            next_offset += envelope_size;
11644
11645            // Decode the remaining unknown envelopes.
11646            while next_offset < end_offset {
11647                _next_ordinal_to_read += 1;
11648                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11649                next_offset += envelope_size;
11650            }
11651
11652            Ok(())
11653        }
11654    }
11655
11656    impl WlanFullmacImplReconnectRequest {
11657        #[inline(always)]
11658        fn max_ordinal_present(&self) -> u64 {
11659            if let Some(_) = self.peer_sta_address {
11660                return 1;
11661            }
11662            0
11663        }
11664    }
11665
11666    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplReconnectRequest {
11667        type Borrowed<'a> = &'a Self;
11668        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11669            value
11670        }
11671    }
11672
11673    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplReconnectRequest {
11674        type Owned = Self;
11675
11676        #[inline(always)]
11677        fn inline_align(_context: fidl::encoding::Context) -> usize {
11678            8
11679        }
11680
11681        #[inline(always)]
11682        fn inline_size(_context: fidl::encoding::Context) -> usize {
11683            16
11684        }
11685    }
11686
11687    unsafe impl<D: fidl::encoding::ResourceDialect>
11688        fidl::encoding::Encode<WlanFullmacImplReconnectRequest, D>
11689        for &WlanFullmacImplReconnectRequest
11690    {
11691        unsafe fn encode(
11692            self,
11693            encoder: &mut fidl::encoding::Encoder<'_, D>,
11694            offset: usize,
11695            mut depth: fidl::encoding::Depth,
11696        ) -> fidl::Result<()> {
11697            encoder.debug_check_bounds::<WlanFullmacImplReconnectRequest>(offset);
11698            // Vector header
11699            let max_ordinal: u64 = self.max_ordinal_present();
11700            encoder.write_num(max_ordinal, offset);
11701            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11702            // Calling encoder.out_of_line_offset(0) is not allowed.
11703            if max_ordinal == 0 {
11704                return Ok(());
11705            }
11706            depth.increment()?;
11707            let envelope_size = 8;
11708            let bytes_len = max_ordinal as usize * envelope_size;
11709            #[allow(unused_variables)]
11710            let offset = encoder.out_of_line_offset(bytes_len);
11711            let mut _prev_end_offset: usize = 0;
11712            if 1 > max_ordinal {
11713                return Ok(());
11714            }
11715
11716            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11717            // are envelope_size bytes.
11718            let cur_offset: usize = (1 - 1) * envelope_size;
11719
11720            // Zero reserved fields.
11721            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11722
11723            // Safety:
11724            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11725            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11726            //   envelope_size bytes, there is always sufficient room.
11727            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
11728                self.peer_sta_address
11729                    .as_ref()
11730                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
11731                encoder,
11732                offset + cur_offset,
11733                depth,
11734            )?;
11735
11736            _prev_end_offset = cur_offset + envelope_size;
11737
11738            Ok(())
11739        }
11740    }
11741
11742    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11743        for WlanFullmacImplReconnectRequest
11744    {
11745        #[inline(always)]
11746        fn new_empty() -> Self {
11747            Self::default()
11748        }
11749
11750        unsafe fn decode(
11751            &mut self,
11752            decoder: &mut fidl::encoding::Decoder<'_, D>,
11753            offset: usize,
11754            mut depth: fidl::encoding::Depth,
11755        ) -> fidl::Result<()> {
11756            decoder.debug_check_bounds::<Self>(offset);
11757            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11758                None => return Err(fidl::Error::NotNullable),
11759                Some(len) => len,
11760            };
11761            // Calling decoder.out_of_line_offset(0) is not allowed.
11762            if len == 0 {
11763                return Ok(());
11764            };
11765            depth.increment()?;
11766            let envelope_size = 8;
11767            let bytes_len = len * envelope_size;
11768            let offset = decoder.out_of_line_offset(bytes_len)?;
11769            // Decode the envelope for each type.
11770            let mut _next_ordinal_to_read = 0;
11771            let mut next_offset = offset;
11772            let end_offset = offset + bytes_len;
11773            _next_ordinal_to_read += 1;
11774            if next_offset >= end_offset {
11775                return Ok(());
11776            }
11777
11778            // Decode unknown envelopes for gaps in ordinals.
11779            while _next_ordinal_to_read < 1 {
11780                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11781                _next_ordinal_to_read += 1;
11782                next_offset += envelope_size;
11783            }
11784
11785            let next_out_of_line = decoder.next_out_of_line();
11786            let handles_before = decoder.remaining_handles();
11787            if let Some((inlined, num_bytes, num_handles)) =
11788                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11789            {
11790                let member_inline_size =
11791                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
11792                        decoder.context,
11793                    );
11794                if inlined != (member_inline_size <= 4) {
11795                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11796                }
11797                let inner_offset;
11798                let mut inner_depth = depth.clone();
11799                if inlined {
11800                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11801                    inner_offset = next_offset;
11802                } else {
11803                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11804                    inner_depth.increment()?;
11805                }
11806                let val_ref = self
11807                    .peer_sta_address
11808                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
11809                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
11810                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11811                {
11812                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11813                }
11814                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11815                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11816                }
11817            }
11818
11819            next_offset += envelope_size;
11820
11821            // Decode the remaining unknown envelopes.
11822            while next_offset < end_offset {
11823                _next_ordinal_to_read += 1;
11824                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11825                next_offset += envelope_size;
11826            }
11827
11828            Ok(())
11829        }
11830    }
11831
11832    impl WlanFullmacImplRoamRequest {
11833        #[inline(always)]
11834        fn max_ordinal_present(&self) -> u64 {
11835            if let Some(_) = self.selected_bss {
11836                return 1;
11837            }
11838            0
11839        }
11840    }
11841
11842    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplRoamRequest {
11843        type Borrowed<'a> = &'a Self;
11844        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11845            value
11846        }
11847    }
11848
11849    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplRoamRequest {
11850        type Owned = Self;
11851
11852        #[inline(always)]
11853        fn inline_align(_context: fidl::encoding::Context) -> usize {
11854            8
11855        }
11856
11857        #[inline(always)]
11858        fn inline_size(_context: fidl::encoding::Context) -> usize {
11859            16
11860        }
11861    }
11862
11863    unsafe impl<D: fidl::encoding::ResourceDialect>
11864        fidl::encoding::Encode<WlanFullmacImplRoamRequest, D> for &WlanFullmacImplRoamRequest
11865    {
11866        unsafe fn encode(
11867            self,
11868            encoder: &mut fidl::encoding::Encoder<'_, D>,
11869            offset: usize,
11870            mut depth: fidl::encoding::Depth,
11871        ) -> fidl::Result<()> {
11872            encoder.debug_check_bounds::<WlanFullmacImplRoamRequest>(offset);
11873            // Vector header
11874            let max_ordinal: u64 = self.max_ordinal_present();
11875            encoder.write_num(max_ordinal, offset);
11876            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11877            // Calling encoder.out_of_line_offset(0) is not allowed.
11878            if max_ordinal == 0 {
11879                return Ok(());
11880            }
11881            depth.increment()?;
11882            let envelope_size = 8;
11883            let bytes_len = max_ordinal as usize * envelope_size;
11884            #[allow(unused_variables)]
11885            let offset = encoder.out_of_line_offset(bytes_len);
11886            let mut _prev_end_offset: usize = 0;
11887            if 1 > max_ordinal {
11888                return Ok(());
11889            }
11890
11891            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11892            // are envelope_size bytes.
11893            let cur_offset: usize = (1 - 1) * envelope_size;
11894
11895            // Zero reserved fields.
11896            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11897
11898            // Safety:
11899            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11900            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11901            //   envelope_size bytes, there is always sufficient room.
11902            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssDescription, D>(
11903            self.selected_bss.as_ref().map(<fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow),
11904            encoder, offset + cur_offset, depth
11905        )?;
11906
11907            _prev_end_offset = cur_offset + envelope_size;
11908
11909            Ok(())
11910        }
11911    }
11912
11913    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11914        for WlanFullmacImplRoamRequest
11915    {
11916        #[inline(always)]
11917        fn new_empty() -> Self {
11918            Self::default()
11919        }
11920
11921        unsafe fn decode(
11922            &mut self,
11923            decoder: &mut fidl::encoding::Decoder<'_, D>,
11924            offset: usize,
11925            mut depth: fidl::encoding::Depth,
11926        ) -> fidl::Result<()> {
11927            decoder.debug_check_bounds::<Self>(offset);
11928            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11929                None => return Err(fidl::Error::NotNullable),
11930                Some(len) => len,
11931            };
11932            // Calling decoder.out_of_line_offset(0) is not allowed.
11933            if len == 0 {
11934                return Ok(());
11935            };
11936            depth.increment()?;
11937            let envelope_size = 8;
11938            let bytes_len = len * envelope_size;
11939            let offset = decoder.out_of_line_offset(bytes_len)?;
11940            // Decode the envelope for each type.
11941            let mut _next_ordinal_to_read = 0;
11942            let mut next_offset = offset;
11943            let end_offset = offset + bytes_len;
11944            _next_ordinal_to_read += 1;
11945            if next_offset >= end_offset {
11946                return Ok(());
11947            }
11948
11949            // Decode unknown envelopes for gaps in ordinals.
11950            while _next_ordinal_to_read < 1 {
11951                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11952                _next_ordinal_to_read += 1;
11953                next_offset += envelope_size;
11954            }
11955
11956            let next_out_of_line = decoder.next_out_of_line();
11957            let handles_before = decoder.remaining_handles();
11958            if let Some((inlined, num_bytes, num_handles)) =
11959                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11960            {
11961                let member_inline_size = <fidl_fuchsia_wlan_common__common::BssDescription as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11962                if inlined != (member_inline_size <= 4) {
11963                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11964                }
11965                let inner_offset;
11966                let mut inner_depth = depth.clone();
11967                if inlined {
11968                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11969                    inner_offset = next_offset;
11970                } else {
11971                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11972                    inner_depth.increment()?;
11973                }
11974                let val_ref = self.selected_bss.get_or_insert_with(|| {
11975                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssDescription, D)
11976                });
11977                fidl::decode!(
11978                    fidl_fuchsia_wlan_common__common::BssDescription,
11979                    D,
11980                    val_ref,
11981                    decoder,
11982                    inner_offset,
11983                    inner_depth
11984                )?;
11985                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11986                {
11987                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11988                }
11989                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11990                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11991                }
11992            }
11993
11994            next_offset += envelope_size;
11995
11996            // Decode the remaining unknown envelopes.
11997            while next_offset < end_offset {
11998                _next_ordinal_to_read += 1;
11999                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12000                next_offset += envelope_size;
12001            }
12002
12003            Ok(())
12004        }
12005    }
12006
12007    impl WlanFullmacImplSaeHandshakeRespRequest {
12008        #[inline(always)]
12009        fn max_ordinal_present(&self) -> u64 {
12010            if let Some(_) = self.status_code {
12011                return 2;
12012            }
12013            if let Some(_) = self.peer_sta_address {
12014                return 1;
12015            }
12016            0
12017        }
12018    }
12019
12020    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSaeHandshakeRespRequest {
12021        type Borrowed<'a> = &'a Self;
12022        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12023            value
12024        }
12025    }
12026
12027    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSaeHandshakeRespRequest {
12028        type Owned = Self;
12029
12030        #[inline(always)]
12031        fn inline_align(_context: fidl::encoding::Context) -> usize {
12032            8
12033        }
12034
12035        #[inline(always)]
12036        fn inline_size(_context: fidl::encoding::Context) -> usize {
12037            16
12038        }
12039    }
12040
12041    unsafe impl<D: fidl::encoding::ResourceDialect>
12042        fidl::encoding::Encode<WlanFullmacImplSaeHandshakeRespRequest, D>
12043        for &WlanFullmacImplSaeHandshakeRespRequest
12044    {
12045        unsafe fn encode(
12046            self,
12047            encoder: &mut fidl::encoding::Encoder<'_, D>,
12048            offset: usize,
12049            mut depth: fidl::encoding::Depth,
12050        ) -> fidl::Result<()> {
12051            encoder.debug_check_bounds::<WlanFullmacImplSaeHandshakeRespRequest>(offset);
12052            // Vector header
12053            let max_ordinal: u64 = self.max_ordinal_present();
12054            encoder.write_num(max_ordinal, offset);
12055            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12056            // Calling encoder.out_of_line_offset(0) is not allowed.
12057            if max_ordinal == 0 {
12058                return Ok(());
12059            }
12060            depth.increment()?;
12061            let envelope_size = 8;
12062            let bytes_len = max_ordinal as usize * envelope_size;
12063            #[allow(unused_variables)]
12064            let offset = encoder.out_of_line_offset(bytes_len);
12065            let mut _prev_end_offset: usize = 0;
12066            if 1 > max_ordinal {
12067                return Ok(());
12068            }
12069
12070            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12071            // are envelope_size bytes.
12072            let cur_offset: usize = (1 - 1) * envelope_size;
12073
12074            // Zero reserved fields.
12075            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12076
12077            // Safety:
12078            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12079            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12080            //   envelope_size bytes, there is always sufficient room.
12081            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
12082                self.peer_sta_address
12083                    .as_ref()
12084                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
12085                encoder,
12086                offset + cur_offset,
12087                depth,
12088            )?;
12089
12090            _prev_end_offset = cur_offset + envelope_size;
12091            if 2 > max_ordinal {
12092                return Ok(());
12093            }
12094
12095            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12096            // are envelope_size bytes.
12097            let cur_offset: usize = (2 - 1) * envelope_size;
12098
12099            // Zero reserved fields.
12100            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12101
12102            // Safety:
12103            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12104            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12105            //   envelope_size bytes, there is always sufficient room.
12106            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>(
12107            self.status_code.as_ref().map(<fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow),
12108            encoder, offset + cur_offset, depth
12109        )?;
12110
12111            _prev_end_offset = cur_offset + envelope_size;
12112
12113            Ok(())
12114        }
12115    }
12116
12117    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12118        for WlanFullmacImplSaeHandshakeRespRequest
12119    {
12120        #[inline(always)]
12121        fn new_empty() -> Self {
12122            Self::default()
12123        }
12124
12125        unsafe fn decode(
12126            &mut self,
12127            decoder: &mut fidl::encoding::Decoder<'_, D>,
12128            offset: usize,
12129            mut depth: fidl::encoding::Depth,
12130        ) -> fidl::Result<()> {
12131            decoder.debug_check_bounds::<Self>(offset);
12132            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12133                None => return Err(fidl::Error::NotNullable),
12134                Some(len) => len,
12135            };
12136            // Calling decoder.out_of_line_offset(0) is not allowed.
12137            if len == 0 {
12138                return Ok(());
12139            };
12140            depth.increment()?;
12141            let envelope_size = 8;
12142            let bytes_len = len * envelope_size;
12143            let offset = decoder.out_of_line_offset(bytes_len)?;
12144            // Decode the envelope for each type.
12145            let mut _next_ordinal_to_read = 0;
12146            let mut next_offset = offset;
12147            let end_offset = offset + bytes_len;
12148            _next_ordinal_to_read += 1;
12149            if next_offset >= end_offset {
12150                return Ok(());
12151            }
12152
12153            // Decode unknown envelopes for gaps in ordinals.
12154            while _next_ordinal_to_read < 1 {
12155                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12156                _next_ordinal_to_read += 1;
12157                next_offset += envelope_size;
12158            }
12159
12160            let next_out_of_line = decoder.next_out_of_line();
12161            let handles_before = decoder.remaining_handles();
12162            if let Some((inlined, num_bytes, num_handles)) =
12163                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12164            {
12165                let member_inline_size =
12166                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
12167                        decoder.context,
12168                    );
12169                if inlined != (member_inline_size <= 4) {
12170                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12171                }
12172                let inner_offset;
12173                let mut inner_depth = depth.clone();
12174                if inlined {
12175                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12176                    inner_offset = next_offset;
12177                } else {
12178                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12179                    inner_depth.increment()?;
12180                }
12181                let val_ref = self
12182                    .peer_sta_address
12183                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
12184                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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            _next_ordinal_to_read += 1;
12196            if next_offset >= end_offset {
12197                return Ok(());
12198            }
12199
12200            // Decode unknown envelopes for gaps in ordinals.
12201            while _next_ordinal_to_read < 2 {
12202                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12203                _next_ordinal_to_read += 1;
12204                next_offset += envelope_size;
12205            }
12206
12207            let next_out_of_line = decoder.next_out_of_line();
12208            let handles_before = decoder.remaining_handles();
12209            if let Some((inlined, num_bytes, num_handles)) =
12210                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12211            {
12212                let member_inline_size = <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12213                if inlined != (member_inline_size <= 4) {
12214                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12215                }
12216                let inner_offset;
12217                let mut inner_depth = depth.clone();
12218                if inlined {
12219                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12220                    inner_offset = next_offset;
12221                } else {
12222                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12223                    inner_depth.increment()?;
12224                }
12225                let val_ref = self.status_code.get_or_insert_with(|| {
12226                    fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D)
12227                });
12228                fidl::decode!(
12229                    fidl_fuchsia_wlan_ieee80211__common::StatusCode,
12230                    D,
12231                    val_ref,
12232                    decoder,
12233                    inner_offset,
12234                    inner_depth
12235                )?;
12236                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12237                {
12238                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12239                }
12240                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12241                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12242                }
12243            }
12244
12245            next_offset += envelope_size;
12246
12247            // Decode the remaining unknown envelopes.
12248            while next_offset < end_offset {
12249                _next_ordinal_to_read += 1;
12250                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12251                next_offset += envelope_size;
12252            }
12253
12254            Ok(())
12255        }
12256    }
12257
12258    impl WlanFullmacImplSetKeysRequest {
12259        #[inline(always)]
12260        fn max_ordinal_present(&self) -> u64 {
12261            if let Some(_) = self.key_descriptors {
12262                return 2;
12263            }
12264            if let Some(_) = self.keylist {
12265                return 1;
12266            }
12267            0
12268        }
12269    }
12270
12271    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplSetKeysRequest {
12272        type Borrowed<'a> = &'a Self;
12273        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12274            value
12275        }
12276    }
12277
12278    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplSetKeysRequest {
12279        type Owned = Self;
12280
12281        #[inline(always)]
12282        fn inline_align(_context: fidl::encoding::Context) -> usize {
12283            8
12284        }
12285
12286        #[inline(always)]
12287        fn inline_size(_context: fidl::encoding::Context) -> usize {
12288            16
12289        }
12290    }
12291
12292    unsafe impl<D: fidl::encoding::ResourceDialect>
12293        fidl::encoding::Encode<WlanFullmacImplSetKeysRequest, D>
12294        for &WlanFullmacImplSetKeysRequest
12295    {
12296        unsafe fn encode(
12297            self,
12298            encoder: &mut fidl::encoding::Encoder<'_, D>,
12299            offset: usize,
12300            mut depth: fidl::encoding::Depth,
12301        ) -> fidl::Result<()> {
12302            encoder.debug_check_bounds::<WlanFullmacImplSetKeysRequest>(offset);
12303            // Vector header
12304            let max_ordinal: u64 = self.max_ordinal_present();
12305            encoder.write_num(max_ordinal, offset);
12306            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12307            // Calling encoder.out_of_line_offset(0) is not allowed.
12308            if max_ordinal == 0 {
12309                return Ok(());
12310            }
12311            depth.increment()?;
12312            let envelope_size = 8;
12313            let bytes_len = max_ordinal as usize * envelope_size;
12314            #[allow(unused_variables)]
12315            let offset = encoder.out_of_line_offset(bytes_len);
12316            let mut _prev_end_offset: usize = 0;
12317            if 1 > max_ordinal {
12318                return Ok(());
12319            }
12320
12321            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12322            // are envelope_size bytes.
12323            let cur_offset: usize = (1 - 1) * envelope_size;
12324
12325            // Zero reserved fields.
12326            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12327
12328            // Safety:
12329            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12330            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12331            //   envelope_size bytes, there is always sufficient room.
12332            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4>, D>(
12333            self.keylist.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4> as fidl::encoding::ValueTypeMarker>::borrow),
12334            encoder, offset + cur_offset, depth
12335        )?;
12336
12337            _prev_end_offset = cur_offset + envelope_size;
12338            if 2 > max_ordinal {
12339                return Ok(());
12340            }
12341
12342            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12343            // are envelope_size bytes.
12344            let cur_offset: usize = (2 - 1) * envelope_size;
12345
12346            // Zero reserved fields.
12347            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12348
12349            // Safety:
12350            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12351            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12352            //   envelope_size bytes, there is always sufficient room.
12353            fidl::encoding::encode_in_envelope_optional::<
12354                fidl::encoding::Vector<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, 4>,
12355                D,
12356            >(
12357                self.key_descriptors.as_ref().map(
12358                    <fidl::encoding::Vector<
12359                        fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor,
12360                        4,
12361                    > as fidl::encoding::ValueTypeMarker>::borrow,
12362                ),
12363                encoder,
12364                offset + cur_offset,
12365                depth,
12366            )?;
12367
12368            _prev_end_offset = cur_offset + envelope_size;
12369
12370            Ok(())
12371        }
12372    }
12373
12374    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12375        for WlanFullmacImplSetKeysRequest
12376    {
12377        #[inline(always)]
12378        fn new_empty() -> Self {
12379            Self::default()
12380        }
12381
12382        unsafe fn decode(
12383            &mut self,
12384            decoder: &mut fidl::encoding::Decoder<'_, D>,
12385            offset: usize,
12386            mut depth: fidl::encoding::Depth,
12387        ) -> fidl::Result<()> {
12388            decoder.debug_check_bounds::<Self>(offset);
12389            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12390                None => return Err(fidl::Error::NotNullable),
12391                Some(len) => len,
12392            };
12393            // Calling decoder.out_of_line_offset(0) is not allowed.
12394            if len == 0 {
12395                return Ok(());
12396            };
12397            depth.increment()?;
12398            let envelope_size = 8;
12399            let bytes_len = len * envelope_size;
12400            let offset = decoder.out_of_line_offset(bytes_len)?;
12401            // Decode the envelope for each type.
12402            let mut _next_ordinal_to_read = 0;
12403            let mut next_offset = offset;
12404            let end_offset = offset + bytes_len;
12405            _next_ordinal_to_read += 1;
12406            if next_offset >= end_offset {
12407                return Ok(());
12408            }
12409
12410            // Decode unknown envelopes for gaps in ordinals.
12411            while _next_ordinal_to_read < 1 {
12412                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12413                _next_ordinal_to_read += 1;
12414                next_offset += envelope_size;
12415            }
12416
12417            let next_out_of_line = decoder.next_out_of_line();
12418            let handles_before = decoder.remaining_handles();
12419            if let Some((inlined, num_bytes, num_handles)) =
12420                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12421            {
12422                let member_inline_size = <fidl::encoding::Vector<
12423                    fidl_fuchsia_wlan_common__common::WlanKeyConfig,
12424                    4,
12425                > as fidl::encoding::TypeMarker>::inline_size(
12426                    decoder.context
12427                );
12428                if inlined != (member_inline_size <= 4) {
12429                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12430                }
12431                let inner_offset;
12432                let mut inner_depth = depth.clone();
12433                if inlined {
12434                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12435                    inner_offset = next_offset;
12436                } else {
12437                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12438                    inner_depth.increment()?;
12439                }
12440                let val_ref =
12441                self.keylist.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4>, D));
12442                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanKeyConfig, 4>, D, val_ref, decoder, inner_offset, inner_depth)?;
12443                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12444                {
12445                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12446                }
12447                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12448                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12449                }
12450            }
12451
12452            next_offset += envelope_size;
12453            _next_ordinal_to_read += 1;
12454            if next_offset >= end_offset {
12455                return Ok(());
12456            }
12457
12458            // Decode unknown envelopes for gaps in ordinals.
12459            while _next_ordinal_to_read < 2 {
12460                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12461                _next_ordinal_to_read += 1;
12462                next_offset += envelope_size;
12463            }
12464
12465            let next_out_of_line = decoder.next_out_of_line();
12466            let handles_before = decoder.remaining_handles();
12467            if let Some((inlined, num_bytes, num_handles)) =
12468                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12469            {
12470                let member_inline_size = <fidl::encoding::Vector<
12471                    fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor,
12472                    4,
12473                > as fidl::encoding::TypeMarker>::inline_size(
12474                    decoder.context
12475                );
12476                if inlined != (member_inline_size <= 4) {
12477                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12478                }
12479                let inner_offset;
12480                let mut inner_depth = depth.clone();
12481                if inlined {
12482                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12483                    inner_offset = next_offset;
12484                } else {
12485                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12486                    inner_depth.increment()?;
12487                }
12488                let val_ref =
12489                self.key_descriptors.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, 4>, D));
12490                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_wlan_ieee80211__common::SetKeyDescriptor, 4>, D, val_ref, decoder, inner_offset, inner_depth)?;
12491                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12492                {
12493                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12494                }
12495                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12496                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12497                }
12498            }
12499
12500            next_offset += envelope_size;
12501
12502            // Decode the remaining unknown envelopes.
12503            while next_offset < end_offset {
12504                _next_ordinal_to_read += 1;
12505                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12506                next_offset += envelope_size;
12507            }
12508
12509            Ok(())
12510        }
12511    }
12512
12513    impl WlanFullmacImplStartBssRequest {
12514        #[inline(always)]
12515        fn max_ordinal_present(&self) -> u64 {
12516            if let Some(_) = self.vendor_ie {
12517                return 7;
12518            }
12519            if let Some(_) = self.rsne {
12520                return 6;
12521            }
12522            if let Some(_) = self.channel {
12523                return 5;
12524            }
12525            if let Some(_) = self.dtim_period {
12526                return 4;
12527            }
12528            if let Some(_) = self.beacon_period {
12529                return 3;
12530            }
12531            if let Some(_) = self.bss_type {
12532                return 2;
12533            }
12534            if let Some(_) = self.ssid {
12535                return 1;
12536            }
12537            0
12538        }
12539    }
12540
12541    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplStartBssRequest {
12542        type Borrowed<'a> = &'a Self;
12543        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12544            value
12545        }
12546    }
12547
12548    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplStartBssRequest {
12549        type Owned = Self;
12550
12551        #[inline(always)]
12552        fn inline_align(_context: fidl::encoding::Context) -> usize {
12553            8
12554        }
12555
12556        #[inline(always)]
12557        fn inline_size(_context: fidl::encoding::Context) -> usize {
12558            16
12559        }
12560    }
12561
12562    unsafe impl<D: fidl::encoding::ResourceDialect>
12563        fidl::encoding::Encode<WlanFullmacImplStartBssRequest, D>
12564        for &WlanFullmacImplStartBssRequest
12565    {
12566        unsafe fn encode(
12567            self,
12568            encoder: &mut fidl::encoding::Encoder<'_, D>,
12569            offset: usize,
12570            mut depth: fidl::encoding::Depth,
12571        ) -> fidl::Result<()> {
12572            encoder.debug_check_bounds::<WlanFullmacImplStartBssRequest>(offset);
12573            // Vector header
12574            let max_ordinal: u64 = self.max_ordinal_present();
12575            encoder.write_num(max_ordinal, offset);
12576            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12577            // Calling encoder.out_of_line_offset(0) is not allowed.
12578            if max_ordinal == 0 {
12579                return Ok(());
12580            }
12581            depth.increment()?;
12582            let envelope_size = 8;
12583            let bytes_len = max_ordinal as usize * envelope_size;
12584            #[allow(unused_variables)]
12585            let offset = encoder.out_of_line_offset(bytes_len);
12586            let mut _prev_end_offset: usize = 0;
12587            if 1 > max_ordinal {
12588                return Ok(());
12589            }
12590
12591            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12592            // are envelope_size bytes.
12593            let cur_offset: usize = (1 - 1) * envelope_size;
12594
12595            // Zero reserved fields.
12596            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12597
12598            // Safety:
12599            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12600            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12601            //   envelope_size bytes, there is always sufficient room.
12602            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
12603                self.ssid.as_ref().map(
12604                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
12605                ),
12606                encoder,
12607                offset + cur_offset,
12608                depth,
12609            )?;
12610
12611            _prev_end_offset = cur_offset + envelope_size;
12612            if 2 > max_ordinal {
12613                return Ok(());
12614            }
12615
12616            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12617            // are envelope_size bytes.
12618            let cur_offset: usize = (2 - 1) * envelope_size;
12619
12620            // Zero reserved fields.
12621            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12622
12623            // Safety:
12624            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12625            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12626            //   envelope_size bytes, there is always sufficient room.
12627            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::BssType, D>(
12628            self.bss_type.as_ref().map(<fidl_fuchsia_wlan_common__common::BssType as fidl::encoding::ValueTypeMarker>::borrow),
12629            encoder, offset + cur_offset, depth
12630        )?;
12631
12632            _prev_end_offset = cur_offset + envelope_size;
12633            if 3 > max_ordinal {
12634                return Ok(());
12635            }
12636
12637            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12638            // are envelope_size bytes.
12639            let cur_offset: usize = (3 - 1) * envelope_size;
12640
12641            // Zero reserved fields.
12642            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12643
12644            // Safety:
12645            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12646            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12647            //   envelope_size bytes, there is always sufficient room.
12648            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12649                self.beacon_period.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12650                encoder,
12651                offset + cur_offset,
12652                depth,
12653            )?;
12654
12655            _prev_end_offset = cur_offset + envelope_size;
12656            if 4 > max_ordinal {
12657                return Ok(());
12658            }
12659
12660            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12661            // are envelope_size bytes.
12662            let cur_offset: usize = (4 - 1) * envelope_size;
12663
12664            // Zero reserved fields.
12665            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12666
12667            // Safety:
12668            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12669            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12670            //   envelope_size bytes, there is always sufficient room.
12671            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12672                self.dtim_period.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12673                encoder,
12674                offset + cur_offset,
12675                depth,
12676            )?;
12677
12678            _prev_end_offset = cur_offset + envelope_size;
12679            if 5 > max_ordinal {
12680                return Ok(());
12681            }
12682
12683            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12684            // are envelope_size bytes.
12685            let cur_offset: usize = (5 - 1) * envelope_size;
12686
12687            // Zero reserved fields.
12688            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12689
12690            // Safety:
12691            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12692            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12693            //   envelope_size bytes, there is always sufficient room.
12694            fidl::encoding::encode_in_envelope_optional::<u8, D>(
12695                self.channel.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
12696                encoder,
12697                offset + cur_offset,
12698                depth,
12699            )?;
12700
12701            _prev_end_offset = cur_offset + envelope_size;
12702            if 6 > max_ordinal {
12703                return Ok(());
12704            }
12705
12706            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12707            // are envelope_size bytes.
12708            let cur_offset: usize = (6 - 1) * envelope_size;
12709
12710            // Zero reserved fields.
12711            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12712
12713            // Safety:
12714            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12715            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12716            //   envelope_size bytes, there is always sufficient room.
12717            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 257>, D>(
12718                self.rsne.as_ref().map(
12719                    <fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow,
12720                ),
12721                encoder,
12722                offset + cur_offset,
12723                depth,
12724            )?;
12725
12726            _prev_end_offset = cur_offset + envelope_size;
12727            if 7 > max_ordinal {
12728                return Ok(());
12729            }
12730
12731            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12732            // are envelope_size bytes.
12733            let cur_offset: usize = (7 - 1) * envelope_size;
12734
12735            // Zero reserved fields.
12736            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12737
12738            // Safety:
12739            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12740            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12741            //   envelope_size bytes, there is always sufficient room.
12742            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 514>, D>(
12743                self.vendor_ie.as_ref().map(
12744                    <fidl::encoding::Vector<u8, 514> as fidl::encoding::ValueTypeMarker>::borrow,
12745                ),
12746                encoder,
12747                offset + cur_offset,
12748                depth,
12749            )?;
12750
12751            _prev_end_offset = cur_offset + envelope_size;
12752
12753            Ok(())
12754        }
12755    }
12756
12757    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12758        for WlanFullmacImplStartBssRequest
12759    {
12760        #[inline(always)]
12761        fn new_empty() -> Self {
12762            Self::default()
12763        }
12764
12765        unsafe fn decode(
12766            &mut self,
12767            decoder: &mut fidl::encoding::Decoder<'_, D>,
12768            offset: usize,
12769            mut depth: fidl::encoding::Depth,
12770        ) -> fidl::Result<()> {
12771            decoder.debug_check_bounds::<Self>(offset);
12772            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12773                None => return Err(fidl::Error::NotNullable),
12774                Some(len) => len,
12775            };
12776            // Calling decoder.out_of_line_offset(0) is not allowed.
12777            if len == 0 {
12778                return Ok(());
12779            };
12780            depth.increment()?;
12781            let envelope_size = 8;
12782            let bytes_len = len * envelope_size;
12783            let offset = decoder.out_of_line_offset(bytes_len)?;
12784            // Decode the envelope for each type.
12785            let mut _next_ordinal_to_read = 0;
12786            let mut next_offset = offset;
12787            let end_offset = offset + bytes_len;
12788            _next_ordinal_to_read += 1;
12789            if next_offset >= end_offset {
12790                return Ok(());
12791            }
12792
12793            // Decode unknown envelopes for gaps in ordinals.
12794            while _next_ordinal_to_read < 1 {
12795                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12796                _next_ordinal_to_read += 1;
12797                next_offset += envelope_size;
12798            }
12799
12800            let next_out_of_line = decoder.next_out_of_line();
12801            let handles_before = decoder.remaining_handles();
12802            if let Some((inlined, num_bytes, num_handles)) =
12803                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12804            {
12805                let member_inline_size =
12806                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
12807                        decoder.context,
12808                    );
12809                if inlined != (member_inline_size <= 4) {
12810                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12811                }
12812                let inner_offset;
12813                let mut inner_depth = depth.clone();
12814                if inlined {
12815                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12816                    inner_offset = next_offset;
12817                } else {
12818                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12819                    inner_depth.increment()?;
12820                }
12821                let val_ref = self
12822                    .ssid
12823                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
12824                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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 = <fidl_fuchsia_wlan_common__common::BssType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12853                if inlined != (member_inline_size <= 4) {
12854                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12855                }
12856                let inner_offset;
12857                let mut inner_depth = depth.clone();
12858                if inlined {
12859                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12860                    inner_offset = next_offset;
12861                } else {
12862                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12863                    inner_depth.increment()?;
12864                }
12865                let val_ref = self.bss_type.get_or_insert_with(|| {
12866                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::BssType, D)
12867                });
12868                fidl::decode!(
12869                    fidl_fuchsia_wlan_common__common::BssType,
12870                    D,
12871                    val_ref,
12872                    decoder,
12873                    inner_offset,
12874                    inner_depth
12875                )?;
12876                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12877                {
12878                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12879                }
12880                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12881                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12882                }
12883            }
12884
12885            next_offset += envelope_size;
12886            _next_ordinal_to_read += 1;
12887            if next_offset >= end_offset {
12888                return Ok(());
12889            }
12890
12891            // Decode unknown envelopes for gaps in ordinals.
12892            while _next_ordinal_to_read < 3 {
12893                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12894                _next_ordinal_to_read += 1;
12895                next_offset += envelope_size;
12896            }
12897
12898            let next_out_of_line = decoder.next_out_of_line();
12899            let handles_before = decoder.remaining_handles();
12900            if let Some((inlined, num_bytes, num_handles)) =
12901                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12902            {
12903                let member_inline_size =
12904                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12905                if inlined != (member_inline_size <= 4) {
12906                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12907                }
12908                let inner_offset;
12909                let mut inner_depth = depth.clone();
12910                if inlined {
12911                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12912                    inner_offset = next_offset;
12913                } else {
12914                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12915                    inner_depth.increment()?;
12916                }
12917                let val_ref = self.beacon_period.get_or_insert_with(|| fidl::new_empty!(u32, D));
12918                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12919                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12920                {
12921                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12922                }
12923                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12924                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12925                }
12926            }
12927
12928            next_offset += envelope_size;
12929            _next_ordinal_to_read += 1;
12930            if next_offset >= end_offset {
12931                return Ok(());
12932            }
12933
12934            // Decode unknown envelopes for gaps in ordinals.
12935            while _next_ordinal_to_read < 4 {
12936                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12937                _next_ordinal_to_read += 1;
12938                next_offset += envelope_size;
12939            }
12940
12941            let next_out_of_line = decoder.next_out_of_line();
12942            let handles_before = decoder.remaining_handles();
12943            if let Some((inlined, num_bytes, num_handles)) =
12944                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12945            {
12946                let member_inline_size =
12947                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12948                if inlined != (member_inline_size <= 4) {
12949                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12950                }
12951                let inner_offset;
12952                let mut inner_depth = depth.clone();
12953                if inlined {
12954                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12955                    inner_offset = next_offset;
12956                } else {
12957                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12958                    inner_depth.increment()?;
12959                }
12960                let val_ref = self.dtim_period.get_or_insert_with(|| fidl::new_empty!(u32, D));
12961                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12962                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12963                {
12964                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12965                }
12966                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12967                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12968                }
12969            }
12970
12971            next_offset += envelope_size;
12972            _next_ordinal_to_read += 1;
12973            if next_offset >= end_offset {
12974                return Ok(());
12975            }
12976
12977            // Decode unknown envelopes for gaps in ordinals.
12978            while _next_ordinal_to_read < 5 {
12979                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12980                _next_ordinal_to_read += 1;
12981                next_offset += envelope_size;
12982            }
12983
12984            let next_out_of_line = decoder.next_out_of_line();
12985            let handles_before = decoder.remaining_handles();
12986            if let Some((inlined, num_bytes, num_handles)) =
12987                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12988            {
12989                let member_inline_size =
12990                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12991                if inlined != (member_inline_size <= 4) {
12992                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12993                }
12994                let inner_offset;
12995                let mut inner_depth = depth.clone();
12996                if inlined {
12997                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12998                    inner_offset = next_offset;
12999                } else {
13000                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13001                    inner_depth.increment()?;
13002                }
13003                let val_ref = self.channel.get_or_insert_with(|| fidl::new_empty!(u8, D));
13004                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
13005                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13006                {
13007                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13008                }
13009                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13010                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13011                }
13012            }
13013
13014            next_offset += envelope_size;
13015            _next_ordinal_to_read += 1;
13016            if next_offset >= end_offset {
13017                return Ok(());
13018            }
13019
13020            // Decode unknown envelopes for gaps in ordinals.
13021            while _next_ordinal_to_read < 6 {
13022                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13023                _next_ordinal_to_read += 1;
13024                next_offset += envelope_size;
13025            }
13026
13027            let next_out_of_line = decoder.next_out_of_line();
13028            let handles_before = decoder.remaining_handles();
13029            if let Some((inlined, num_bytes, num_handles)) =
13030                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13031            {
13032                let member_inline_size =
13033                    <fidl::encoding::Vector<u8, 257> as fidl::encoding::TypeMarker>::inline_size(
13034                        decoder.context,
13035                    );
13036                if inlined != (member_inline_size <= 4) {
13037                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13038                }
13039                let inner_offset;
13040                let mut inner_depth = depth.clone();
13041                if inlined {
13042                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13043                    inner_offset = next_offset;
13044                } else {
13045                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13046                    inner_depth.increment()?;
13047                }
13048                let val_ref = self
13049                    .rsne
13050                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 257>, D));
13051                fidl::decode!(fidl::encoding::Vector<u8, 257>, D, val_ref, decoder, inner_offset, inner_depth)?;
13052                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13053                {
13054                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13055                }
13056                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13057                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13058                }
13059            }
13060
13061            next_offset += envelope_size;
13062            _next_ordinal_to_read += 1;
13063            if next_offset >= end_offset {
13064                return Ok(());
13065            }
13066
13067            // Decode unknown envelopes for gaps in ordinals.
13068            while _next_ordinal_to_read < 7 {
13069                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13070                _next_ordinal_to_read += 1;
13071                next_offset += envelope_size;
13072            }
13073
13074            let next_out_of_line = decoder.next_out_of_line();
13075            let handles_before = decoder.remaining_handles();
13076            if let Some((inlined, num_bytes, num_handles)) =
13077                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13078            {
13079                let member_inline_size =
13080                    <fidl::encoding::Vector<u8, 514> as fidl::encoding::TypeMarker>::inline_size(
13081                        decoder.context,
13082                    );
13083                if inlined != (member_inline_size <= 4) {
13084                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13085                }
13086                let inner_offset;
13087                let mut inner_depth = depth.clone();
13088                if inlined {
13089                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13090                    inner_offset = next_offset;
13091                } else {
13092                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13093                    inner_depth.increment()?;
13094                }
13095                let val_ref = self
13096                    .vendor_ie
13097                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 514>, D));
13098                fidl::decode!(fidl::encoding::Vector<u8, 514>, D, val_ref, decoder, inner_offset, inner_depth)?;
13099                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13100                {
13101                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13102                }
13103                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13104                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13105                }
13106            }
13107
13108            next_offset += envelope_size;
13109
13110            // Decode the remaining unknown envelopes.
13111            while next_offset < end_offset {
13112                _next_ordinal_to_read += 1;
13113                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13114                next_offset += envelope_size;
13115            }
13116
13117            Ok(())
13118        }
13119    }
13120
13121    impl WlanFullmacImplStartScanRequest {
13122        #[inline(always)]
13123        fn max_ordinal_present(&self) -> u64 {
13124            if let Some(_) = self.max_channel_time {
13125                return 6;
13126            }
13127            if let Some(_) = self.min_channel_time {
13128                return 5;
13129            }
13130            if let Some(_) = self.ssids {
13131                return 4;
13132            }
13133            if let Some(_) = self.channels {
13134                return 3;
13135            }
13136            if let Some(_) = self.scan_type {
13137                return 2;
13138            }
13139            if let Some(_) = self.txn_id {
13140                return 1;
13141            }
13142            0
13143        }
13144    }
13145
13146    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplStartScanRequest {
13147        type Borrowed<'a> = &'a Self;
13148        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13149            value
13150        }
13151    }
13152
13153    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplStartScanRequest {
13154        type Owned = Self;
13155
13156        #[inline(always)]
13157        fn inline_align(_context: fidl::encoding::Context) -> usize {
13158            8
13159        }
13160
13161        #[inline(always)]
13162        fn inline_size(_context: fidl::encoding::Context) -> usize {
13163            16
13164        }
13165    }
13166
13167    unsafe impl<D: fidl::encoding::ResourceDialect>
13168        fidl::encoding::Encode<WlanFullmacImplStartScanRequest, D>
13169        for &WlanFullmacImplStartScanRequest
13170    {
13171        unsafe fn encode(
13172            self,
13173            encoder: &mut fidl::encoding::Encoder<'_, D>,
13174            offset: usize,
13175            mut depth: fidl::encoding::Depth,
13176        ) -> fidl::Result<()> {
13177            encoder.debug_check_bounds::<WlanFullmacImplStartScanRequest>(offset);
13178            // Vector header
13179            let max_ordinal: u64 = self.max_ordinal_present();
13180            encoder.write_num(max_ordinal, offset);
13181            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13182            // Calling encoder.out_of_line_offset(0) is not allowed.
13183            if max_ordinal == 0 {
13184                return Ok(());
13185            }
13186            depth.increment()?;
13187            let envelope_size = 8;
13188            let bytes_len = max_ordinal as usize * envelope_size;
13189            #[allow(unused_variables)]
13190            let offset = encoder.out_of_line_offset(bytes_len);
13191            let mut _prev_end_offset: usize = 0;
13192            if 1 > max_ordinal {
13193                return Ok(());
13194            }
13195
13196            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13197            // are envelope_size bytes.
13198            let cur_offset: usize = (1 - 1) * envelope_size;
13199
13200            // Zero reserved fields.
13201            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13202
13203            // Safety:
13204            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13205            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13206            //   envelope_size bytes, there is always sufficient room.
13207            fidl::encoding::encode_in_envelope_optional::<u64, D>(
13208                self.txn_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
13209                encoder,
13210                offset + cur_offset,
13211                depth,
13212            )?;
13213
13214            _prev_end_offset = cur_offset + envelope_size;
13215            if 2 > max_ordinal {
13216                return Ok(());
13217            }
13218
13219            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13220            // are envelope_size bytes.
13221            let cur_offset: usize = (2 - 1) * envelope_size;
13222
13223            // Zero reserved fields.
13224            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13225
13226            // Safety:
13227            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13228            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13229            //   envelope_size bytes, there is always sufficient room.
13230            fidl::encoding::encode_in_envelope_optional::<WlanScanType, D>(
13231                self.scan_type
13232                    .as_ref()
13233                    .map(<WlanScanType as fidl::encoding::ValueTypeMarker>::borrow),
13234                encoder,
13235                offset + cur_offset,
13236                depth,
13237            )?;
13238
13239            _prev_end_offset = cur_offset + envelope_size;
13240            if 3 > max_ordinal {
13241                return Ok(());
13242            }
13243
13244            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13245            // are envelope_size bytes.
13246            let cur_offset: usize = (3 - 1) * envelope_size;
13247
13248            // Zero reserved fields.
13249            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13250
13251            // Safety:
13252            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13253            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13254            //   envelope_size bytes, there is always sufficient room.
13255            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 256>, D>(
13256                self.channels.as_ref().map(
13257                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow,
13258                ),
13259                encoder,
13260                offset + cur_offset,
13261                depth,
13262            )?;
13263
13264            _prev_end_offset = cur_offset + envelope_size;
13265            if 4 > max_ordinal {
13266                return Ok(());
13267            }
13268
13269            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13270            // are envelope_size bytes.
13271            let cur_offset: usize = (4 - 1) * envelope_size;
13272
13273            // Zero reserved fields.
13274            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13275
13276            // Safety:
13277            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13278            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13279            //   envelope_size bytes, there is always sufficient room.
13280            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>, D>(
13281            self.ssids.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>> as fidl::encoding::ValueTypeMarker>::borrow),
13282            encoder, offset + cur_offset, depth
13283        )?;
13284
13285            _prev_end_offset = cur_offset + envelope_size;
13286            if 5 > max_ordinal {
13287                return Ok(());
13288            }
13289
13290            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13291            // are envelope_size bytes.
13292            let cur_offset: usize = (5 - 1) * envelope_size;
13293
13294            // Zero reserved fields.
13295            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13296
13297            // Safety:
13298            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13299            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13300            //   envelope_size bytes, there is always sufficient room.
13301            fidl::encoding::encode_in_envelope_optional::<u32, D>(
13302                self.min_channel_time
13303                    .as_ref()
13304                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
13305                encoder,
13306                offset + cur_offset,
13307                depth,
13308            )?;
13309
13310            _prev_end_offset = cur_offset + envelope_size;
13311            if 6 > max_ordinal {
13312                return Ok(());
13313            }
13314
13315            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13316            // are envelope_size bytes.
13317            let cur_offset: usize = (6 - 1) * envelope_size;
13318
13319            // Zero reserved fields.
13320            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13321
13322            // Safety:
13323            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13324            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13325            //   envelope_size bytes, there is always sufficient room.
13326            fidl::encoding::encode_in_envelope_optional::<u32, D>(
13327                self.max_channel_time
13328                    .as_ref()
13329                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
13330                encoder,
13331                offset + cur_offset,
13332                depth,
13333            )?;
13334
13335            _prev_end_offset = cur_offset + envelope_size;
13336
13337            Ok(())
13338        }
13339    }
13340
13341    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13342        for WlanFullmacImplStartScanRequest
13343    {
13344        #[inline(always)]
13345        fn new_empty() -> Self {
13346            Self::default()
13347        }
13348
13349        unsafe fn decode(
13350            &mut self,
13351            decoder: &mut fidl::encoding::Decoder<'_, D>,
13352            offset: usize,
13353            mut depth: fidl::encoding::Depth,
13354        ) -> fidl::Result<()> {
13355            decoder.debug_check_bounds::<Self>(offset);
13356            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13357                None => return Err(fidl::Error::NotNullable),
13358                Some(len) => len,
13359            };
13360            // Calling decoder.out_of_line_offset(0) is not allowed.
13361            if len == 0 {
13362                return Ok(());
13363            };
13364            depth.increment()?;
13365            let envelope_size = 8;
13366            let bytes_len = len * envelope_size;
13367            let offset = decoder.out_of_line_offset(bytes_len)?;
13368            // Decode the envelope for each type.
13369            let mut _next_ordinal_to_read = 0;
13370            let mut next_offset = offset;
13371            let end_offset = offset + bytes_len;
13372            _next_ordinal_to_read += 1;
13373            if next_offset >= end_offset {
13374                return Ok(());
13375            }
13376
13377            // Decode unknown envelopes for gaps in ordinals.
13378            while _next_ordinal_to_read < 1 {
13379                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13380                _next_ordinal_to_read += 1;
13381                next_offset += envelope_size;
13382            }
13383
13384            let next_out_of_line = decoder.next_out_of_line();
13385            let handles_before = decoder.remaining_handles();
13386            if let Some((inlined, num_bytes, num_handles)) =
13387                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13388            {
13389                let member_inline_size =
13390                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13391                if inlined != (member_inline_size <= 4) {
13392                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13393                }
13394                let inner_offset;
13395                let mut inner_depth = depth.clone();
13396                if inlined {
13397                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13398                    inner_offset = next_offset;
13399                } else {
13400                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13401                    inner_depth.increment()?;
13402                }
13403                let val_ref = self.txn_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
13404                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
13405                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13406                {
13407                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13408                }
13409                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13410                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13411                }
13412            }
13413
13414            next_offset += envelope_size;
13415            _next_ordinal_to_read += 1;
13416            if next_offset >= end_offset {
13417                return Ok(());
13418            }
13419
13420            // Decode unknown envelopes for gaps in ordinals.
13421            while _next_ordinal_to_read < 2 {
13422                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13423                _next_ordinal_to_read += 1;
13424                next_offset += envelope_size;
13425            }
13426
13427            let next_out_of_line = decoder.next_out_of_line();
13428            let handles_before = decoder.remaining_handles();
13429            if let Some((inlined, num_bytes, num_handles)) =
13430                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13431            {
13432                let member_inline_size =
13433                    <WlanScanType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13434                if inlined != (member_inline_size <= 4) {
13435                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13436                }
13437                let inner_offset;
13438                let mut inner_depth = depth.clone();
13439                if inlined {
13440                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13441                    inner_offset = next_offset;
13442                } else {
13443                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13444                    inner_depth.increment()?;
13445                }
13446                let val_ref =
13447                    self.scan_type.get_or_insert_with(|| fidl::new_empty!(WlanScanType, D));
13448                fidl::decode!(WlanScanType, D, val_ref, decoder, inner_offset, inner_depth)?;
13449                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13450                {
13451                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13452                }
13453                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13454                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13455                }
13456            }
13457
13458            next_offset += envelope_size;
13459            _next_ordinal_to_read += 1;
13460            if next_offset >= end_offset {
13461                return Ok(());
13462            }
13463
13464            // Decode unknown envelopes for gaps in ordinals.
13465            while _next_ordinal_to_read < 3 {
13466                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13467                _next_ordinal_to_read += 1;
13468                next_offset += envelope_size;
13469            }
13470
13471            let next_out_of_line = decoder.next_out_of_line();
13472            let handles_before = decoder.remaining_handles();
13473            if let Some((inlined, num_bytes, num_handles)) =
13474                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13475            {
13476                let member_inline_size =
13477                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::TypeMarker>::inline_size(
13478                        decoder.context,
13479                    );
13480                if inlined != (member_inline_size <= 4) {
13481                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13482                }
13483                let inner_offset;
13484                let mut inner_depth = depth.clone();
13485                if inlined {
13486                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13487                    inner_offset = next_offset;
13488                } else {
13489                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13490                    inner_depth.increment()?;
13491                }
13492                let val_ref = self
13493                    .channels
13494                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D));
13495                fidl::decode!(fidl::encoding::Vector<u8, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
13496                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13497                {
13498                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13499                }
13500                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13501                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13502                }
13503            }
13504
13505            next_offset += envelope_size;
13506            _next_ordinal_to_read += 1;
13507            if next_offset >= end_offset {
13508                return Ok(());
13509            }
13510
13511            // Decode unknown envelopes for gaps in ordinals.
13512            while _next_ordinal_to_read < 4 {
13513                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13514                _next_ordinal_to_read += 1;
13515                next_offset += envelope_size;
13516            }
13517
13518            let next_out_of_line = decoder.next_out_of_line();
13519            let handles_before = decoder.remaining_handles();
13520            if let Some((inlined, num_bytes, num_handles)) =
13521                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13522            {
13523                let member_inline_size = <fidl::encoding::UnboundedVector<
13524                    fidl::encoding::Vector<u8, 32>,
13525                > as fidl::encoding::TypeMarker>::inline_size(
13526                    decoder.context
13527                );
13528                if inlined != (member_inline_size <= 4) {
13529                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13530                }
13531                let inner_offset;
13532                let mut inner_depth = depth.clone();
13533                if inlined {
13534                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13535                    inner_offset = next_offset;
13536                } else {
13537                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13538                    inner_depth.increment()?;
13539                }
13540                let val_ref = self.ssids.get_or_insert_with(|| {
13541                    fidl::new_empty!(
13542                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>,
13543                        D
13544                    )
13545                });
13546                fidl::decode!(
13547                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>,
13548                    D,
13549                    val_ref,
13550                    decoder,
13551                    inner_offset,
13552                    inner_depth
13553                )?;
13554                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13555                {
13556                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13557                }
13558                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13559                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13560                }
13561            }
13562
13563            next_offset += envelope_size;
13564            _next_ordinal_to_read += 1;
13565            if next_offset >= end_offset {
13566                return Ok(());
13567            }
13568
13569            // Decode unknown envelopes for gaps in ordinals.
13570            while _next_ordinal_to_read < 5 {
13571                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13572                _next_ordinal_to_read += 1;
13573                next_offset += envelope_size;
13574            }
13575
13576            let next_out_of_line = decoder.next_out_of_line();
13577            let handles_before = decoder.remaining_handles();
13578            if let Some((inlined, num_bytes, num_handles)) =
13579                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13580            {
13581                let member_inline_size =
13582                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13583                if inlined != (member_inline_size <= 4) {
13584                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13585                }
13586                let inner_offset;
13587                let mut inner_depth = depth.clone();
13588                if inlined {
13589                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13590                    inner_offset = next_offset;
13591                } else {
13592                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13593                    inner_depth.increment()?;
13594                }
13595                let val_ref = self.min_channel_time.get_or_insert_with(|| fidl::new_empty!(u32, D));
13596                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
13597                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13598                {
13599                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13600                }
13601                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13602                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13603                }
13604            }
13605
13606            next_offset += envelope_size;
13607            _next_ordinal_to_read += 1;
13608            if next_offset >= end_offset {
13609                return Ok(());
13610            }
13611
13612            // Decode unknown envelopes for gaps in ordinals.
13613            while _next_ordinal_to_read < 6 {
13614                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13615                _next_ordinal_to_read += 1;
13616                next_offset += envelope_size;
13617            }
13618
13619            let next_out_of_line = decoder.next_out_of_line();
13620            let handles_before = decoder.remaining_handles();
13621            if let Some((inlined, num_bytes, num_handles)) =
13622                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13623            {
13624                let member_inline_size =
13625                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13626                if inlined != (member_inline_size <= 4) {
13627                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13628                }
13629                let inner_offset;
13630                let mut inner_depth = depth.clone();
13631                if inlined {
13632                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13633                    inner_offset = next_offset;
13634                } else {
13635                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13636                    inner_depth.increment()?;
13637                }
13638                let val_ref = self.max_channel_time.get_or_insert_with(|| fidl::new_empty!(u32, D));
13639                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
13640                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13641                {
13642                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13643                }
13644                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13645                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13646                }
13647            }
13648
13649            next_offset += envelope_size;
13650
13651            // Decode the remaining unknown envelopes.
13652            while next_offset < end_offset {
13653                _next_ordinal_to_read += 1;
13654                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13655                next_offset += envelope_size;
13656            }
13657
13658            Ok(())
13659        }
13660    }
13661
13662    impl WlanFullmacImplStopBssRequest {
13663        #[inline(always)]
13664        fn max_ordinal_present(&self) -> u64 {
13665            if let Some(_) = self.ssid {
13666                return 1;
13667            }
13668            0
13669        }
13670    }
13671
13672    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplStopBssRequest {
13673        type Borrowed<'a> = &'a Self;
13674        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13675            value
13676        }
13677    }
13678
13679    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplStopBssRequest {
13680        type Owned = Self;
13681
13682        #[inline(always)]
13683        fn inline_align(_context: fidl::encoding::Context) -> usize {
13684            8
13685        }
13686
13687        #[inline(always)]
13688        fn inline_size(_context: fidl::encoding::Context) -> usize {
13689            16
13690        }
13691    }
13692
13693    unsafe impl<D: fidl::encoding::ResourceDialect>
13694        fidl::encoding::Encode<WlanFullmacImplStopBssRequest, D>
13695        for &WlanFullmacImplStopBssRequest
13696    {
13697        unsafe fn encode(
13698            self,
13699            encoder: &mut fidl::encoding::Encoder<'_, D>,
13700            offset: usize,
13701            mut depth: fidl::encoding::Depth,
13702        ) -> fidl::Result<()> {
13703            encoder.debug_check_bounds::<WlanFullmacImplStopBssRequest>(offset);
13704            // Vector header
13705            let max_ordinal: u64 = self.max_ordinal_present();
13706            encoder.write_num(max_ordinal, offset);
13707            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13708            // Calling encoder.out_of_line_offset(0) is not allowed.
13709            if max_ordinal == 0 {
13710                return Ok(());
13711            }
13712            depth.increment()?;
13713            let envelope_size = 8;
13714            let bytes_len = max_ordinal as usize * envelope_size;
13715            #[allow(unused_variables)]
13716            let offset = encoder.out_of_line_offset(bytes_len);
13717            let mut _prev_end_offset: usize = 0;
13718            if 1 > max_ordinal {
13719                return Ok(());
13720            }
13721
13722            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13723            // are envelope_size bytes.
13724            let cur_offset: usize = (1 - 1) * envelope_size;
13725
13726            // Zero reserved fields.
13727            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13728
13729            // Safety:
13730            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13731            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13732            //   envelope_size bytes, there is always sufficient room.
13733            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
13734                self.ssid.as_ref().map(
13735                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
13736                ),
13737                encoder,
13738                offset + cur_offset,
13739                depth,
13740            )?;
13741
13742            _prev_end_offset = cur_offset + envelope_size;
13743
13744            Ok(())
13745        }
13746    }
13747
13748    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13749        for WlanFullmacImplStopBssRequest
13750    {
13751        #[inline(always)]
13752        fn new_empty() -> Self {
13753            Self::default()
13754        }
13755
13756        unsafe fn decode(
13757            &mut self,
13758            decoder: &mut fidl::encoding::Decoder<'_, D>,
13759            offset: usize,
13760            mut depth: fidl::encoding::Depth,
13761        ) -> fidl::Result<()> {
13762            decoder.debug_check_bounds::<Self>(offset);
13763            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13764                None => return Err(fidl::Error::NotNullable),
13765                Some(len) => len,
13766            };
13767            // Calling decoder.out_of_line_offset(0) is not allowed.
13768            if len == 0 {
13769                return Ok(());
13770            };
13771            depth.increment()?;
13772            let envelope_size = 8;
13773            let bytes_len = len * envelope_size;
13774            let offset = decoder.out_of_line_offset(bytes_len)?;
13775            // Decode the envelope for each type.
13776            let mut _next_ordinal_to_read = 0;
13777            let mut next_offset = offset;
13778            let end_offset = offset + bytes_len;
13779            _next_ordinal_to_read += 1;
13780            if next_offset >= end_offset {
13781                return Ok(());
13782            }
13783
13784            // Decode unknown envelopes for gaps in ordinals.
13785            while _next_ordinal_to_read < 1 {
13786                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13787                _next_ordinal_to_read += 1;
13788                next_offset += envelope_size;
13789            }
13790
13791            let next_out_of_line = decoder.next_out_of_line();
13792            let handles_before = decoder.remaining_handles();
13793            if let Some((inlined, num_bytes, num_handles)) =
13794                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13795            {
13796                let member_inline_size =
13797                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
13798                        decoder.context,
13799                    );
13800                if inlined != (member_inline_size <= 4) {
13801                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13802                }
13803                let inner_offset;
13804                let mut inner_depth = depth.clone();
13805                if inlined {
13806                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13807                    inner_offset = next_offset;
13808                } else {
13809                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13810                    inner_depth.increment()?;
13811                }
13812                let val_ref = self
13813                    .ssid
13814                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
13815                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
13816                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13817                {
13818                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13819                }
13820                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13821                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13822                }
13823            }
13824
13825            next_offset += envelope_size;
13826
13827            // Decode the remaining unknown envelopes.
13828            while next_offset < end_offset {
13829                _next_ordinal_to_read += 1;
13830                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13831                next_offset += envelope_size;
13832            }
13833
13834            Ok(())
13835        }
13836    }
13837
13838    impl WlanFullmacImplQueryResponse {
13839        #[inline(always)]
13840        fn max_ordinal_present(&self) -> u64 {
13841            if let Some(_) = self.band_caps {
13842                return 3;
13843            }
13844            if let Some(_) = self.role {
13845                return 2;
13846            }
13847            if let Some(_) = self.sta_addr {
13848                return 1;
13849            }
13850            0
13851        }
13852    }
13853
13854    impl fidl::encoding::ValueTypeMarker for WlanFullmacImplQueryResponse {
13855        type Borrowed<'a> = &'a Self;
13856        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13857            value
13858        }
13859    }
13860
13861    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplQueryResponse {
13862        type Owned = Self;
13863
13864        #[inline(always)]
13865        fn inline_align(_context: fidl::encoding::Context) -> usize {
13866            8
13867        }
13868
13869        #[inline(always)]
13870        fn inline_size(_context: fidl::encoding::Context) -> usize {
13871            16
13872        }
13873    }
13874
13875    unsafe impl<D: fidl::encoding::ResourceDialect>
13876        fidl::encoding::Encode<WlanFullmacImplQueryResponse, D> for &WlanFullmacImplQueryResponse
13877    {
13878        unsafe fn encode(
13879            self,
13880            encoder: &mut fidl::encoding::Encoder<'_, D>,
13881            offset: usize,
13882            mut depth: fidl::encoding::Depth,
13883        ) -> fidl::Result<()> {
13884            encoder.debug_check_bounds::<WlanFullmacImplQueryResponse>(offset);
13885            // Vector header
13886            let max_ordinal: u64 = self.max_ordinal_present();
13887            encoder.write_num(max_ordinal, offset);
13888            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13889            // Calling encoder.out_of_line_offset(0) is not allowed.
13890            if max_ordinal == 0 {
13891                return Ok(());
13892            }
13893            depth.increment()?;
13894            let envelope_size = 8;
13895            let bytes_len = max_ordinal as usize * envelope_size;
13896            #[allow(unused_variables)]
13897            let offset = encoder.out_of_line_offset(bytes_len);
13898            let mut _prev_end_offset: usize = 0;
13899            if 1 > max_ordinal {
13900                return Ok(());
13901            }
13902
13903            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13904            // are envelope_size bytes.
13905            let cur_offset: usize = (1 - 1) * envelope_size;
13906
13907            // Zero reserved fields.
13908            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13909
13910            // Safety:
13911            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13912            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13913            //   envelope_size bytes, there is always sufficient room.
13914            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
13915                self.sta_addr
13916                    .as_ref()
13917                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
13918                encoder,
13919                offset + cur_offset,
13920                depth,
13921            )?;
13922
13923            _prev_end_offset = cur_offset + envelope_size;
13924            if 2 > max_ordinal {
13925                return Ok(());
13926            }
13927
13928            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13929            // are envelope_size bytes.
13930            let cur_offset: usize = (2 - 1) * envelope_size;
13931
13932            // Zero reserved fields.
13933            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13934
13935            // Safety:
13936            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13937            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13938            //   envelope_size bytes, there is always sufficient room.
13939            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::WlanMacRole, D>(
13940            self.role.as_ref().map(<fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::ValueTypeMarker>::borrow),
13941            encoder, offset + cur_offset, depth
13942        )?;
13943
13944            _prev_end_offset = cur_offset + envelope_size;
13945            if 3 > max_ordinal {
13946                return Ok(());
13947            }
13948
13949            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13950            // are envelope_size bytes.
13951            let cur_offset: usize = (3 - 1) * envelope_size;
13952
13953            // Zero reserved fields.
13954            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13955
13956            // Safety:
13957            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13958            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13959            //   envelope_size bytes, there is always sufficient room.
13960            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<BandCapability, 16>, D>(
13961            self.band_caps.as_ref().map(<fidl::encoding::Vector<BandCapability, 16> as fidl::encoding::ValueTypeMarker>::borrow),
13962            encoder, offset + cur_offset, depth
13963        )?;
13964
13965            _prev_end_offset = cur_offset + envelope_size;
13966
13967            Ok(())
13968        }
13969    }
13970
13971    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13972        for WlanFullmacImplQueryResponse
13973    {
13974        #[inline(always)]
13975        fn new_empty() -> Self {
13976            Self::default()
13977        }
13978
13979        unsafe fn decode(
13980            &mut self,
13981            decoder: &mut fidl::encoding::Decoder<'_, D>,
13982            offset: usize,
13983            mut depth: fidl::encoding::Depth,
13984        ) -> fidl::Result<()> {
13985            decoder.debug_check_bounds::<Self>(offset);
13986            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13987                None => return Err(fidl::Error::NotNullable),
13988                Some(len) => len,
13989            };
13990            // Calling decoder.out_of_line_offset(0) is not allowed.
13991            if len == 0 {
13992                return Ok(());
13993            };
13994            depth.increment()?;
13995            let envelope_size = 8;
13996            let bytes_len = len * envelope_size;
13997            let offset = decoder.out_of_line_offset(bytes_len)?;
13998            // Decode the envelope for each type.
13999            let mut _next_ordinal_to_read = 0;
14000            let mut next_offset = offset;
14001            let end_offset = offset + bytes_len;
14002            _next_ordinal_to_read += 1;
14003            if next_offset >= end_offset {
14004                return Ok(());
14005            }
14006
14007            // Decode unknown envelopes for gaps in ordinals.
14008            while _next_ordinal_to_read < 1 {
14009                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14010                _next_ordinal_to_read += 1;
14011                next_offset += envelope_size;
14012            }
14013
14014            let next_out_of_line = decoder.next_out_of_line();
14015            let handles_before = decoder.remaining_handles();
14016            if let Some((inlined, num_bytes, num_handles)) =
14017                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14018            {
14019                let member_inline_size =
14020                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
14021                        decoder.context,
14022                    );
14023                if inlined != (member_inline_size <= 4) {
14024                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14025                }
14026                let inner_offset;
14027                let mut inner_depth = depth.clone();
14028                if inlined {
14029                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14030                    inner_offset = next_offset;
14031                } else {
14032                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14033                    inner_depth.increment()?;
14034                }
14035                let val_ref = self
14036                    .sta_addr
14037                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
14038                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 2 {
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_fuchsia_wlan_common__common::WlanMacRole 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.role.get_or_insert_with(|| {
14080                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanMacRole, D)
14081                });
14082                fidl::decode!(
14083                    fidl_fuchsia_wlan_common__common::WlanMacRole,
14084                    D,
14085                    val_ref,
14086                    decoder,
14087                    inner_offset,
14088                    inner_depth
14089                )?;
14090                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14091                {
14092                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14093                }
14094                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14095                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14096                }
14097            }
14098
14099            next_offset += envelope_size;
14100            _next_ordinal_to_read += 1;
14101            if next_offset >= end_offset {
14102                return Ok(());
14103            }
14104
14105            // Decode unknown envelopes for gaps in ordinals.
14106            while _next_ordinal_to_read < 3 {
14107                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14108                _next_ordinal_to_read += 1;
14109                next_offset += envelope_size;
14110            }
14111
14112            let next_out_of_line = decoder.next_out_of_line();
14113            let handles_before = decoder.remaining_handles();
14114            if let Some((inlined, num_bytes, num_handles)) =
14115                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14116            {
14117                let member_inline_size = <fidl::encoding::Vector<BandCapability, 16> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14118                if inlined != (member_inline_size <= 4) {
14119                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14120                }
14121                let inner_offset;
14122                let mut inner_depth = depth.clone();
14123                if inlined {
14124                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14125                    inner_offset = next_offset;
14126                } else {
14127                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14128                    inner_depth.increment()?;
14129                }
14130                let val_ref = self.band_caps.get_or_insert_with(
14131                    || fidl::new_empty!(fidl::encoding::Vector<BandCapability, 16>, D),
14132                );
14133                fidl::decode!(fidl::encoding::Vector<BandCapability, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
14134                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14135                {
14136                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14137                }
14138                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14139                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14140                }
14141            }
14142
14143            next_offset += envelope_size;
14144
14145            // Decode the remaining unknown envelopes.
14146            while next_offset < end_offset {
14147                _next_ordinal_to_read += 1;
14148                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14149                next_offset += envelope_size;
14150            }
14151
14152            Ok(())
14153        }
14154    }
14155}