fidl_fuchsia_wlan_mlme__common/
fidl_fuchsia_wlan_mlme__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// WFA WMM v1.2, 2.2.1
12pub type QosInfo = u8;
13
14pub const MAX_SSIDS_PER_SCAN_REQUEST: u32 = 32;
15
16/// WFA WMM v1.2, 2.2.2 Table 5
17/// Length of the WMM Parameter Element body. This does not include IE and vendor IE headers,
18/// and only includes the QoS Info, reserved, and AC parameters fields.
19pub const WMM_PARAM_LEN: u8 = 18;
20
21pub const COUNTRY_ENVIRON_ALL: u8 = 32;
22
23pub const COUNTRY_ENVIRON_INDOOR: u8 = 73;
24
25pub const COUNTRY_ENVIRON_NON_COUNTRY: u8 = 88;
26
27pub const COUNTRY_ENVIRON_OUTDOOR: u8 = 79;
28
29bitflags! {
30    /// Bits used to request management frame subtypes to be captured. Also used in
31    /// StartCaptureFramesResponse to indicate what management frames are supported.
32    ///
33    /// These values are set at `1 << MgmtFrameSubtypeValue`
34    /// See IEEE Std 802.11-2016, 9.2.4.1.3, for value of each management frame subtype
35    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
36    pub struct MgmtFrameCaptureFlags: u32 {
37        const ASSOC_REQ = 1;
38        const ASSOC_RESP = 2;
39        const REASSOC_REQ = 4;
40        const REASSOC_RESP = 8;
41        const PROBE_REQ = 16;
42        const PROBE_RESP = 32;
43        const TIMING_AD = 64;
44        const BEACON = 256;
45        const ATIM = 512;
46        const DISASSOC = 1024;
47        const AUTH = 2048;
48        const DEAUTH = 4096;
49        const ACTION = 8192;
50        const ACTION_NO_ACK = 16384;
51    }
52}
53
54impl MgmtFrameCaptureFlags {}
55
56#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
57#[repr(u32)]
58pub enum AssociateResultCode {
59    Success = 0,
60    RefusedReasonUnspecified = 1,
61    RefusedNotAuthenticated = 2,
62    RefusedCapabilitiesMismatch = 3,
63    RefusedExternalReason = 4,
64    RefusedApOutOfMemory = 5,
65    RefusedBasicRatesMismatch = 6,
66    RejectedEmergencyServicesNotSupported = 7,
67    RefusedTemporarily = 8,
68}
69
70impl AssociateResultCode {
71    #[inline]
72    pub fn from_primitive(prim: u32) -> Option<Self> {
73        match prim {
74            0 => Some(Self::Success),
75            1 => Some(Self::RefusedReasonUnspecified),
76            2 => Some(Self::RefusedNotAuthenticated),
77            3 => Some(Self::RefusedCapabilitiesMismatch),
78            4 => Some(Self::RefusedExternalReason),
79            5 => Some(Self::RefusedApOutOfMemory),
80            6 => Some(Self::RefusedBasicRatesMismatch),
81            7 => Some(Self::RejectedEmergencyServicesNotSupported),
82            8 => Some(Self::RefusedTemporarily),
83            _ => None,
84        }
85    }
86
87    #[inline]
88    pub const fn into_primitive(self) -> u32 {
89        self as u32
90    }
91}
92
93#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
94#[repr(u32)]
95pub enum AuthenticateResultCode {
96    Success = 0,
97    Refused = 1,
98    AntiCloggingTokenRequired = 2,
99    FiniteCyclicGroupNotSupported = 3,
100    AuthenticationRejected = 4,
101    AuthFailureTimeout = 5,
102}
103
104impl AuthenticateResultCode {
105    #[inline]
106    pub fn from_primitive(prim: u32) -> Option<Self> {
107        match prim {
108            0 => Some(Self::Success),
109            1 => Some(Self::Refused),
110            2 => Some(Self::AntiCloggingTokenRequired),
111            3 => Some(Self::FiniteCyclicGroupNotSupported),
112            4 => Some(Self::AuthenticationRejected),
113            5 => Some(Self::AuthFailureTimeout),
114            _ => None,
115        }
116    }
117
118    #[inline]
119    pub const fn into_primitive(self) -> u32 {
120        self as u32
121    }
122}
123
124#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
125#[repr(u32)]
126pub enum AuthenticationTypes {
127    OpenSystem = 1,
128    SharedKey = 2,
129    FastBssTransition = 3,
130    Sae = 4,
131}
132
133impl AuthenticationTypes {
134    #[inline]
135    pub fn from_primitive(prim: u32) -> Option<Self> {
136        match prim {
137            1 => Some(Self::OpenSystem),
138            2 => Some(Self::SharedKey),
139            3 => Some(Self::FastBssTransition),
140            4 => Some(Self::Sae),
141            _ => None,
142        }
143    }
144
145    #[inline]
146    pub const fn into_primitive(self) -> u32 {
147        self as u32
148    }
149}
150
151#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
152#[repr(u32)]
153pub enum ControlledPortState {
154    Closed = 0,
155    Open = 1,
156}
157
158impl ControlledPortState {
159    #[inline]
160    pub fn from_primitive(prim: u32) -> Option<Self> {
161        match prim {
162            0 => Some(Self::Closed),
163            1 => Some(Self::Open),
164            _ => None,
165        }
166    }
167
168    #[inline]
169    pub const fn into_primitive(self) -> u32 {
170        self as u32
171    }
172}
173
174#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
175#[repr(u32)]
176pub enum EapolResultCode {
177    Success = 0,
178    TransmissionFailure = 1,
179}
180
181impl EapolResultCode {
182    #[inline]
183    pub fn from_primitive(prim: u32) -> Option<Self> {
184        match prim {
185            0 => Some(Self::Success),
186            1 => Some(Self::TransmissionFailure),
187            _ => None,
188        }
189    }
190
191    #[inline]
192    pub const fn into_primitive(self) -> u32 {
193        self as u32
194    }
195}
196
197#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
198#[repr(u32)]
199pub enum KeyType {
200    Group = 1,
201    Pairwise = 2,
202    PeerKey = 3,
203    Igtk = 4,
204}
205
206impl KeyType {
207    #[inline]
208    pub fn from_primitive(prim: u32) -> Option<Self> {
209        match prim {
210            1 => Some(Self::Group),
211            2 => Some(Self::Pairwise),
212            3 => Some(Self::PeerKey),
213            4 => Some(Self::Igtk),
214            _ => None,
215        }
216    }
217
218    #[inline]
219    pub const fn into_primitive(self) -> u32 {
220        self as u32
221    }
222}
223
224#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
225#[repr(u32)]
226pub enum ScanResultCode {
227    Success = 0,
228    NotSupported = 1,
229    InvalidArgs = 2,
230    InternalError = 3,
231    ShouldWait = 4,
232    CanceledByDriverOrFirmware = 5,
233}
234
235impl ScanResultCode {
236    #[inline]
237    pub fn from_primitive(prim: u32) -> Option<Self> {
238        match prim {
239            0 => Some(Self::Success),
240            1 => Some(Self::NotSupported),
241            2 => Some(Self::InvalidArgs),
242            3 => Some(Self::InternalError),
243            4 => Some(Self::ShouldWait),
244            5 => Some(Self::CanceledByDriverOrFirmware),
245            _ => None,
246        }
247    }
248
249    #[inline]
250    pub const fn into_primitive(self) -> u32 {
251        self as u32
252    }
253}
254
255#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
256#[repr(u32)]
257pub enum ScanTypes {
258    Active = 1,
259    Passive = 2,
260}
261
262impl ScanTypes {
263    #[inline]
264    pub fn from_primitive(prim: u32) -> Option<Self> {
265        match prim {
266            1 => Some(Self::Active),
267            2 => Some(Self::Passive),
268            _ => None,
269        }
270    }
271
272    #[inline]
273    pub const fn into_primitive(self) -> u32 {
274        self as u32
275    }
276}
277
278#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
279#[repr(u32)]
280pub enum StartResultCode {
281    Success = 0,
282    BssAlreadyStartedOrJoined = 1,
283    ResetRequiredBeforeStart = 2,
284    NotSupported = 3,
285    InternalError = 4,
286}
287
288impl StartResultCode {
289    #[inline]
290    pub fn from_primitive(prim: u32) -> Option<Self> {
291        match prim {
292            0 => Some(Self::Success),
293            1 => Some(Self::BssAlreadyStartedOrJoined),
294            2 => Some(Self::ResetRequiredBeforeStart),
295            3 => Some(Self::NotSupported),
296            4 => Some(Self::InternalError),
297            _ => None,
298        }
299    }
300
301    #[inline]
302    pub const fn into_primitive(self) -> u32 {
303        self as u32
304    }
305}
306
307#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
308#[repr(u32)]
309pub enum StopResultCode {
310    Success = 0,
311    BssAlreadyStopped = 1,
312    InternalError = 2,
313}
314
315impl StopResultCode {
316    #[inline]
317    pub fn from_primitive(prim: u32) -> Option<Self> {
318        match prim {
319            0 => Some(Self::Success),
320            1 => Some(Self::BssAlreadyStopped),
321            2 => Some(Self::InternalError),
322            _ => None,
323        }
324    }
325
326    #[inline]
327    pub const fn into_primitive(self) -> u32 {
328        self as u32
329    }
330}
331
332#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
333pub struct AssociateIndication {
334    pub peer_sta_address: [u8; 6],
335    pub capability_info: u16,
336    pub listen_interval: u16,
337    pub ssid: Option<Vec<u8>>,
338    pub rates: Vec<u8>,
339    pub rsne: Option<Vec<u8>>,
340}
341
342impl fidl::Persistable for AssociateIndication {}
343
344#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
345pub struct AssociateResponse {
346    pub peer_sta_address: [u8; 6],
347    pub result_code: AssociateResultCode,
348    pub association_id: u16,
349    pub capability_info: u16,
350    pub rates: Vec<u8>,
351}
352
353impl fidl::Persistable for AssociateResponse {}
354
355#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
356pub struct AuthenticateIndication {
357    pub peer_sta_address: [u8; 6],
358    pub auth_type: AuthenticationTypes,
359}
360
361impl fidl::Persistable for AuthenticateIndication {}
362
363#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
364pub struct AuthenticateResponse {
365    pub peer_sta_address: [u8; 6],
366    pub result_code: AuthenticateResultCode,
367}
368
369impl fidl::Persistable for AuthenticateResponse {}
370
371#[derive(Clone, Debug, PartialEq)]
372pub struct BandCapability {
373    /// The values of this struct apply to the band indicated in this field.
374    pub band: fidl_fuchsia_wlan_ieee80211__common::WlanBand,
375    /// Basic rates supported in units of 500 kbit/s (as defined in
376    /// IEEE Std 802.11-2016, 9.4.2.3), e.g., 0x02 represents 1 Mbps.
377    /// The value returned by this type indicates all the non-HT rates
378    /// the device supports transmitting and receiving.
379    pub basic_rates: Vec<u8>,
380    pub ht_cap: Option<Box<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>>,
381    pub vht_cap: Option<Box<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>>,
382    /// A list of operating channels considered valid by hardware, in the context of
383    /// regulatory information known to the device driver, at the time of its
384    /// construction during iface creation. In this context, an operating channel
385    /// means a channel which APs may transmit Beacon frames on in the current
386    /// regulatory domain.
387    ///
388    /// This list should be used to determine efficacy of subsequent requests to
389    /// scan a subset of channels using the iface, or to determine which operating
390    /// channel to use when starting an AP.
391    pub operating_channels: Vec<u8>,
392}
393
394impl fidl::Persistable for BandCapability {}
395
396#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
397pub struct CapturedFrameResult {
398    pub frame: Vec<u8>,
399}
400
401impl fidl::Persistable for CapturedFrameResult {}
402
403#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
404pub struct ConnectConfirm {
405    pub peer_sta_address: [u8; 6],
406    pub result_code: fidl_fuchsia_wlan_ieee80211__common::StatusCode,
407    pub association_id: u16,
408    pub association_ies: Vec<u8>,
409}
410
411impl fidl::Persistable for ConnectConfirm {}
412
413#[derive(Clone, Debug, PartialEq)]
414pub struct ConnectRequest {
415    pub selected_bss: fidl_fuchsia_wlan_ieee80211__common::BssDescription,
416    pub connect_failure_timeout: u32,
417    /// Additional parameters specific to the authentication exchange.
418    pub auth_type: AuthenticationTypes,
419    pub sae_password: Vec<u8>,
420    /// WEP key used in the authentication exchange. Only included for WEP security type.
421    pub wep_key: Option<Box<SetKeyDescriptor>>,
422    /// Additional parameters specific to the association exchange.
423    pub security_ie: Vec<u8>,
424    /// OWE public key used for Diffie Hellman exchange during association.
425    /// Only included for OWE security type.
426    pub owe_public_key: Option<Box<fidl_fuchsia_wlan_internal__common::OwePublicKey>>,
427}
428
429impl fidl::Persistable for ConnectRequest {}
430
431#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
432#[repr(C)]
433pub struct Country {
434    pub alpha2: [u8; 2],
435    pub suffix: u8,
436}
437
438impl fidl::Persistable for Country {}
439
440#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
441#[repr(C)]
442pub struct DeauthenticateConfirm {
443    pub peer_sta_address: [u8; 6],
444}
445
446impl fidl::Persistable for DeauthenticateConfirm {}
447
448#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
449pub struct DeauthenticateIndication {
450    pub peer_sta_address: [u8; 6],
451    pub reason_code: fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
452    /// locally_initiated is true if deauth is initiated from the device,
453    /// and is false if it's initiated remotely (e.g. due to deauth frame)
454    pub locally_initiated: bool,
455}
456
457impl fidl::Persistable for DeauthenticateIndication {}
458
459#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
460pub struct DeauthenticateRequest {
461    pub peer_sta_address: [u8; 6],
462    pub reason_code: fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
463}
464
465impl fidl::Persistable for DeauthenticateRequest {}
466
467#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
468pub struct DeleteKeyDescriptor {
469    pub key_id: u16,
470    pub key_type: KeyType,
471    pub address: [u8; 6],
472}
473
474impl fidl::Persistable for DeleteKeyDescriptor {}
475
476#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
477pub struct DeleteKeysRequest {
478    pub keylist: Vec<DeleteKeyDescriptor>,
479}
480
481impl fidl::Persistable for DeleteKeysRequest {}
482
483#[derive(Clone, Debug, PartialEq)]
484pub struct DeviceInfo {
485    pub sta_addr: [u8; 6],
486    pub factory_addr: [u8; 6],
487    pub role: fidl_fuchsia_wlan_common__common::WlanMacRole,
488    pub bands: Vec<BandCapability>,
489    pub softmac_hardware_capability: u32,
490    pub qos_capable: bool,
491}
492
493impl fidl::Persistable for DeviceInfo {}
494
495#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
496#[repr(C)]
497pub struct DisassociateConfirm {
498    pub status: i32,
499}
500
501impl fidl::Persistable for DisassociateConfirm {}
502
503#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
504pub struct DisassociateIndication {
505    pub peer_sta_address: [u8; 6],
506    pub reason_code: fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
507    /// locally_initiated is true if diassoc is initiated from the device,
508    /// and is false if it's initiated remotely (e.g. due to disassoc frame)
509    pub locally_initiated: bool,
510}
511
512impl fidl::Persistable for DisassociateIndication {}
513
514#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
515pub struct DisassociateRequest {
516    pub peer_sta_address: [u8; 6],
517    pub reason_code: fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
518}
519
520impl fidl::Persistable for DisassociateRequest {}
521
522#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
523pub struct EapolConfirm {
524    pub result_code: EapolResultCode,
525    /// This value corresponds to the dst_addr in the EapolRequest we're confirming.
526    /// IEEE 802.11-2016 does not include this field, but we need it to disambiguate
527    /// if multiple EAPoL handshakes are ongoing.
528    pub dst_addr: [u8; 6],
529}
530
531impl fidl::Persistable for EapolConfirm {}
532
533#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
534pub struct EapolIndication {
535    pub src_addr: [u8; 6],
536    pub dst_addr: [u8; 6],
537    pub data: Vec<u8>,
538}
539
540impl fidl::Persistable for EapolIndication {}
541
542#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
543pub struct EapolRequest {
544    pub src_addr: [u8; 6],
545    pub dst_addr: [u8; 6],
546    pub data: Vec<u8>,
547}
548
549impl fidl::Persistable for EapolRequest {}
550
551#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
552pub struct MlmeGetApfPacketFilterEnabledResponse {
553    pub enabled: bool,
554}
555
556impl fidl::Persistable for MlmeGetApfPacketFilterEnabledResponse {}
557
558#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
559pub struct MlmeGetScheduledScanEnabledResponse {
560    pub active_txn_ids: Vec<u64>,
561}
562
563impl fidl::Persistable for MlmeGetScheduledScanEnabledResponse {}
564
565#[derive(Clone, Debug, PartialEq)]
566pub struct MlmeGetSignalReportResponse {
567    pub resp: fidl_fuchsia_wlan_stats__common::SignalReport,
568}
569
570impl fidl::Persistable for MlmeGetSignalReportResponse {}
571
572#[derive(Clone, Debug, PartialEq)]
573pub struct MlmeQueryTelemetrySupportResponse {
574    pub resp: fidl_fuchsia_wlan_stats__common::TelemetrySupport,
575}
576
577impl fidl::Persistable for MlmeQueryTelemetrySupportResponse {}
578
579#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
580pub struct MlmeReadApfPacketFilterDataResponse {
581    pub memory: Vec<u8>,
582}
583
584impl fidl::Persistable for MlmeReadApfPacketFilterDataResponse {}
585
586#[derive(Clone, Debug, PartialEq)]
587pub struct MinstrelListResponse {
588    pub peers: fidl_fuchsia_wlan_minstrel__common::Peers,
589}
590
591impl fidl::Persistable for MinstrelListResponse {}
592
593#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
594#[repr(C)]
595pub struct MinstrelStatsRequest {
596    pub peer_addr: [u8; 6],
597}
598
599impl fidl::Persistable for MinstrelStatsRequest {}
600
601#[derive(Clone, Debug, PartialEq)]
602pub struct MinstrelStatsResponse {
603    pub peer: Option<Box<fidl_fuchsia_wlan_minstrel__common::Peer>>,
604}
605
606impl fidl::Persistable for MinstrelStatsResponse {}
607
608#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
609pub struct MlmeAssociateIndRequest {
610    pub ind: AssociateIndication,
611}
612
613impl fidl::Persistable for MlmeAssociateIndRequest {}
614
615#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
616pub struct MlmeAssociateRespRequest {
617    pub resp: AssociateResponse,
618}
619
620impl fidl::Persistable for MlmeAssociateRespRequest {}
621
622#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
623pub struct MlmeAuthenticateIndRequest {
624    pub ind: AuthenticateIndication,
625}
626
627impl fidl::Persistable for MlmeAuthenticateIndRequest {}
628
629#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
630pub struct MlmeAuthenticateRespRequest {
631    pub resp: AuthenticateResponse,
632}
633
634impl fidl::Persistable for MlmeAuthenticateRespRequest {}
635
636#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
637pub struct MlmeConnectConfRequest {
638    pub resp: ConnectConfirm,
639}
640
641impl fidl::Persistable for MlmeConnectConfRequest {}
642
643#[derive(Clone, Debug, PartialEq)]
644pub struct MlmeConnectReqRequest {
645    pub req: ConnectRequest,
646}
647
648impl fidl::Persistable for MlmeConnectReqRequest {}
649
650#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
651#[repr(C)]
652pub struct MlmeDeauthenticateConfRequest {
653    pub resp: DeauthenticateConfirm,
654}
655
656impl fidl::Persistable for MlmeDeauthenticateConfRequest {}
657
658#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
659pub struct MlmeDeauthenticateIndRequest {
660    pub ind: DeauthenticateIndication,
661}
662
663impl fidl::Persistable for MlmeDeauthenticateIndRequest {}
664
665#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
666pub struct MlmeDeauthenticateReqRequest {
667    pub req: DeauthenticateRequest,
668}
669
670impl fidl::Persistable for MlmeDeauthenticateReqRequest {}
671
672#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
673pub struct MlmeDeleteKeysReqRequest {
674    pub req: DeleteKeysRequest,
675}
676
677impl fidl::Persistable for MlmeDeleteKeysReqRequest {}
678
679#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
680#[repr(C)]
681pub struct MlmeDisassociateConfRequest {
682    pub resp: DisassociateConfirm,
683}
684
685impl fidl::Persistable for MlmeDisassociateConfRequest {}
686
687#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
688pub struct MlmeDisassociateIndRequest {
689    pub ind: DisassociateIndication,
690}
691
692impl fidl::Persistable for MlmeDisassociateIndRequest {}
693
694#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
695pub struct MlmeDisassociateReqRequest {
696    pub req: DisassociateRequest,
697}
698
699impl fidl::Persistable for MlmeDisassociateReqRequest {}
700
701#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
702pub struct MlmeEapolConfRequest {
703    pub resp: EapolConfirm,
704}
705
706impl fidl::Persistable for MlmeEapolConfRequest {}
707
708#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
709pub struct MlmeEapolIndRequest {
710    pub ind: EapolIndication,
711}
712
713impl fidl::Persistable for MlmeEapolIndRequest {}
714
715#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
716pub struct MlmeEapolReqRequest {
717    pub req: EapolRequest,
718}
719
720impl fidl::Persistable for MlmeEapolReqRequest {}
721
722#[derive(Clone, Debug, PartialEq)]
723pub struct MlmeFinalizeAssociationReqRequest {
724    pub negotiated_capabilities: NegotiatedCapabilities,
725}
726
727impl fidl::Persistable for MlmeFinalizeAssociationReqRequest {}
728
729#[derive(Clone, Debug, PartialEq)]
730pub struct MlmeGetIfaceHistogramStatsResponse {
731    pub resp: GetIfaceHistogramStatsResponse,
732}
733
734impl fidl::Persistable for MlmeGetIfaceHistogramStatsResponse {}
735
736#[derive(Clone, Debug, PartialEq)]
737pub struct MlmeGetIfaceStatsResponse {
738    pub resp: GetIfaceStatsResponse,
739}
740
741impl fidl::Persistable for MlmeGetIfaceStatsResponse {}
742
743#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
744#[repr(C)]
745pub struct MlmeGetMinstrelStatsRequest {
746    pub req: MinstrelStatsRequest,
747}
748
749impl fidl::Persistable for MlmeGetMinstrelStatsRequest {}
750
751#[derive(Clone, Debug, PartialEq)]
752pub struct MlmeGetMinstrelStatsResponse {
753    pub resp: MinstrelStatsResponse,
754}
755
756impl fidl::Persistable for MlmeGetMinstrelStatsResponse {}
757
758#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
759pub struct MlmeInstallApfPacketFilterRequest {
760    pub program: Vec<u8>,
761}
762
763impl fidl::Persistable for MlmeInstallApfPacketFilterRequest {}
764
765#[derive(Clone, Debug, PartialEq)]
766pub struct MlmeListMinstrelPeersResponse {
767    pub resp: MinstrelListResponse,
768}
769
770impl fidl::Persistable for MlmeListMinstrelPeersResponse {}
771
772#[derive(Clone, Debug, PartialEq)]
773pub struct MlmeOnChannelSwitchedRequest {
774    pub info: fidl_fuchsia_wlan_internal__common::ChannelSwitchInfo,
775}
776
777impl fidl::Persistable for MlmeOnChannelSwitchedRequest {}
778
779#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
780pub struct MlmeOnPmkAvailableRequest {
781    pub info: PmkInfo,
782}
783
784impl fidl::Persistable for MlmeOnPmkAvailableRequest {}
785
786#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
787pub struct MlmeOnSaeFrameRxRequest {
788    pub frame: SaeFrame,
789}
790
791impl fidl::Persistable for MlmeOnSaeFrameRxRequest {}
792
793#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
794#[repr(C)]
795pub struct MlmeOnSaeHandshakeIndRequest {
796    pub ind: SaeHandshakeIndication,
797}
798
799impl fidl::Persistable for MlmeOnSaeHandshakeIndRequest {}
800
801#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
802pub struct MlmeOnScanEndRequest {
803    pub end: ScanEnd,
804}
805
806impl fidl::Persistable for MlmeOnScanEndRequest {}
807
808#[derive(Clone, Debug, PartialEq)]
809pub struct MlmeOnScanResultRequest {
810    pub result: ScanResult,
811}
812
813impl fidl::Persistable for MlmeOnScanResultRequest {}
814
815#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
816#[repr(C)]
817pub struct MlmeOnScheduledScanMatchesAvailableRequest {
818    pub txn_id: u64,
819}
820
821impl fidl::Persistable for MlmeOnScheduledScanMatchesAvailableRequest {}
822
823#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
824#[repr(C)]
825pub struct MlmeOnScheduledScanStoppedByFirmwareRequest {
826    pub txn_id: u64,
827}
828
829impl fidl::Persistable for MlmeOnScheduledScanStoppedByFirmwareRequest {}
830
831#[derive(Clone, Debug, PartialEq)]
832pub struct MlmeOnWmmStatusRespRequest {
833    pub status: i32,
834    pub resp: fidl_fuchsia_wlan_internal__common::WmmStatusResponse,
835}
836
837impl fidl::Persistable for MlmeOnWmmStatusRespRequest {}
838
839#[derive(Clone, Debug, PartialEq)]
840pub struct MlmeQueryDeviceInfoResponse {
841    pub info: DeviceInfo,
842}
843
844impl fidl::Persistable for MlmeQueryDeviceInfoResponse {}
845
846#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
847#[repr(C)]
848pub struct MlmeReconnectReqRequest {
849    pub req: ReconnectRequest,
850}
851
852impl fidl::Persistable for MlmeReconnectReqRequest {}
853
854#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
855pub struct MlmeRelayCapturedFrameRequest {
856    pub result: CapturedFrameResult,
857}
858
859impl fidl::Persistable for MlmeRelayCapturedFrameRequest {}
860
861#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
862pub struct MlmeResetReqRequest {
863    pub req: ResetRequest,
864}
865
866impl fidl::Persistable for MlmeResetReqRequest {}
867
868#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
869pub struct MlmeRoamConfRequest {
870    pub conf: RoamConfirm,
871}
872
873impl fidl::Persistable for MlmeRoamConfRequest {}
874
875#[derive(Clone, Debug, PartialEq)]
876pub struct MlmeRoamReqRequest {
877    pub req: RoamRequest,
878}
879
880impl fidl::Persistable for MlmeRoamReqRequest {}
881
882#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
883pub struct MlmeRoamResultIndRequest {
884    pub ind: RoamResultIndication,
885}
886
887impl fidl::Persistable for MlmeRoamResultIndRequest {}
888
889#[derive(Clone, Debug, PartialEq)]
890pub struct MlmeRoamStartIndRequest {
891    pub ind: RoamStartIndication,
892}
893
894impl fidl::Persistable for MlmeRoamStartIndRequest {}
895
896#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
897pub struct MlmeSaeFrameTxRequest {
898    pub frame: SaeFrame,
899}
900
901impl fidl::Persistable for MlmeSaeFrameTxRequest {}
902
903#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
904pub struct MlmeSaeHandshakeRespRequest {
905    pub resp: SaeHandshakeResponse,
906}
907
908impl fidl::Persistable for MlmeSaeHandshakeRespRequest {}
909
910#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
911pub struct MlmeSetApfPacketFilterEnabledRequest {
912    pub enabled: bool,
913}
914
915impl fidl::Persistable for MlmeSetApfPacketFilterEnabledRequest {}
916
917#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
918pub struct MlmeSetControlledPortRequest {
919    pub req: SetControlledPortRequest,
920}
921
922impl fidl::Persistable for MlmeSetControlledPortRequest {}
923
924#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
925pub struct MlmeSetKeysConfRequest {
926    pub conf: SetKeysConfirm,
927}
928
929impl fidl::Persistable for MlmeSetKeysConfRequest {}
930
931#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
932pub struct MlmeSetKeysReqRequest {
933    pub req: SetKeysRequest,
934}
935
936impl fidl::Persistable for MlmeSetKeysReqRequest {}
937
938#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
939#[repr(C)]
940pub struct MlmeSetMacAddressRequest {
941    pub mac_addr: [u8; 6],
942}
943
944impl fidl::Persistable for MlmeSetMacAddressRequest {}
945
946#[derive(Clone, Debug, PartialEq)]
947pub struct MlmeSignalReportRequest {
948    pub ind: fidl_fuchsia_wlan_internal__common::SignalReportIndication,
949}
950
951impl fidl::Persistable for MlmeSignalReportRequest {}
952
953#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
954pub struct MlmeStartCaptureFramesRequest {
955    pub req: StartCaptureFramesRequest,
956}
957
958impl fidl::Persistable for MlmeStartCaptureFramesRequest {}
959
960#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
961pub struct MlmeStartCaptureFramesResponse {
962    pub resp: StartCaptureFramesResponse,
963}
964
965impl fidl::Persistable for MlmeStartCaptureFramesResponse {}
966
967#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
968pub struct MlmeStartConfRequest {
969    pub resp: StartConfirm,
970}
971
972impl fidl::Persistable for MlmeStartConfRequest {}
973
974#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
975pub struct MlmeStartReqRequest {
976    pub req: StartRequest,
977}
978
979impl fidl::Persistable for MlmeStartReqRequest {}
980
981#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
982pub struct MlmeStartScanRequest {
983    pub req: ScanRequest,
984}
985
986impl fidl::Persistable for MlmeStartScanRequest {}
987
988#[derive(Clone, Debug, PartialEq)]
989pub struct MlmeStartScheduledScanRequest {
990    pub txn_id: u64,
991    pub req: fidl_fuchsia_wlan_common__common::ScheduledScanRequest,
992}
993
994impl fidl::Persistable for MlmeStartScheduledScanRequest {}
995
996#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
997pub struct MlmeStopConfRequest {
998    pub resp: StopConfirm,
999}
1000
1001impl fidl::Persistable for MlmeStopConfRequest {}
1002
1003#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1004pub struct MlmeStopReqRequest {
1005    pub req: StopRequest,
1006}
1007
1008impl fidl::Persistable for MlmeStopReqRequest {}
1009
1010#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1011#[repr(C)]
1012pub struct MlmeStopScheduledScanRequest {
1013    pub txn_id: u64,
1014}
1015
1016impl fidl::Persistable for MlmeStopScheduledScanRequest {}
1017
1018/// Non-IEEE custom structure to inform a SoftMAC device about the association negotiation outcome.
1019#[derive(Clone, Debug, PartialEq)]
1020pub struct NegotiatedCapabilities {
1021    pub channel: fidl_fuchsia_wlan_ieee80211__common::WlanChannel,
1022    pub capability_info: u16,
1023    pub rates: Vec<u8>,
1024    pub wmm_param: Option<Box<WmmParameter>>,
1025    pub ht_cap: Option<Box<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>>,
1026    pub vht_cap: Option<Box<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>>,
1027}
1028
1029impl fidl::Persistable for NegotiatedCapabilities {}
1030
1031#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1032pub struct PmkInfo {
1033    pub pmk: Vec<u8>,
1034    pub pmkid: Vec<u8>,
1035}
1036
1037impl fidl::Persistable for PmkInfo {}
1038
1039#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1040#[repr(C)]
1041pub struct ReconnectRequest {
1042    pub peer_sta_address: [u8; 6],
1043}
1044
1045impl fidl::Persistable for ReconnectRequest {}
1046
1047#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1048pub struct ResetRequest {
1049    pub sta_address: [u8; 6],
1050    pub set_default_mib: bool,
1051}
1052
1053impl fidl::Persistable for ResetRequest {}
1054
1055/// Result of an SME-initiated roam attempt.
1056#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1057pub struct RoamConfirm {
1058    pub selected_bssid: [u8; 6],
1059    pub status_code: fidl_fuchsia_wlan_ieee80211__common::StatusCode,
1060    /// Whether the original BSS association has been maintained through the roam attempt.
1061    /// A successful roam always incurs disassociation from the original BSS, so if `status_code` is
1062    /// success then this field must be set to false; a roam failure typically incurs disassociation
1063    /// from the original BSS, but may not in some cases (e.g. in some Fast BSS Transition scenarios).
1064    pub original_association_maintained: bool,
1065    /// Whether the client is authenticated with the target BSS. If `status_code` is success, then
1066    /// this field must be set to true; if the roam attempt failed, this field may be true or false.
1067    /// This allows higher layers to decide how to clean up connection state after a failed roam
1068    /// attempt.
1069    pub target_bss_authenticated: bool,
1070    pub association_id: u16,
1071    pub association_ies: Vec<u8>,
1072}
1073
1074impl fidl::Persistable for RoamConfirm {}
1075
1076#[derive(Clone, Debug, PartialEq)]
1077pub struct RoamRequest {
1078    pub selected_bss: fidl_fuchsia_wlan_ieee80211__common::BssDescription,
1079}
1080
1081impl fidl::Persistable for RoamRequest {}
1082
1083/// Result of a fullmac-initiated roam attempt.
1084#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1085pub struct RoamResultIndication {
1086    pub selected_bssid: [u8; 6],
1087    pub status_code: fidl_fuchsia_wlan_ieee80211__common::StatusCode,
1088    /// Whether the original BSS association has been maintained through the roam attempt.
1089    /// A successful roam always incurs disassociation from the original BSS, so if `status_code` is
1090    /// success then this field must be set to false; a roam failure typically incurs disassociation
1091    /// from the original BSS, but may not in some cases (e.g. in some Fast BSS Transition scenarios).
1092    pub original_association_maintained: bool,
1093    /// Whether the client is authenticated with the target BSS. If `status_code` is success, then
1094    /// this field must be set to true; if the roam attempt failed, this field may be true or false.
1095    /// This allows higher layers to decide how to clean up connection state after a failed roam
1096    /// attempt.
1097    pub target_bss_authenticated: bool,
1098    pub association_id: u16,
1099    pub association_ies: Vec<u8>,
1100}
1101
1102impl fidl::Persistable for RoamResultIndication {}
1103
1104/// In-progress fullmac-initiated roam attempt details.
1105#[derive(Clone, Debug, PartialEq)]
1106pub struct RoamStartIndication {
1107    pub selected_bssid: [u8; 6],
1108    pub selected_bss: fidl_fuchsia_wlan_ieee80211__common::BssDescription,
1109    /// Whether the original BSS association has been maintained at the start of a roam attempt.
1110    /// 802.11 dictates that a STA can only be associated with a single BSS, so a roam attempt
1111    /// typically incurs disassociation at the start of the roam attempt. However, 802.11 also
1112    /// provides a mechanism (i.e. Fast BSS Transition) that allows a device to maintain
1113    /// association with the original BSS while establishing authentication with the target BSS, in
1114    /// order to avoid losing the original association if authentication with the target BSS fails.
1115    pub original_association_maintained: bool,
1116}
1117
1118impl fidl::Persistable for RoamStartIndication {}
1119
1120#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1121pub struct SaeFrame {
1122    pub peer_sta_address: [u8; 6],
1123    pub status_code: fidl_fuchsia_wlan_ieee80211__common::StatusCode,
1124    pub seq_num: u16,
1125    pub sae_fields: Vec<u8>,
1126}
1127
1128impl fidl::Persistable for SaeFrame {}
1129
1130#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1131#[repr(C)]
1132pub struct SaeHandshakeIndication {
1133    pub peer_sta_address: [u8; 6],
1134}
1135
1136impl fidl::Persistable for SaeHandshakeIndication {}
1137
1138#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1139pub struct SaeHandshakeResponse {
1140    pub peer_sta_address: [u8; 6],
1141    pub status_code: fidl_fuchsia_wlan_ieee80211__common::StatusCode,
1142}
1143
1144impl fidl::Persistable for SaeHandshakeResponse {}
1145
1146#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1147pub struct ScanEnd {
1148    pub txn_id: u64,
1149    pub code: ScanResultCode,
1150}
1151
1152impl fidl::Persistable for ScanEnd {}
1153
1154#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1155pub struct ScanRequest {
1156    pub txn_id: u64,
1157    pub scan_type: ScanTypes,
1158    /// List of channels to scan on. An empty list of channels will cause a
1159    /// scan request to immediately return a ScanEnd with code INVALID_ARGS.
1160    ///
1161    /// Invalid channel numbers will be silently ignored. The validity of a channel
1162    /// number depends on the current regulatory region, and MLME does not control
1163    /// or know this setting.
1164    pub channel_list: Vec<u8>,
1165    /// List of SSIDs to scan for. An empty list of ssids is the same as specifying
1166    /// a list containing only the wildcard SSID.
1167    ///
1168    /// There is no limit on the number of SSIDs specified. A large number of
1169    /// SSIDs may result in extended scan times because of hardware limitations on
1170    /// the number of SSIDs permitted per scan request and the technical limitation
1171    /// in IEEE 802.11-2016 that limits the number of SSIDs in a single Probe Request
1172    /// frame to ieee80211.SSID_LIST_MAX SSIDs.
1173    pub ssid_list: Vec<Vec<u8>>,
1174    pub probe_delay: u32,
1175    pub min_channel_time: u32,
1176    pub max_channel_time: u32,
1177}
1178
1179impl fidl::Persistable for ScanRequest {}
1180
1181#[derive(Clone, Debug, PartialEq)]
1182pub struct ScanResult {
1183    pub txn_id: u64,
1184    pub timestamp_nanos: i64,
1185    pub bss: fidl_fuchsia_wlan_ieee80211__common::BssDescription,
1186}
1187
1188impl fidl::Persistable for ScanResult {}
1189
1190#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1191pub struct SetControlledPortRequest {
1192    pub peer_sta_address: [u8; 6],
1193    pub state: ControlledPortState,
1194}
1195
1196impl fidl::Persistable for SetControlledPortRequest {}
1197
1198#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1199pub struct SetKeyDescriptor {
1200    pub key: Vec<u8>,
1201    pub key_id: u16,
1202    pub key_type: KeyType,
1203    pub address: [u8; 6],
1204    pub rsc: u64,
1205    pub cipher_suite_oui: [u8; 3],
1206    pub cipher_suite_type: fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType,
1207}
1208
1209impl fidl::Persistable for SetKeyDescriptor {}
1210
1211#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1212#[repr(C)]
1213pub struct SetKeyResult {
1214    pub key_id: u16,
1215    pub status: i32,
1216}
1217
1218impl fidl::Persistable for SetKeyResult {}
1219
1220#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1221pub struct SetKeysConfirm {
1222    pub results: Vec<SetKeyResult>,
1223}
1224
1225impl fidl::Persistable for SetKeysConfirm {}
1226
1227#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1228pub struct SetKeysRequest {
1229    pub keylist: Vec<SetKeyDescriptor>,
1230}
1231
1232impl fidl::Persistable for SetKeysRequest {}
1233
1234#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1235pub struct StartCaptureFramesRequest {
1236    pub mgmt_frame_flags: MgmtFrameCaptureFlags,
1237}
1238
1239impl fidl::Persistable for StartCaptureFramesRequest {}
1240
1241#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1242pub struct StartCaptureFramesResponse {
1243    pub status: i32,
1244    pub supported_mgmt_frames: MgmtFrameCaptureFlags,
1245}
1246
1247impl fidl::Persistable for StartCaptureFramesResponse {}
1248
1249#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1250pub struct StartConfirm {
1251    pub result_code: StartResultCode,
1252}
1253
1254impl fidl::Persistable for StartConfirm {}
1255
1256#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1257pub struct StartRequest {
1258    pub ssid: Vec<u8>,
1259    pub bss_type: fidl_fuchsia_wlan_ieee80211__common::BssType,
1260    pub beacon_period: u16,
1261    pub dtim_period: u8,
1262    pub channel: u8,
1263    pub capability_info: u16,
1264    pub rates: Vec<u8>,
1265    pub country: Country,
1266    pub mesh_id: Vec<u8>,
1267    pub rsne: Option<Vec<u8>>,
1268    pub phy: fidl_fuchsia_wlan_ieee80211__common::WlanPhyType,
1269    pub channel_bandwidth: fidl_fuchsia_wlan_ieee80211__common::ChannelBandwidth,
1270}
1271
1272impl fidl::Persistable for StartRequest {}
1273
1274#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1275pub struct StopConfirm {
1276    pub result_code: StopResultCode,
1277}
1278
1279impl fidl::Persistable for StopConfirm {}
1280
1281#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1282pub struct StopRequest {
1283    pub ssid: Vec<u8>,
1284}
1285
1286impl fidl::Persistable for StopRequest {}
1287
1288#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1289#[repr(C)]
1290pub struct WmmParameter {
1291    pub bytes: [u8; 18],
1292}
1293
1294impl fidl::Persistable for WmmParameter {}
1295
1296#[derive(Clone, Debug, PartialEq)]
1297pub enum GetIfaceHistogramStatsResponse {
1298    Stats(fidl_fuchsia_wlan_stats__common::IfaceHistogramStats),
1299    ErrorStatus(i32),
1300}
1301
1302impl GetIfaceHistogramStatsResponse {
1303    #[inline]
1304    pub fn ordinal(&self) -> u64 {
1305        match *self {
1306            Self::Stats(_) => 1,
1307            Self::ErrorStatus(_) => 2,
1308        }
1309    }
1310}
1311
1312impl fidl::Persistable for GetIfaceHistogramStatsResponse {}
1313
1314#[derive(Clone, Debug, PartialEq)]
1315pub enum GetIfaceStatsResponse {
1316    Stats(fidl_fuchsia_wlan_stats__common::IfaceStats),
1317    ErrorStatus(i32),
1318}
1319
1320impl GetIfaceStatsResponse {
1321    #[inline]
1322    pub fn ordinal(&self) -> u64 {
1323        match *self {
1324            Self::Stats(_) => 1,
1325            Self::ErrorStatus(_) => 2,
1326        }
1327    }
1328}
1329
1330impl fidl::Persistable for GetIfaceStatsResponse {}
1331
1332pub mod connector_ordinals {
1333    pub const CONNECT: u64 = 0x42131859717af962;
1334}
1335
1336pub mod mlme_ordinals {
1337    pub const START_SCAN: u64 = 0x342cc5ec6a957479;
1338    pub const ON_SCAN_RESULT: u64 = 0x681af7466a75074d;
1339    pub const ON_SCAN_END: u64 = 0x7f2702d253e7ca59;
1340    pub const START_SCHEDULED_SCAN: u64 = 0x7fff163af4620212;
1341    pub const STOP_SCHEDULED_SCAN: u64 = 0x5fbc466f3daa4dd9;
1342    pub const GET_SCHEDULED_SCAN_ENABLED: u64 = 0x1ecc6a7fe7f9fcff;
1343    pub const ON_SCHEDULED_SCAN_MATCHES_AVAILABLE: u64 = 0x3d915df5108ec4e1;
1344    pub const ON_SCHEDULED_SCAN_STOPPED_BY_FIRMWARE: u64 = 0x4c2cb4b145163fd0;
1345    pub const CONNECT_REQ: u64 = 0x31153dc85f8f64c;
1346    pub const CONNECT_CONF: u64 = 0x77b27623279b981e;
1347    pub const RECONNECT_REQ: u64 = 0x74e0f1bd758b6b78;
1348    pub const ROAM_REQ: u64 = 0x3ba163eadf7dba45;
1349    pub const ROAM_CONF: u64 = 0x3f608034faa054bc;
1350    pub const ROAM_START_IND: u64 = 0x270a1ec78672d094;
1351    pub const ROAM_RESULT_IND: u64 = 0x26d074364fc84865;
1352    pub const AUTHENTICATE_IND: u64 = 0x460f49ae891adbe9;
1353    pub const AUTHENTICATE_RESP: u64 = 0x26108aade2fdd2f4;
1354    pub const DEAUTHENTICATE_REQ: u64 = 0x228983b200de5d12;
1355    pub const DEAUTHENTICATE_CONF: u64 = 0x3b44debc21b88c8c;
1356    pub const DEAUTHENTICATE_IND: u64 = 0x7ee0889b326da1d7;
1357    pub const ASSOCIATE_IND: u64 = 0x6a86f20e3063dd63;
1358    pub const ASSOCIATE_RESP: u64 = 0x70244dbd652ed6d9;
1359    pub const DISASSOCIATE_REQ: u64 = 0x5765807f1387d764;
1360    pub const DISASSOCIATE_CONF: u64 = 0x61345fbce732a28d;
1361    pub const DISASSOCIATE_IND: u64 = 0x77ac0ebf387c1f35;
1362    pub const RESET_REQ: u64 = 0x780b98c58a286b9f;
1363    pub const START_REQ: u64 = 0x5d95885f8053654;
1364    pub const START_CONF: u64 = 0x15ea6cdf3b8382b3;
1365    pub const STOP_REQ: u64 = 0x27b9a2ab04a2c79f;
1366    pub const STOP_CONF: u64 = 0x50b426ef4a84a2df;
1367    pub const SET_KEYS_REQ: u64 = 0x6b30a07fd3a11a79;
1368    pub const SET_KEYS_CONF: u64 = 0x5bafb3a8d4039380;
1369    pub const DELETE_KEYS_REQ: u64 = 0x1e3524d20d190c8f;
1370    pub const EAPOL_REQ: u64 = 0xc3c096924704d4;
1371    pub const EAPOL_CONF: u64 = 0x6ffa21f4ee73ce64;
1372    pub const SIGNAL_REPORT: u64 = 0x48f32a876aa53d8f;
1373    pub const EAPOL_IND: u64 = 0x7038dca46a3142fc;
1374    pub const SET_CONTROLLED_PORT: u64 = 0x4e47065668890c8d;
1375    pub const QUERY_DEVICE_INFO: u64 = 0x6ee3e7f63f2b7bc0;
1376    pub const QUERY_TELEMETRY_SUPPORT: u64 = 0x1598879b70332c99;
1377    pub const GET_IFACE_STATS: u64 = 0xede1a8342d1b211;
1378    pub const GET_IFACE_HISTOGRAM_STATS: u64 = 0x1979c9d3449f8675;
1379    pub const GET_SIGNAL_REPORT: u64 = 0x7e47e7ebe92acec9;
1380    pub const LIST_MINSTREL_PEERS: u64 = 0x4ac5d1e66fe1ffd5;
1381    pub const GET_MINSTREL_STATS: u64 = 0x2f688b1245323f4b;
1382    pub const START_CAPTURE_FRAMES: u64 = 0x23b369ed5749ee69;
1383    pub const STOP_CAPTURE_FRAMES: u64 = 0x2f1aebbc68bf7c54;
1384    pub const RELAY_CAPTURED_FRAME: u64 = 0x6f00a6f3cff9b1f5;
1385    pub const ON_CHANNEL_SWITCHED: u64 = 0x581750594e4c0c1;
1386    pub const ON_PMK_AVAILABLE: u64 = 0x1314fc2c79643f90;
1387    pub const ON_SAE_HANDSHAKE_IND: u64 = 0x6308b10e18986d7e;
1388    pub const SAE_HANDSHAKE_RESP: u64 = 0x28477bd2f7a5ab0c;
1389    pub const SAE_FRAME_TX: u64 = 0x7700c0d536733d8c;
1390    pub const ON_SAE_FRAME_RX: u64 = 0x4ebf51c86ef5f3cd;
1391    pub const WMM_STATUS_REQ: u64 = 0xef4851f6088fede;
1392    pub const ON_WMM_STATUS_RESP: u64 = 0x53f056b432e7b5cb;
1393    pub const FINALIZE_ASSOCIATION_REQ: u64 = 0x7aea59787cfd385a;
1394    pub const SET_MAC_ADDRESS: u64 = 0x476999f9bb27afe1;
1395    pub const INSTALL_APF_PACKET_FILTER: u64 = 0x267565b4916c825b;
1396    pub const READ_APF_PACKET_FILTER_DATA: u64 = 0x6040d744f1b2cb61;
1397    pub const SET_APF_PACKET_FILTER_ENABLED: u64 = 0x6d99bdca77076aea;
1398    pub const GET_APF_PACKET_FILTER_ENABLED: u64 = 0x1df408bc154be1e4;
1399}
1400
1401mod internal {
1402    use super::*;
1403    unsafe impl fidl::encoding::TypeMarker for MgmtFrameCaptureFlags {
1404        type Owned = Self;
1405
1406        #[inline(always)]
1407        fn inline_align(_context: fidl::encoding::Context) -> usize {
1408            4
1409        }
1410
1411        #[inline(always)]
1412        fn inline_size(_context: fidl::encoding::Context) -> usize {
1413            4
1414        }
1415    }
1416
1417    impl fidl::encoding::ValueTypeMarker for MgmtFrameCaptureFlags {
1418        type Borrowed<'a> = Self;
1419        #[inline(always)]
1420        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1421            *value
1422        }
1423    }
1424
1425    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1426        for MgmtFrameCaptureFlags
1427    {
1428        #[inline]
1429        unsafe fn encode(
1430            self,
1431            encoder: &mut fidl::encoding::Encoder<'_, D>,
1432            offset: usize,
1433            _depth: fidl::encoding::Depth,
1434        ) -> fidl::Result<()> {
1435            encoder.debug_check_bounds::<Self>(offset);
1436            if self.bits() & Self::all().bits() != self.bits() {
1437                return Err(fidl::Error::InvalidBitsValue);
1438            }
1439            encoder.write_num(self.bits(), offset);
1440            Ok(())
1441        }
1442    }
1443
1444    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MgmtFrameCaptureFlags {
1445        #[inline(always)]
1446        fn new_empty() -> Self {
1447            Self::empty()
1448        }
1449
1450        #[inline]
1451        unsafe fn decode(
1452            &mut self,
1453            decoder: &mut fidl::encoding::Decoder<'_, D>,
1454            offset: usize,
1455            _depth: fidl::encoding::Depth,
1456        ) -> fidl::Result<()> {
1457            decoder.debug_check_bounds::<Self>(offset);
1458            let prim = decoder.read_num::<u32>(offset);
1459            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1460            Ok(())
1461        }
1462    }
1463    unsafe impl fidl::encoding::TypeMarker for AssociateResultCode {
1464        type Owned = Self;
1465
1466        #[inline(always)]
1467        fn inline_align(_context: fidl::encoding::Context) -> usize {
1468            std::mem::align_of::<u32>()
1469        }
1470
1471        #[inline(always)]
1472        fn inline_size(_context: fidl::encoding::Context) -> usize {
1473            std::mem::size_of::<u32>()
1474        }
1475
1476        #[inline(always)]
1477        fn encode_is_copy() -> bool {
1478            true
1479        }
1480
1481        #[inline(always)]
1482        fn decode_is_copy() -> bool {
1483            false
1484        }
1485    }
1486
1487    impl fidl::encoding::ValueTypeMarker for AssociateResultCode {
1488        type Borrowed<'a> = Self;
1489        #[inline(always)]
1490        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1491            *value
1492        }
1493    }
1494
1495    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1496        for AssociateResultCode
1497    {
1498        #[inline]
1499        unsafe fn encode(
1500            self,
1501            encoder: &mut fidl::encoding::Encoder<'_, D>,
1502            offset: usize,
1503            _depth: fidl::encoding::Depth,
1504        ) -> fidl::Result<()> {
1505            encoder.debug_check_bounds::<Self>(offset);
1506            encoder.write_num(self.into_primitive(), offset);
1507            Ok(())
1508        }
1509    }
1510
1511    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AssociateResultCode {
1512        #[inline(always)]
1513        fn new_empty() -> Self {
1514            Self::Success
1515        }
1516
1517        #[inline]
1518        unsafe fn decode(
1519            &mut self,
1520            decoder: &mut fidl::encoding::Decoder<'_, D>,
1521            offset: usize,
1522            _depth: fidl::encoding::Depth,
1523        ) -> fidl::Result<()> {
1524            decoder.debug_check_bounds::<Self>(offset);
1525            let prim = decoder.read_num::<u32>(offset);
1526
1527            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1528            Ok(())
1529        }
1530    }
1531    unsafe impl fidl::encoding::TypeMarker for AuthenticateResultCode {
1532        type Owned = Self;
1533
1534        #[inline(always)]
1535        fn inline_align(_context: fidl::encoding::Context) -> usize {
1536            std::mem::align_of::<u32>()
1537        }
1538
1539        #[inline(always)]
1540        fn inline_size(_context: fidl::encoding::Context) -> usize {
1541            std::mem::size_of::<u32>()
1542        }
1543
1544        #[inline(always)]
1545        fn encode_is_copy() -> bool {
1546            true
1547        }
1548
1549        #[inline(always)]
1550        fn decode_is_copy() -> bool {
1551            false
1552        }
1553    }
1554
1555    impl fidl::encoding::ValueTypeMarker for AuthenticateResultCode {
1556        type Borrowed<'a> = Self;
1557        #[inline(always)]
1558        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1559            *value
1560        }
1561    }
1562
1563    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1564        for AuthenticateResultCode
1565    {
1566        #[inline]
1567        unsafe fn encode(
1568            self,
1569            encoder: &mut fidl::encoding::Encoder<'_, D>,
1570            offset: usize,
1571            _depth: fidl::encoding::Depth,
1572        ) -> fidl::Result<()> {
1573            encoder.debug_check_bounds::<Self>(offset);
1574            encoder.write_num(self.into_primitive(), offset);
1575            Ok(())
1576        }
1577    }
1578
1579    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1580        for AuthenticateResultCode
1581    {
1582        #[inline(always)]
1583        fn new_empty() -> Self {
1584            Self::Success
1585        }
1586
1587        #[inline]
1588        unsafe fn decode(
1589            &mut self,
1590            decoder: &mut fidl::encoding::Decoder<'_, D>,
1591            offset: usize,
1592            _depth: fidl::encoding::Depth,
1593        ) -> fidl::Result<()> {
1594            decoder.debug_check_bounds::<Self>(offset);
1595            let prim = decoder.read_num::<u32>(offset);
1596
1597            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1598            Ok(())
1599        }
1600    }
1601    unsafe impl fidl::encoding::TypeMarker for AuthenticationTypes {
1602        type Owned = Self;
1603
1604        #[inline(always)]
1605        fn inline_align(_context: fidl::encoding::Context) -> usize {
1606            std::mem::align_of::<u32>()
1607        }
1608
1609        #[inline(always)]
1610        fn inline_size(_context: fidl::encoding::Context) -> usize {
1611            std::mem::size_of::<u32>()
1612        }
1613
1614        #[inline(always)]
1615        fn encode_is_copy() -> bool {
1616            true
1617        }
1618
1619        #[inline(always)]
1620        fn decode_is_copy() -> bool {
1621            false
1622        }
1623    }
1624
1625    impl fidl::encoding::ValueTypeMarker for AuthenticationTypes {
1626        type Borrowed<'a> = Self;
1627        #[inline(always)]
1628        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1629            *value
1630        }
1631    }
1632
1633    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1634        for AuthenticationTypes
1635    {
1636        #[inline]
1637        unsafe fn encode(
1638            self,
1639            encoder: &mut fidl::encoding::Encoder<'_, D>,
1640            offset: usize,
1641            _depth: fidl::encoding::Depth,
1642        ) -> fidl::Result<()> {
1643            encoder.debug_check_bounds::<Self>(offset);
1644            encoder.write_num(self.into_primitive(), offset);
1645            Ok(())
1646        }
1647    }
1648
1649    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AuthenticationTypes {
1650        #[inline(always)]
1651        fn new_empty() -> Self {
1652            Self::OpenSystem
1653        }
1654
1655        #[inline]
1656        unsafe fn decode(
1657            &mut self,
1658            decoder: &mut fidl::encoding::Decoder<'_, D>,
1659            offset: usize,
1660            _depth: fidl::encoding::Depth,
1661        ) -> fidl::Result<()> {
1662            decoder.debug_check_bounds::<Self>(offset);
1663            let prim = decoder.read_num::<u32>(offset);
1664
1665            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1666            Ok(())
1667        }
1668    }
1669    unsafe impl fidl::encoding::TypeMarker for ControlledPortState {
1670        type Owned = Self;
1671
1672        #[inline(always)]
1673        fn inline_align(_context: fidl::encoding::Context) -> usize {
1674            std::mem::align_of::<u32>()
1675        }
1676
1677        #[inline(always)]
1678        fn inline_size(_context: fidl::encoding::Context) -> usize {
1679            std::mem::size_of::<u32>()
1680        }
1681
1682        #[inline(always)]
1683        fn encode_is_copy() -> bool {
1684            true
1685        }
1686
1687        #[inline(always)]
1688        fn decode_is_copy() -> bool {
1689            false
1690        }
1691    }
1692
1693    impl fidl::encoding::ValueTypeMarker for ControlledPortState {
1694        type Borrowed<'a> = Self;
1695        #[inline(always)]
1696        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1697            *value
1698        }
1699    }
1700
1701    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1702        for ControlledPortState
1703    {
1704        #[inline]
1705        unsafe fn encode(
1706            self,
1707            encoder: &mut fidl::encoding::Encoder<'_, D>,
1708            offset: usize,
1709            _depth: fidl::encoding::Depth,
1710        ) -> fidl::Result<()> {
1711            encoder.debug_check_bounds::<Self>(offset);
1712            encoder.write_num(self.into_primitive(), offset);
1713            Ok(())
1714        }
1715    }
1716
1717    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlledPortState {
1718        #[inline(always)]
1719        fn new_empty() -> Self {
1720            Self::Closed
1721        }
1722
1723        #[inline]
1724        unsafe fn decode(
1725            &mut self,
1726            decoder: &mut fidl::encoding::Decoder<'_, D>,
1727            offset: usize,
1728            _depth: fidl::encoding::Depth,
1729        ) -> fidl::Result<()> {
1730            decoder.debug_check_bounds::<Self>(offset);
1731            let prim = decoder.read_num::<u32>(offset);
1732
1733            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1734            Ok(())
1735        }
1736    }
1737    unsafe impl fidl::encoding::TypeMarker for EapolResultCode {
1738        type Owned = Self;
1739
1740        #[inline(always)]
1741        fn inline_align(_context: fidl::encoding::Context) -> usize {
1742            std::mem::align_of::<u32>()
1743        }
1744
1745        #[inline(always)]
1746        fn inline_size(_context: fidl::encoding::Context) -> usize {
1747            std::mem::size_of::<u32>()
1748        }
1749
1750        #[inline(always)]
1751        fn encode_is_copy() -> bool {
1752            true
1753        }
1754
1755        #[inline(always)]
1756        fn decode_is_copy() -> bool {
1757            false
1758        }
1759    }
1760
1761    impl fidl::encoding::ValueTypeMarker for EapolResultCode {
1762        type Borrowed<'a> = Self;
1763        #[inline(always)]
1764        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1765            *value
1766        }
1767    }
1768
1769    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1770        for EapolResultCode
1771    {
1772        #[inline]
1773        unsafe fn encode(
1774            self,
1775            encoder: &mut fidl::encoding::Encoder<'_, D>,
1776            offset: usize,
1777            _depth: fidl::encoding::Depth,
1778        ) -> fidl::Result<()> {
1779            encoder.debug_check_bounds::<Self>(offset);
1780            encoder.write_num(self.into_primitive(), offset);
1781            Ok(())
1782        }
1783    }
1784
1785    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EapolResultCode {
1786        #[inline(always)]
1787        fn new_empty() -> Self {
1788            Self::Success
1789        }
1790
1791        #[inline]
1792        unsafe fn decode(
1793            &mut self,
1794            decoder: &mut fidl::encoding::Decoder<'_, D>,
1795            offset: usize,
1796            _depth: fidl::encoding::Depth,
1797        ) -> fidl::Result<()> {
1798            decoder.debug_check_bounds::<Self>(offset);
1799            let prim = decoder.read_num::<u32>(offset);
1800
1801            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1802            Ok(())
1803        }
1804    }
1805    unsafe impl fidl::encoding::TypeMarker for KeyType {
1806        type Owned = Self;
1807
1808        #[inline(always)]
1809        fn inline_align(_context: fidl::encoding::Context) -> usize {
1810            std::mem::align_of::<u32>()
1811        }
1812
1813        #[inline(always)]
1814        fn inline_size(_context: fidl::encoding::Context) -> usize {
1815            std::mem::size_of::<u32>()
1816        }
1817
1818        #[inline(always)]
1819        fn encode_is_copy() -> bool {
1820            true
1821        }
1822
1823        #[inline(always)]
1824        fn decode_is_copy() -> bool {
1825            false
1826        }
1827    }
1828
1829    impl fidl::encoding::ValueTypeMarker for KeyType {
1830        type Borrowed<'a> = Self;
1831        #[inline(always)]
1832        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1833            *value
1834        }
1835    }
1836
1837    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for KeyType {
1838        #[inline]
1839        unsafe fn encode(
1840            self,
1841            encoder: &mut fidl::encoding::Encoder<'_, D>,
1842            offset: usize,
1843            _depth: fidl::encoding::Depth,
1844        ) -> fidl::Result<()> {
1845            encoder.debug_check_bounds::<Self>(offset);
1846            encoder.write_num(self.into_primitive(), offset);
1847            Ok(())
1848        }
1849    }
1850
1851    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for KeyType {
1852        #[inline(always)]
1853        fn new_empty() -> Self {
1854            Self::Group
1855        }
1856
1857        #[inline]
1858        unsafe fn decode(
1859            &mut self,
1860            decoder: &mut fidl::encoding::Decoder<'_, D>,
1861            offset: usize,
1862            _depth: fidl::encoding::Depth,
1863        ) -> fidl::Result<()> {
1864            decoder.debug_check_bounds::<Self>(offset);
1865            let prim = decoder.read_num::<u32>(offset);
1866
1867            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1868            Ok(())
1869        }
1870    }
1871    unsafe impl fidl::encoding::TypeMarker for ScanResultCode {
1872        type Owned = Self;
1873
1874        #[inline(always)]
1875        fn inline_align(_context: fidl::encoding::Context) -> usize {
1876            std::mem::align_of::<u32>()
1877        }
1878
1879        #[inline(always)]
1880        fn inline_size(_context: fidl::encoding::Context) -> usize {
1881            std::mem::size_of::<u32>()
1882        }
1883
1884        #[inline(always)]
1885        fn encode_is_copy() -> bool {
1886            true
1887        }
1888
1889        #[inline(always)]
1890        fn decode_is_copy() -> bool {
1891            false
1892        }
1893    }
1894
1895    impl fidl::encoding::ValueTypeMarker for ScanResultCode {
1896        type Borrowed<'a> = Self;
1897        #[inline(always)]
1898        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1899            *value
1900        }
1901    }
1902
1903    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ScanResultCode {
1904        #[inline]
1905        unsafe fn encode(
1906            self,
1907            encoder: &mut fidl::encoding::Encoder<'_, D>,
1908            offset: usize,
1909            _depth: fidl::encoding::Depth,
1910        ) -> fidl::Result<()> {
1911            encoder.debug_check_bounds::<Self>(offset);
1912            encoder.write_num(self.into_primitive(), offset);
1913            Ok(())
1914        }
1915    }
1916
1917    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanResultCode {
1918        #[inline(always)]
1919        fn new_empty() -> Self {
1920            Self::Success
1921        }
1922
1923        #[inline]
1924        unsafe fn decode(
1925            &mut self,
1926            decoder: &mut fidl::encoding::Decoder<'_, D>,
1927            offset: usize,
1928            _depth: fidl::encoding::Depth,
1929        ) -> fidl::Result<()> {
1930            decoder.debug_check_bounds::<Self>(offset);
1931            let prim = decoder.read_num::<u32>(offset);
1932
1933            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1934            Ok(())
1935        }
1936    }
1937    unsafe impl fidl::encoding::TypeMarker for ScanTypes {
1938        type Owned = Self;
1939
1940        #[inline(always)]
1941        fn inline_align(_context: fidl::encoding::Context) -> usize {
1942            std::mem::align_of::<u32>()
1943        }
1944
1945        #[inline(always)]
1946        fn inline_size(_context: fidl::encoding::Context) -> usize {
1947            std::mem::size_of::<u32>()
1948        }
1949
1950        #[inline(always)]
1951        fn encode_is_copy() -> bool {
1952            true
1953        }
1954
1955        #[inline(always)]
1956        fn decode_is_copy() -> bool {
1957            false
1958        }
1959    }
1960
1961    impl fidl::encoding::ValueTypeMarker for ScanTypes {
1962        type Borrowed<'a> = Self;
1963        #[inline(always)]
1964        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1965            *value
1966        }
1967    }
1968
1969    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ScanTypes {
1970        #[inline]
1971        unsafe fn encode(
1972            self,
1973            encoder: &mut fidl::encoding::Encoder<'_, D>,
1974            offset: usize,
1975            _depth: fidl::encoding::Depth,
1976        ) -> fidl::Result<()> {
1977            encoder.debug_check_bounds::<Self>(offset);
1978            encoder.write_num(self.into_primitive(), offset);
1979            Ok(())
1980        }
1981    }
1982
1983    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanTypes {
1984        #[inline(always)]
1985        fn new_empty() -> Self {
1986            Self::Active
1987        }
1988
1989        #[inline]
1990        unsafe fn decode(
1991            &mut self,
1992            decoder: &mut fidl::encoding::Decoder<'_, D>,
1993            offset: usize,
1994            _depth: fidl::encoding::Depth,
1995        ) -> fidl::Result<()> {
1996            decoder.debug_check_bounds::<Self>(offset);
1997            let prim = decoder.read_num::<u32>(offset);
1998
1999            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2000            Ok(())
2001        }
2002    }
2003    unsafe impl fidl::encoding::TypeMarker for StartResultCode {
2004        type Owned = Self;
2005
2006        #[inline(always)]
2007        fn inline_align(_context: fidl::encoding::Context) -> usize {
2008            std::mem::align_of::<u32>()
2009        }
2010
2011        #[inline(always)]
2012        fn inline_size(_context: fidl::encoding::Context) -> usize {
2013            std::mem::size_of::<u32>()
2014        }
2015
2016        #[inline(always)]
2017        fn encode_is_copy() -> bool {
2018            true
2019        }
2020
2021        #[inline(always)]
2022        fn decode_is_copy() -> bool {
2023            false
2024        }
2025    }
2026
2027    impl fidl::encoding::ValueTypeMarker for StartResultCode {
2028        type Borrowed<'a> = Self;
2029        #[inline(always)]
2030        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2031            *value
2032        }
2033    }
2034
2035    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2036        for StartResultCode
2037    {
2038        #[inline]
2039        unsafe fn encode(
2040            self,
2041            encoder: &mut fidl::encoding::Encoder<'_, D>,
2042            offset: usize,
2043            _depth: fidl::encoding::Depth,
2044        ) -> fidl::Result<()> {
2045            encoder.debug_check_bounds::<Self>(offset);
2046            encoder.write_num(self.into_primitive(), offset);
2047            Ok(())
2048        }
2049    }
2050
2051    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartResultCode {
2052        #[inline(always)]
2053        fn new_empty() -> Self {
2054            Self::Success
2055        }
2056
2057        #[inline]
2058        unsafe fn decode(
2059            &mut self,
2060            decoder: &mut fidl::encoding::Decoder<'_, D>,
2061            offset: usize,
2062            _depth: fidl::encoding::Depth,
2063        ) -> fidl::Result<()> {
2064            decoder.debug_check_bounds::<Self>(offset);
2065            let prim = decoder.read_num::<u32>(offset);
2066
2067            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2068            Ok(())
2069        }
2070    }
2071    unsafe impl fidl::encoding::TypeMarker for StopResultCode {
2072        type Owned = Self;
2073
2074        #[inline(always)]
2075        fn inline_align(_context: fidl::encoding::Context) -> usize {
2076            std::mem::align_of::<u32>()
2077        }
2078
2079        #[inline(always)]
2080        fn inline_size(_context: fidl::encoding::Context) -> usize {
2081            std::mem::size_of::<u32>()
2082        }
2083
2084        #[inline(always)]
2085        fn encode_is_copy() -> bool {
2086            true
2087        }
2088
2089        #[inline(always)]
2090        fn decode_is_copy() -> bool {
2091            false
2092        }
2093    }
2094
2095    impl fidl::encoding::ValueTypeMarker for StopResultCode {
2096        type Borrowed<'a> = Self;
2097        #[inline(always)]
2098        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2099            *value
2100        }
2101    }
2102
2103    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StopResultCode {
2104        #[inline]
2105        unsafe fn encode(
2106            self,
2107            encoder: &mut fidl::encoding::Encoder<'_, D>,
2108            offset: usize,
2109            _depth: fidl::encoding::Depth,
2110        ) -> fidl::Result<()> {
2111            encoder.debug_check_bounds::<Self>(offset);
2112            encoder.write_num(self.into_primitive(), offset);
2113            Ok(())
2114        }
2115    }
2116
2117    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopResultCode {
2118        #[inline(always)]
2119        fn new_empty() -> Self {
2120            Self::Success
2121        }
2122
2123        #[inline]
2124        unsafe fn decode(
2125            &mut self,
2126            decoder: &mut fidl::encoding::Decoder<'_, D>,
2127            offset: usize,
2128            _depth: fidl::encoding::Depth,
2129        ) -> fidl::Result<()> {
2130            decoder.debug_check_bounds::<Self>(offset);
2131            let prim = decoder.read_num::<u32>(offset);
2132
2133            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2134            Ok(())
2135        }
2136    }
2137
2138    impl fidl::encoding::ValueTypeMarker for AssociateIndication {
2139        type Borrowed<'a> = &'a Self;
2140        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2141            value
2142        }
2143    }
2144
2145    unsafe impl fidl::encoding::TypeMarker for AssociateIndication {
2146        type Owned = Self;
2147
2148        #[inline(always)]
2149        fn inline_align(_context: fidl::encoding::Context) -> usize {
2150            8
2151        }
2152
2153        #[inline(always)]
2154        fn inline_size(_context: fidl::encoding::Context) -> usize {
2155            64
2156        }
2157    }
2158
2159    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AssociateIndication, D>
2160        for &AssociateIndication
2161    {
2162        #[inline]
2163        unsafe fn encode(
2164            self,
2165            encoder: &mut fidl::encoding::Encoder<'_, D>,
2166            offset: usize,
2167            _depth: fidl::encoding::Depth,
2168        ) -> fidl::Result<()> {
2169            encoder.debug_check_bounds::<AssociateIndication>(offset);
2170            // Delegate to tuple encoding.
2171            fidl::encoding::Encode::<AssociateIndication, D>::encode(
2172                (
2173                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
2174                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.capability_info),
2175                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.listen_interval),
2176                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 32>> as fidl::encoding::ValueTypeMarker>::borrow(&self.ssid),
2177                    <fidl::encoding::Vector<u8, 14> as fidl::encoding::ValueTypeMarker>::borrow(&self.rates),
2178                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>> as fidl::encoding::ValueTypeMarker>::borrow(&self.rsne),
2179                ),
2180                encoder, offset, _depth
2181            )
2182        }
2183    }
2184    unsafe impl<
2185        D: fidl::encoding::ResourceDialect,
2186        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
2187        T1: fidl::encoding::Encode<u16, D>,
2188        T2: fidl::encoding::Encode<u16, D>,
2189        T3: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::Vector<u8, 32>>, D>,
2190        T4: fidl::encoding::Encode<fidl::encoding::Vector<u8, 14>, D>,
2191        T5: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>>, D>,
2192    > fidl::encoding::Encode<AssociateIndication, D> for (T0, T1, T2, T3, T4, T5)
2193    {
2194        #[inline]
2195        unsafe fn encode(
2196            self,
2197            encoder: &mut fidl::encoding::Encoder<'_, D>,
2198            offset: usize,
2199            depth: fidl::encoding::Depth,
2200        ) -> fidl::Result<()> {
2201            encoder.debug_check_bounds::<AssociateIndication>(offset);
2202            // Zero out padding regions. There's no need to apply masks
2203            // because the unmasked parts will be overwritten by fields.
2204            unsafe {
2205                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
2206                (ptr as *mut u64).write_unaligned(0);
2207            }
2208            // Write the fields.
2209            self.0.encode(encoder, offset + 0, depth)?;
2210            self.1.encode(encoder, offset + 6, depth)?;
2211            self.2.encode(encoder, offset + 8, depth)?;
2212            self.3.encode(encoder, offset + 16, depth)?;
2213            self.4.encode(encoder, offset + 32, depth)?;
2214            self.5.encode(encoder, offset + 48, depth)?;
2215            Ok(())
2216        }
2217    }
2218
2219    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AssociateIndication {
2220        #[inline(always)]
2221        fn new_empty() -> Self {
2222            Self {
2223                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
2224                capability_info: fidl::new_empty!(u16, D),
2225                listen_interval: fidl::new_empty!(u16, D),
2226                ssid: fidl::new_empty!(fidl::encoding::Optional<fidl::encoding::Vector<u8, 32>>, D),
2227                rates: fidl::new_empty!(fidl::encoding::Vector<u8, 14>, D),
2228                rsne: fidl::new_empty!(
2229                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>>,
2230                    D
2231                ),
2232            }
2233        }
2234
2235        #[inline]
2236        unsafe fn decode(
2237            &mut self,
2238            decoder: &mut fidl::encoding::Decoder<'_, D>,
2239            offset: usize,
2240            _depth: fidl::encoding::Depth,
2241        ) -> fidl::Result<()> {
2242            decoder.debug_check_bounds::<Self>(offset);
2243            // Verify that padding bytes are zero.
2244            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
2245            let padval = unsafe { (ptr as *const u64).read_unaligned() };
2246            let mask = 0xffffffffffff0000u64;
2247            let maskedval = padval & mask;
2248            if maskedval != 0 {
2249                return Err(fidl::Error::NonZeroPadding {
2250                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
2251                });
2252            }
2253            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
2254            fidl::decode!(u16, D, &mut self.capability_info, decoder, offset + 6, _depth)?;
2255            fidl::decode!(u16, D, &mut self.listen_interval, decoder, offset + 8, _depth)?;
2256            fidl::decode!(
2257                fidl::encoding::Optional<fidl::encoding::Vector<u8, 32>>,
2258                D,
2259                &mut self.ssid,
2260                decoder,
2261                offset + 16,
2262                _depth
2263            )?;
2264            fidl::decode!(fidl::encoding::Vector<u8, 14>, D, &mut self.rates, decoder, offset + 32, _depth)?;
2265            fidl::decode!(
2266                fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>>,
2267                D,
2268                &mut self.rsne,
2269                decoder,
2270                offset + 48,
2271                _depth
2272            )?;
2273            Ok(())
2274        }
2275    }
2276
2277    impl fidl::encoding::ValueTypeMarker for AssociateResponse {
2278        type Borrowed<'a> = &'a Self;
2279        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2280            value
2281        }
2282    }
2283
2284    unsafe impl fidl::encoding::TypeMarker for AssociateResponse {
2285        type Owned = Self;
2286
2287        #[inline(always)]
2288        fn inline_align(_context: fidl::encoding::Context) -> usize {
2289            8
2290        }
2291
2292        #[inline(always)]
2293        fn inline_size(_context: fidl::encoding::Context) -> usize {
2294            32
2295        }
2296    }
2297
2298    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AssociateResponse, D>
2299        for &AssociateResponse
2300    {
2301        #[inline]
2302        unsafe fn encode(
2303            self,
2304            encoder: &mut fidl::encoding::Encoder<'_, D>,
2305            offset: usize,
2306            _depth: fidl::encoding::Depth,
2307        ) -> fidl::Result<()> {
2308            encoder.debug_check_bounds::<AssociateResponse>(offset);
2309            // Delegate to tuple encoding.
2310            fidl::encoding::Encode::<AssociateResponse, D>::encode(
2311                (
2312                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
2313                        &self.peer_sta_address,
2314                    ),
2315                    <AssociateResultCode as fidl::encoding::ValueTypeMarker>::borrow(
2316                        &self.result_code,
2317                    ),
2318                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.association_id),
2319                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.capability_info),
2320                    <fidl::encoding::Vector<u8, 14> as fidl::encoding::ValueTypeMarker>::borrow(
2321                        &self.rates,
2322                    ),
2323                ),
2324                encoder,
2325                offset,
2326                _depth,
2327            )
2328        }
2329    }
2330    unsafe impl<
2331        D: fidl::encoding::ResourceDialect,
2332        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
2333        T1: fidl::encoding::Encode<AssociateResultCode, D>,
2334        T2: fidl::encoding::Encode<u16, D>,
2335        T3: fidl::encoding::Encode<u16, D>,
2336        T4: fidl::encoding::Encode<fidl::encoding::Vector<u8, 14>, D>,
2337    > fidl::encoding::Encode<AssociateResponse, D> for (T0, T1, T2, T3, T4)
2338    {
2339        #[inline]
2340        unsafe fn encode(
2341            self,
2342            encoder: &mut fidl::encoding::Encoder<'_, D>,
2343            offset: usize,
2344            depth: fidl::encoding::Depth,
2345        ) -> fidl::Result<()> {
2346            encoder.debug_check_bounds::<AssociateResponse>(offset);
2347            // Zero out padding regions. There's no need to apply masks
2348            // because the unmasked parts will be overwritten by fields.
2349            unsafe {
2350                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
2351                (ptr as *mut u64).write_unaligned(0);
2352            }
2353            // Write the fields.
2354            self.0.encode(encoder, offset + 0, depth)?;
2355            self.1.encode(encoder, offset + 8, depth)?;
2356            self.2.encode(encoder, offset + 12, depth)?;
2357            self.3.encode(encoder, offset + 14, depth)?;
2358            self.4.encode(encoder, offset + 16, depth)?;
2359            Ok(())
2360        }
2361    }
2362
2363    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AssociateResponse {
2364        #[inline(always)]
2365        fn new_empty() -> Self {
2366            Self {
2367                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
2368                result_code: fidl::new_empty!(AssociateResultCode, D),
2369                association_id: fidl::new_empty!(u16, D),
2370                capability_info: fidl::new_empty!(u16, D),
2371                rates: fidl::new_empty!(fidl::encoding::Vector<u8, 14>, D),
2372            }
2373        }
2374
2375        #[inline]
2376        unsafe fn decode(
2377            &mut self,
2378            decoder: &mut fidl::encoding::Decoder<'_, D>,
2379            offset: usize,
2380            _depth: fidl::encoding::Depth,
2381        ) -> fidl::Result<()> {
2382            decoder.debug_check_bounds::<Self>(offset);
2383            // Verify that padding bytes are zero.
2384            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
2385            let padval = unsafe { (ptr as *const u64).read_unaligned() };
2386            let mask = 0xffff000000000000u64;
2387            let maskedval = padval & mask;
2388            if maskedval != 0 {
2389                return Err(fidl::Error::NonZeroPadding {
2390                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
2391                });
2392            }
2393            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
2394            fidl::decode!(
2395                AssociateResultCode,
2396                D,
2397                &mut self.result_code,
2398                decoder,
2399                offset + 8,
2400                _depth
2401            )?;
2402            fidl::decode!(u16, D, &mut self.association_id, decoder, offset + 12, _depth)?;
2403            fidl::decode!(u16, D, &mut self.capability_info, decoder, offset + 14, _depth)?;
2404            fidl::decode!(fidl::encoding::Vector<u8, 14>, D, &mut self.rates, decoder, offset + 16, _depth)?;
2405            Ok(())
2406        }
2407    }
2408
2409    impl fidl::encoding::ValueTypeMarker for AuthenticateIndication {
2410        type Borrowed<'a> = &'a Self;
2411        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2412            value
2413        }
2414    }
2415
2416    unsafe impl fidl::encoding::TypeMarker for AuthenticateIndication {
2417        type Owned = Self;
2418
2419        #[inline(always)]
2420        fn inline_align(_context: fidl::encoding::Context) -> usize {
2421            4
2422        }
2423
2424        #[inline(always)]
2425        fn inline_size(_context: fidl::encoding::Context) -> usize {
2426            12
2427        }
2428    }
2429
2430    unsafe impl<D: fidl::encoding::ResourceDialect>
2431        fidl::encoding::Encode<AuthenticateIndication, D> for &AuthenticateIndication
2432    {
2433        #[inline]
2434        unsafe fn encode(
2435            self,
2436            encoder: &mut fidl::encoding::Encoder<'_, D>,
2437            offset: usize,
2438            _depth: fidl::encoding::Depth,
2439        ) -> fidl::Result<()> {
2440            encoder.debug_check_bounds::<AuthenticateIndication>(offset);
2441            // Delegate to tuple encoding.
2442            fidl::encoding::Encode::<AuthenticateIndication, D>::encode(
2443                (
2444                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
2445                        &self.peer_sta_address,
2446                    ),
2447                    <AuthenticationTypes as fidl::encoding::ValueTypeMarker>::borrow(
2448                        &self.auth_type,
2449                    ),
2450                ),
2451                encoder,
2452                offset,
2453                _depth,
2454            )
2455        }
2456    }
2457    unsafe impl<
2458        D: fidl::encoding::ResourceDialect,
2459        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
2460        T1: fidl::encoding::Encode<AuthenticationTypes, D>,
2461    > fidl::encoding::Encode<AuthenticateIndication, D> for (T0, T1)
2462    {
2463        #[inline]
2464        unsafe fn encode(
2465            self,
2466            encoder: &mut fidl::encoding::Encoder<'_, D>,
2467            offset: usize,
2468            depth: fidl::encoding::Depth,
2469        ) -> fidl::Result<()> {
2470            encoder.debug_check_bounds::<AuthenticateIndication>(offset);
2471            // Zero out padding regions. There's no need to apply masks
2472            // because the unmasked parts will be overwritten by fields.
2473            unsafe {
2474                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
2475                (ptr as *mut u32).write_unaligned(0);
2476            }
2477            // Write the fields.
2478            self.0.encode(encoder, offset + 0, depth)?;
2479            self.1.encode(encoder, offset + 8, depth)?;
2480            Ok(())
2481        }
2482    }
2483
2484    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2485        for AuthenticateIndication
2486    {
2487        #[inline(always)]
2488        fn new_empty() -> Self {
2489            Self {
2490                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
2491                auth_type: fidl::new_empty!(AuthenticationTypes, D),
2492            }
2493        }
2494
2495        #[inline]
2496        unsafe fn decode(
2497            &mut self,
2498            decoder: &mut fidl::encoding::Decoder<'_, D>,
2499            offset: usize,
2500            _depth: fidl::encoding::Depth,
2501        ) -> fidl::Result<()> {
2502            decoder.debug_check_bounds::<Self>(offset);
2503            // Verify that padding bytes are zero.
2504            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(4) };
2505            let padval = unsafe { (ptr as *const u32).read_unaligned() };
2506            let mask = 0xffff0000u32;
2507            let maskedval = padval & mask;
2508            if maskedval != 0 {
2509                return Err(fidl::Error::NonZeroPadding {
2510                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
2511                });
2512            }
2513            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
2514            fidl::decode!(
2515                AuthenticationTypes,
2516                D,
2517                &mut self.auth_type,
2518                decoder,
2519                offset + 8,
2520                _depth
2521            )?;
2522            Ok(())
2523        }
2524    }
2525
2526    impl fidl::encoding::ValueTypeMarker for AuthenticateResponse {
2527        type Borrowed<'a> = &'a Self;
2528        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2529            value
2530        }
2531    }
2532
2533    unsafe impl fidl::encoding::TypeMarker for AuthenticateResponse {
2534        type Owned = Self;
2535
2536        #[inline(always)]
2537        fn inline_align(_context: fidl::encoding::Context) -> usize {
2538            4
2539        }
2540
2541        #[inline(always)]
2542        fn inline_size(_context: fidl::encoding::Context) -> usize {
2543            12
2544        }
2545    }
2546
2547    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AuthenticateResponse, D>
2548        for &AuthenticateResponse
2549    {
2550        #[inline]
2551        unsafe fn encode(
2552            self,
2553            encoder: &mut fidl::encoding::Encoder<'_, D>,
2554            offset: usize,
2555            _depth: fidl::encoding::Depth,
2556        ) -> fidl::Result<()> {
2557            encoder.debug_check_bounds::<AuthenticateResponse>(offset);
2558            // Delegate to tuple encoding.
2559            fidl::encoding::Encode::<AuthenticateResponse, D>::encode(
2560                (
2561                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
2562                        &self.peer_sta_address,
2563                    ),
2564                    <AuthenticateResultCode as fidl::encoding::ValueTypeMarker>::borrow(
2565                        &self.result_code,
2566                    ),
2567                ),
2568                encoder,
2569                offset,
2570                _depth,
2571            )
2572        }
2573    }
2574    unsafe impl<
2575        D: fidl::encoding::ResourceDialect,
2576        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
2577        T1: fidl::encoding::Encode<AuthenticateResultCode, D>,
2578    > fidl::encoding::Encode<AuthenticateResponse, D> for (T0, T1)
2579    {
2580        #[inline]
2581        unsafe fn encode(
2582            self,
2583            encoder: &mut fidl::encoding::Encoder<'_, D>,
2584            offset: usize,
2585            depth: fidl::encoding::Depth,
2586        ) -> fidl::Result<()> {
2587            encoder.debug_check_bounds::<AuthenticateResponse>(offset);
2588            // Zero out padding regions. There's no need to apply masks
2589            // because the unmasked parts will be overwritten by fields.
2590            unsafe {
2591                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
2592                (ptr as *mut u32).write_unaligned(0);
2593            }
2594            // Write the fields.
2595            self.0.encode(encoder, offset + 0, depth)?;
2596            self.1.encode(encoder, offset + 8, depth)?;
2597            Ok(())
2598        }
2599    }
2600
2601    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AuthenticateResponse {
2602        #[inline(always)]
2603        fn new_empty() -> Self {
2604            Self {
2605                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
2606                result_code: fidl::new_empty!(AuthenticateResultCode, D),
2607            }
2608        }
2609
2610        #[inline]
2611        unsafe fn decode(
2612            &mut self,
2613            decoder: &mut fidl::encoding::Decoder<'_, D>,
2614            offset: usize,
2615            _depth: fidl::encoding::Depth,
2616        ) -> fidl::Result<()> {
2617            decoder.debug_check_bounds::<Self>(offset);
2618            // Verify that padding bytes are zero.
2619            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(4) };
2620            let padval = unsafe { (ptr as *const u32).read_unaligned() };
2621            let mask = 0xffff0000u32;
2622            let maskedval = padval & mask;
2623            if maskedval != 0 {
2624                return Err(fidl::Error::NonZeroPadding {
2625                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
2626                });
2627            }
2628            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
2629            fidl::decode!(
2630                AuthenticateResultCode,
2631                D,
2632                &mut self.result_code,
2633                decoder,
2634                offset + 8,
2635                _depth
2636            )?;
2637            Ok(())
2638        }
2639    }
2640
2641    impl fidl::encoding::ValueTypeMarker for BandCapability {
2642        type Borrowed<'a> = &'a Self;
2643        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2644            value
2645        }
2646    }
2647
2648    unsafe impl fidl::encoding::TypeMarker for BandCapability {
2649        type Owned = Self;
2650
2651        #[inline(always)]
2652        fn inline_align(_context: fidl::encoding::Context) -> usize {
2653            8
2654        }
2655
2656        #[inline(always)]
2657        fn inline_size(_context: fidl::encoding::Context) -> usize {
2658            56
2659        }
2660    }
2661
2662    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BandCapability, D>
2663        for &BandCapability
2664    {
2665        #[inline]
2666        unsafe fn encode(
2667            self,
2668            encoder: &mut fidl::encoding::Encoder<'_, D>,
2669            offset: usize,
2670            _depth: fidl::encoding::Depth,
2671        ) -> fidl::Result<()> {
2672            encoder.debug_check_bounds::<BandCapability>(offset);
2673            // Delegate to tuple encoding.
2674            fidl::encoding::Encode::<BandCapability, D>::encode(
2675                (
2676                    <fidl_fuchsia_wlan_ieee80211__common::WlanBand as fidl::encoding::ValueTypeMarker>::borrow(&self.band),
2677                    <fidl::encoding::Vector<u8, 12> as fidl::encoding::ValueTypeMarker>::borrow(&self.basic_rates),
2678                    <fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities> as fidl::encoding::ValueTypeMarker>::borrow(&self.ht_cap),
2679                    <fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities> as fidl::encoding::ValueTypeMarker>::borrow(&self.vht_cap),
2680                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.operating_channels),
2681                ),
2682                encoder, offset, _depth
2683            )
2684        }
2685    }
2686    unsafe impl<
2687        D: fidl::encoding::ResourceDialect,
2688        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::WlanBand, D>,
2689        T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 12>, D>,
2690        T2: fidl::encoding::Encode<
2691                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>,
2692                D,
2693            >,
2694        T3: fidl::encoding::Encode<
2695                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>,
2696                D,
2697            >,
2698        T4: fidl::encoding::Encode<fidl::encoding::Vector<u8, 256>, D>,
2699    > fidl::encoding::Encode<BandCapability, D> for (T0, T1, T2, T3, T4)
2700    {
2701        #[inline]
2702        unsafe fn encode(
2703            self,
2704            encoder: &mut fidl::encoding::Encoder<'_, D>,
2705            offset: usize,
2706            depth: fidl::encoding::Depth,
2707        ) -> fidl::Result<()> {
2708            encoder.debug_check_bounds::<BandCapability>(offset);
2709            // Zero out padding regions. There's no need to apply masks
2710            // because the unmasked parts will be overwritten by fields.
2711            unsafe {
2712                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
2713                (ptr as *mut u64).write_unaligned(0);
2714            }
2715            // Write the fields.
2716            self.0.encode(encoder, offset + 0, depth)?;
2717            self.1.encode(encoder, offset + 8, depth)?;
2718            self.2.encode(encoder, offset + 24, depth)?;
2719            self.3.encode(encoder, offset + 32, depth)?;
2720            self.4.encode(encoder, offset + 40, depth)?;
2721            Ok(())
2722        }
2723    }
2724
2725    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BandCapability {
2726        #[inline(always)]
2727        fn new_empty() -> Self {
2728            Self {
2729                band: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::WlanBand, D),
2730                basic_rates: fidl::new_empty!(fidl::encoding::Vector<u8, 12>, D),
2731                ht_cap: fidl::new_empty!(
2732                    fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>,
2733                    D
2734                ),
2735                vht_cap: fidl::new_empty!(
2736                    fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>,
2737                    D
2738                ),
2739                operating_channels: fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D),
2740            }
2741        }
2742
2743        #[inline]
2744        unsafe fn decode(
2745            &mut self,
2746            decoder: &mut fidl::encoding::Decoder<'_, D>,
2747            offset: usize,
2748            _depth: fidl::encoding::Depth,
2749        ) -> fidl::Result<()> {
2750            decoder.debug_check_bounds::<Self>(offset);
2751            // Verify that padding bytes are zero.
2752            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
2753            let padval = unsafe { (ptr as *const u64).read_unaligned() };
2754            let mask = 0xffffffffffffff00u64;
2755            let maskedval = padval & mask;
2756            if maskedval != 0 {
2757                return Err(fidl::Error::NonZeroPadding {
2758                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
2759                });
2760            }
2761            fidl::decode!(
2762                fidl_fuchsia_wlan_ieee80211__common::WlanBand,
2763                D,
2764                &mut self.band,
2765                decoder,
2766                offset + 0,
2767                _depth
2768            )?;
2769            fidl::decode!(fidl::encoding::Vector<u8, 12>, D, &mut self.basic_rates, decoder, offset + 8, _depth)?;
2770            fidl::decode!(
2771                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>,
2772                D,
2773                &mut self.ht_cap,
2774                decoder,
2775                offset + 24,
2776                _depth
2777            )?;
2778            fidl::decode!(
2779                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>,
2780                D,
2781                &mut self.vht_cap,
2782                decoder,
2783                offset + 32,
2784                _depth
2785            )?;
2786            fidl::decode!(fidl::encoding::Vector<u8, 256>, D, &mut self.operating_channels, decoder, offset + 40, _depth)?;
2787            Ok(())
2788        }
2789    }
2790
2791    impl fidl::encoding::ValueTypeMarker for CapturedFrameResult {
2792        type Borrowed<'a> = &'a Self;
2793        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2794            value
2795        }
2796    }
2797
2798    unsafe impl fidl::encoding::TypeMarker for CapturedFrameResult {
2799        type Owned = Self;
2800
2801        #[inline(always)]
2802        fn inline_align(_context: fidl::encoding::Context) -> usize {
2803            8
2804        }
2805
2806        #[inline(always)]
2807        fn inline_size(_context: fidl::encoding::Context) -> usize {
2808            16
2809        }
2810    }
2811
2812    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CapturedFrameResult, D>
2813        for &CapturedFrameResult
2814    {
2815        #[inline]
2816        unsafe fn encode(
2817            self,
2818            encoder: &mut fidl::encoding::Encoder<'_, D>,
2819            offset: usize,
2820            _depth: fidl::encoding::Depth,
2821        ) -> fidl::Result<()> {
2822            encoder.debug_check_bounds::<CapturedFrameResult>(offset);
2823            // Delegate to tuple encoding.
2824            fidl::encoding::Encode::<CapturedFrameResult, D>::encode(
2825                (<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(
2826                    &self.frame,
2827                ),),
2828                encoder,
2829                offset,
2830                _depth,
2831            )
2832        }
2833    }
2834    unsafe impl<
2835        D: fidl::encoding::ResourceDialect,
2836        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
2837    > fidl::encoding::Encode<CapturedFrameResult, D> for (T0,)
2838    {
2839        #[inline]
2840        unsafe fn encode(
2841            self,
2842            encoder: &mut fidl::encoding::Encoder<'_, D>,
2843            offset: usize,
2844            depth: fidl::encoding::Depth,
2845        ) -> fidl::Result<()> {
2846            encoder.debug_check_bounds::<CapturedFrameResult>(offset);
2847            // Zero out padding regions. There's no need to apply masks
2848            // because the unmasked parts will be overwritten by fields.
2849            // Write the fields.
2850            self.0.encode(encoder, offset + 0, depth)?;
2851            Ok(())
2852        }
2853    }
2854
2855    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CapturedFrameResult {
2856        #[inline(always)]
2857        fn new_empty() -> Self {
2858            Self { frame: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D) }
2859        }
2860
2861        #[inline]
2862        unsafe fn decode(
2863            &mut self,
2864            decoder: &mut fidl::encoding::Decoder<'_, D>,
2865            offset: usize,
2866            _depth: fidl::encoding::Depth,
2867        ) -> fidl::Result<()> {
2868            decoder.debug_check_bounds::<Self>(offset);
2869            // Verify that padding bytes are zero.
2870            fidl::decode!(
2871                fidl::encoding::UnboundedVector<u8>,
2872                D,
2873                &mut self.frame,
2874                decoder,
2875                offset + 0,
2876                _depth
2877            )?;
2878            Ok(())
2879        }
2880    }
2881
2882    impl fidl::encoding::ValueTypeMarker for ConnectConfirm {
2883        type Borrowed<'a> = &'a Self;
2884        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2885            value
2886        }
2887    }
2888
2889    unsafe impl fidl::encoding::TypeMarker for ConnectConfirm {
2890        type Owned = Self;
2891
2892        #[inline(always)]
2893        fn inline_align(_context: fidl::encoding::Context) -> usize {
2894            8
2895        }
2896
2897        #[inline(always)]
2898        fn inline_size(_context: fidl::encoding::Context) -> usize {
2899            32
2900        }
2901    }
2902
2903    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConnectConfirm, D>
2904        for &ConnectConfirm
2905    {
2906        #[inline]
2907        unsafe fn encode(
2908            self,
2909            encoder: &mut fidl::encoding::Encoder<'_, D>,
2910            offset: usize,
2911            _depth: fidl::encoding::Depth,
2912        ) -> fidl::Result<()> {
2913            encoder.debug_check_bounds::<ConnectConfirm>(offset);
2914            // Delegate to tuple encoding.
2915            fidl::encoding::Encode::<ConnectConfirm, D>::encode(
2916                (
2917                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
2918                    <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow(&self.result_code),
2919                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.association_id),
2920                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.association_ies),
2921                ),
2922                encoder, offset, _depth
2923            )
2924        }
2925    }
2926    unsafe impl<
2927        D: fidl::encoding::ResourceDialect,
2928        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
2929        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>,
2930        T2: fidl::encoding::Encode<u16, D>,
2931        T3: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
2932    > fidl::encoding::Encode<ConnectConfirm, D> for (T0, T1, T2, T3)
2933    {
2934        #[inline]
2935        unsafe fn encode(
2936            self,
2937            encoder: &mut fidl::encoding::Encoder<'_, D>,
2938            offset: usize,
2939            depth: fidl::encoding::Depth,
2940        ) -> fidl::Result<()> {
2941            encoder.debug_check_bounds::<ConnectConfirm>(offset);
2942            // Zero out padding regions. There's no need to apply masks
2943            // because the unmasked parts will be overwritten by fields.
2944            unsafe {
2945                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
2946                (ptr as *mut u64).write_unaligned(0);
2947            }
2948            // Write the fields.
2949            self.0.encode(encoder, offset + 0, depth)?;
2950            self.1.encode(encoder, offset + 6, depth)?;
2951            self.2.encode(encoder, offset + 8, depth)?;
2952            self.3.encode(encoder, offset + 16, depth)?;
2953            Ok(())
2954        }
2955    }
2956
2957    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectConfirm {
2958        #[inline(always)]
2959        fn new_empty() -> Self {
2960            Self {
2961                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
2962                result_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D),
2963                association_id: fidl::new_empty!(u16, D),
2964                association_ies: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
2965            }
2966        }
2967
2968        #[inline]
2969        unsafe fn decode(
2970            &mut self,
2971            decoder: &mut fidl::encoding::Decoder<'_, D>,
2972            offset: usize,
2973            _depth: fidl::encoding::Depth,
2974        ) -> fidl::Result<()> {
2975            decoder.debug_check_bounds::<Self>(offset);
2976            // Verify that padding bytes are zero.
2977            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
2978            let padval = unsafe { (ptr as *const u64).read_unaligned() };
2979            let mask = 0xffffffffffff0000u64;
2980            let maskedval = padval & mask;
2981            if maskedval != 0 {
2982                return Err(fidl::Error::NonZeroPadding {
2983                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
2984                });
2985            }
2986            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
2987            fidl::decode!(
2988                fidl_fuchsia_wlan_ieee80211__common::StatusCode,
2989                D,
2990                &mut self.result_code,
2991                decoder,
2992                offset + 6,
2993                _depth
2994            )?;
2995            fidl::decode!(u16, D, &mut self.association_id, decoder, offset + 8, _depth)?;
2996            fidl::decode!(
2997                fidl::encoding::UnboundedVector<u8>,
2998                D,
2999                &mut self.association_ies,
3000                decoder,
3001                offset + 16,
3002                _depth
3003            )?;
3004            Ok(())
3005        }
3006    }
3007
3008    impl fidl::encoding::ValueTypeMarker for ConnectRequest {
3009        type Borrowed<'a> = &'a Self;
3010        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3011            value
3012        }
3013    }
3014
3015    unsafe impl fidl::encoding::TypeMarker for ConnectRequest {
3016        type Owned = Self;
3017
3018        #[inline(always)]
3019        fn inline_align(_context: fidl::encoding::Context) -> usize {
3020            8
3021        }
3022
3023        #[inline(always)]
3024        fn inline_size(_context: fidl::encoding::Context) -> usize {
3025            104
3026        }
3027    }
3028
3029    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConnectRequest, D>
3030        for &ConnectRequest
3031    {
3032        #[inline]
3033        unsafe fn encode(
3034            self,
3035            encoder: &mut fidl::encoding::Encoder<'_, D>,
3036            offset: usize,
3037            _depth: fidl::encoding::Depth,
3038        ) -> fidl::Result<()> {
3039            encoder.debug_check_bounds::<ConnectRequest>(offset);
3040            // Delegate to tuple encoding.
3041            fidl::encoding::Encode::<ConnectRequest, D>::encode(
3042                (
3043                    <fidl_fuchsia_wlan_ieee80211__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow(&self.selected_bss),
3044                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.connect_failure_timeout),
3045                    <AuthenticationTypes as fidl::encoding::ValueTypeMarker>::borrow(&self.auth_type),
3046                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.sae_password),
3047                    <fidl::encoding::Boxed<SetKeyDescriptor> as fidl::encoding::ValueTypeMarker>::borrow(&self.wep_key),
3048                    <fidl::encoding::Vector<u8, 257> as fidl::encoding::ValueTypeMarker>::borrow(&self.security_ie),
3049                    <fidl::encoding::Boxed<fidl_fuchsia_wlan_internal__common::OwePublicKey> as fidl::encoding::ValueTypeMarker>::borrow(&self.owe_public_key),
3050                ),
3051                encoder, offset, _depth
3052            )
3053        }
3054    }
3055    unsafe impl<
3056        D: fidl::encoding::ResourceDialect,
3057        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::BssDescription, D>,
3058        T1: fidl::encoding::Encode<u32, D>,
3059        T2: fidl::encoding::Encode<AuthenticationTypes, D>,
3060        T3: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
3061        T4: fidl::encoding::Encode<fidl::encoding::Boxed<SetKeyDescriptor>, D>,
3062        T5: fidl::encoding::Encode<fidl::encoding::Vector<u8, 257>, D>,
3063        T6: fidl::encoding::Encode<
3064                fidl::encoding::Boxed<fidl_fuchsia_wlan_internal__common::OwePublicKey>,
3065                D,
3066            >,
3067    > fidl::encoding::Encode<ConnectRequest, D> for (T0, T1, T2, T3, T4, T5, T6)
3068    {
3069        #[inline]
3070        unsafe fn encode(
3071            self,
3072            encoder: &mut fidl::encoding::Encoder<'_, D>,
3073            offset: usize,
3074            depth: fidl::encoding::Depth,
3075        ) -> fidl::Result<()> {
3076            encoder.debug_check_bounds::<ConnectRequest>(offset);
3077            // Zero out padding regions. There's no need to apply masks
3078            // because the unmasked parts will be overwritten by fields.
3079            // Write the fields.
3080            self.0.encode(encoder, offset + 0, depth)?;
3081            self.1.encode(encoder, offset + 48, depth)?;
3082            self.2.encode(encoder, offset + 52, depth)?;
3083            self.3.encode(encoder, offset + 56, depth)?;
3084            self.4.encode(encoder, offset + 72, depth)?;
3085            self.5.encode(encoder, offset + 80, depth)?;
3086            self.6.encode(encoder, offset + 96, depth)?;
3087            Ok(())
3088        }
3089    }
3090
3091    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectRequest {
3092        #[inline(always)]
3093        fn new_empty() -> Self {
3094            Self {
3095                selected_bss: fidl::new_empty!(
3096                    fidl_fuchsia_wlan_ieee80211__common::BssDescription,
3097                    D
3098                ),
3099                connect_failure_timeout: fidl::new_empty!(u32, D),
3100                auth_type: fidl::new_empty!(AuthenticationTypes, D),
3101                sae_password: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
3102                wep_key: fidl::new_empty!(fidl::encoding::Boxed<SetKeyDescriptor>, D),
3103                security_ie: fidl::new_empty!(fidl::encoding::Vector<u8, 257>, D),
3104                owe_public_key: fidl::new_empty!(
3105                    fidl::encoding::Boxed<fidl_fuchsia_wlan_internal__common::OwePublicKey>,
3106                    D
3107                ),
3108            }
3109        }
3110
3111        #[inline]
3112        unsafe fn decode(
3113            &mut self,
3114            decoder: &mut fidl::encoding::Decoder<'_, D>,
3115            offset: usize,
3116            _depth: fidl::encoding::Depth,
3117        ) -> fidl::Result<()> {
3118            decoder.debug_check_bounds::<Self>(offset);
3119            // Verify that padding bytes are zero.
3120            fidl::decode!(
3121                fidl_fuchsia_wlan_ieee80211__common::BssDescription,
3122                D,
3123                &mut self.selected_bss,
3124                decoder,
3125                offset + 0,
3126                _depth
3127            )?;
3128            fidl::decode!(u32, D, &mut self.connect_failure_timeout, decoder, offset + 48, _depth)?;
3129            fidl::decode!(
3130                AuthenticationTypes,
3131                D,
3132                &mut self.auth_type,
3133                decoder,
3134                offset + 52,
3135                _depth
3136            )?;
3137            fidl::decode!(
3138                fidl::encoding::UnboundedVector<u8>,
3139                D,
3140                &mut self.sae_password,
3141                decoder,
3142                offset + 56,
3143                _depth
3144            )?;
3145            fidl::decode!(
3146                fidl::encoding::Boxed<SetKeyDescriptor>,
3147                D,
3148                &mut self.wep_key,
3149                decoder,
3150                offset + 72,
3151                _depth
3152            )?;
3153            fidl::decode!(fidl::encoding::Vector<u8, 257>, D, &mut self.security_ie, decoder, offset + 80, _depth)?;
3154            fidl::decode!(
3155                fidl::encoding::Boxed<fidl_fuchsia_wlan_internal__common::OwePublicKey>,
3156                D,
3157                &mut self.owe_public_key,
3158                decoder,
3159                offset + 96,
3160                _depth
3161            )?;
3162            Ok(())
3163        }
3164    }
3165
3166    impl fidl::encoding::ValueTypeMarker for Country {
3167        type Borrowed<'a> = &'a Self;
3168        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3169            value
3170        }
3171    }
3172
3173    unsafe impl fidl::encoding::TypeMarker for Country {
3174        type Owned = Self;
3175
3176        #[inline(always)]
3177        fn inline_align(_context: fidl::encoding::Context) -> usize {
3178            1
3179        }
3180
3181        #[inline(always)]
3182        fn inline_size(_context: fidl::encoding::Context) -> usize {
3183            3
3184        }
3185        #[inline(always)]
3186        fn encode_is_copy() -> bool {
3187            true
3188        }
3189
3190        #[inline(always)]
3191        fn decode_is_copy() -> bool {
3192            true
3193        }
3194    }
3195
3196    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Country, D> for &Country {
3197        #[inline]
3198        unsafe fn encode(
3199            self,
3200            encoder: &mut fidl::encoding::Encoder<'_, D>,
3201            offset: usize,
3202            _depth: fidl::encoding::Depth,
3203        ) -> fidl::Result<()> {
3204            encoder.debug_check_bounds::<Country>(offset);
3205            unsafe {
3206                // Copy the object into the buffer.
3207                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3208                (buf_ptr as *mut Country).write_unaligned((self as *const Country).read());
3209                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
3210                // done second because the memcpy will write garbage to these bytes.
3211            }
3212            Ok(())
3213        }
3214    }
3215    unsafe impl<
3216        D: fidl::encoding::ResourceDialect,
3217        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 2>, D>,
3218        T1: fidl::encoding::Encode<u8, D>,
3219    > fidl::encoding::Encode<Country, D> for (T0, T1)
3220    {
3221        #[inline]
3222        unsafe fn encode(
3223            self,
3224            encoder: &mut fidl::encoding::Encoder<'_, D>,
3225            offset: usize,
3226            depth: fidl::encoding::Depth,
3227        ) -> fidl::Result<()> {
3228            encoder.debug_check_bounds::<Country>(offset);
3229            // Zero out padding regions. There's no need to apply masks
3230            // because the unmasked parts will be overwritten by fields.
3231            // Write the fields.
3232            self.0.encode(encoder, offset + 0, depth)?;
3233            self.1.encode(encoder, offset + 2, depth)?;
3234            Ok(())
3235        }
3236    }
3237
3238    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Country {
3239        #[inline(always)]
3240        fn new_empty() -> Self {
3241            Self {
3242                alpha2: fidl::new_empty!(fidl::encoding::Array<u8, 2>, D),
3243                suffix: fidl::new_empty!(u8, D),
3244            }
3245        }
3246
3247        #[inline]
3248        unsafe fn decode(
3249            &mut self,
3250            decoder: &mut fidl::encoding::Decoder<'_, D>,
3251            offset: usize,
3252            _depth: fidl::encoding::Depth,
3253        ) -> fidl::Result<()> {
3254            decoder.debug_check_bounds::<Self>(offset);
3255            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3256            // Verify that padding bytes are zero.
3257            // Copy from the buffer into the object.
3258            unsafe {
3259                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 3);
3260            }
3261            Ok(())
3262        }
3263    }
3264
3265    impl fidl::encoding::ValueTypeMarker for DeauthenticateConfirm {
3266        type Borrowed<'a> = &'a Self;
3267        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3268            value
3269        }
3270    }
3271
3272    unsafe impl fidl::encoding::TypeMarker for DeauthenticateConfirm {
3273        type Owned = Self;
3274
3275        #[inline(always)]
3276        fn inline_align(_context: fidl::encoding::Context) -> usize {
3277            1
3278        }
3279
3280        #[inline(always)]
3281        fn inline_size(_context: fidl::encoding::Context) -> usize {
3282            6
3283        }
3284        #[inline(always)]
3285        fn encode_is_copy() -> bool {
3286            true
3287        }
3288
3289        #[inline(always)]
3290        fn decode_is_copy() -> bool {
3291            true
3292        }
3293    }
3294
3295    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeauthenticateConfirm, D>
3296        for &DeauthenticateConfirm
3297    {
3298        #[inline]
3299        unsafe fn encode(
3300            self,
3301            encoder: &mut fidl::encoding::Encoder<'_, D>,
3302            offset: usize,
3303            _depth: fidl::encoding::Depth,
3304        ) -> fidl::Result<()> {
3305            encoder.debug_check_bounds::<DeauthenticateConfirm>(offset);
3306            unsafe {
3307                // Copy the object into the buffer.
3308                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3309                (buf_ptr as *mut DeauthenticateConfirm)
3310                    .write_unaligned((self as *const DeauthenticateConfirm).read());
3311                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
3312                // done second because the memcpy will write garbage to these bytes.
3313            }
3314            Ok(())
3315        }
3316    }
3317    unsafe impl<
3318        D: fidl::encoding::ResourceDialect,
3319        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
3320    > fidl::encoding::Encode<DeauthenticateConfirm, D> for (T0,)
3321    {
3322        #[inline]
3323        unsafe fn encode(
3324            self,
3325            encoder: &mut fidl::encoding::Encoder<'_, D>,
3326            offset: usize,
3327            depth: fidl::encoding::Depth,
3328        ) -> fidl::Result<()> {
3329            encoder.debug_check_bounds::<DeauthenticateConfirm>(offset);
3330            // Zero out padding regions. There's no need to apply masks
3331            // because the unmasked parts will be overwritten by fields.
3332            // Write the fields.
3333            self.0.encode(encoder, offset + 0, depth)?;
3334            Ok(())
3335        }
3336    }
3337
3338    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeauthenticateConfirm {
3339        #[inline(always)]
3340        fn new_empty() -> Self {
3341            Self { peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D) }
3342        }
3343
3344        #[inline]
3345        unsafe fn decode(
3346            &mut self,
3347            decoder: &mut fidl::encoding::Decoder<'_, D>,
3348            offset: usize,
3349            _depth: fidl::encoding::Depth,
3350        ) -> fidl::Result<()> {
3351            decoder.debug_check_bounds::<Self>(offset);
3352            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3353            // Verify that padding bytes are zero.
3354            // Copy from the buffer into the object.
3355            unsafe {
3356                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 6);
3357            }
3358            Ok(())
3359        }
3360    }
3361
3362    impl fidl::encoding::ValueTypeMarker for DeauthenticateIndication {
3363        type Borrowed<'a> = &'a Self;
3364        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3365            value
3366        }
3367    }
3368
3369    unsafe impl fidl::encoding::TypeMarker for DeauthenticateIndication {
3370        type Owned = Self;
3371
3372        #[inline(always)]
3373        fn inline_align(_context: fidl::encoding::Context) -> usize {
3374            2
3375        }
3376
3377        #[inline(always)]
3378        fn inline_size(_context: fidl::encoding::Context) -> usize {
3379            10
3380        }
3381    }
3382
3383    unsafe impl<D: fidl::encoding::ResourceDialect>
3384        fidl::encoding::Encode<DeauthenticateIndication, D> for &DeauthenticateIndication
3385    {
3386        #[inline]
3387        unsafe fn encode(
3388            self,
3389            encoder: &mut fidl::encoding::Encoder<'_, D>,
3390            offset: usize,
3391            _depth: fidl::encoding::Depth,
3392        ) -> fidl::Result<()> {
3393            encoder.debug_check_bounds::<DeauthenticateIndication>(offset);
3394            // Delegate to tuple encoding.
3395            fidl::encoding::Encode::<DeauthenticateIndication, D>::encode(
3396                (
3397                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
3398                    <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow(&self.reason_code),
3399                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.locally_initiated),
3400                ),
3401                encoder, offset, _depth
3402            )
3403        }
3404    }
3405    unsafe impl<
3406        D: fidl::encoding::ResourceDialect,
3407        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
3408        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>,
3409        T2: fidl::encoding::Encode<bool, D>,
3410    > fidl::encoding::Encode<DeauthenticateIndication, D> for (T0, T1, T2)
3411    {
3412        #[inline]
3413        unsafe fn encode(
3414            self,
3415            encoder: &mut fidl::encoding::Encoder<'_, D>,
3416            offset: usize,
3417            depth: fidl::encoding::Depth,
3418        ) -> fidl::Result<()> {
3419            encoder.debug_check_bounds::<DeauthenticateIndication>(offset);
3420            // Zero out padding regions. There's no need to apply masks
3421            // because the unmasked parts will be overwritten by fields.
3422            unsafe {
3423                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
3424                (ptr as *mut u16).write_unaligned(0);
3425            }
3426            // Write the fields.
3427            self.0.encode(encoder, offset + 0, depth)?;
3428            self.1.encode(encoder, offset + 6, depth)?;
3429            self.2.encode(encoder, offset + 8, depth)?;
3430            Ok(())
3431        }
3432    }
3433
3434    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3435        for DeauthenticateIndication
3436    {
3437        #[inline(always)]
3438        fn new_empty() -> Self {
3439            Self {
3440                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
3441                reason_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D),
3442                locally_initiated: fidl::new_empty!(bool, D),
3443            }
3444        }
3445
3446        #[inline]
3447        unsafe fn decode(
3448            &mut self,
3449            decoder: &mut fidl::encoding::Decoder<'_, D>,
3450            offset: usize,
3451            _depth: fidl::encoding::Depth,
3452        ) -> fidl::Result<()> {
3453            decoder.debug_check_bounds::<Self>(offset);
3454            // Verify that padding bytes are zero.
3455            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
3456            let padval = unsafe { (ptr as *const u16).read_unaligned() };
3457            let mask = 0xff00u16;
3458            let maskedval = padval & mask;
3459            if maskedval != 0 {
3460                return Err(fidl::Error::NonZeroPadding {
3461                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
3462                });
3463            }
3464            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
3465            fidl::decode!(
3466                fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
3467                D,
3468                &mut self.reason_code,
3469                decoder,
3470                offset + 6,
3471                _depth
3472            )?;
3473            fidl::decode!(bool, D, &mut self.locally_initiated, decoder, offset + 8, _depth)?;
3474            Ok(())
3475        }
3476    }
3477
3478    impl fidl::encoding::ValueTypeMarker for DeauthenticateRequest {
3479        type Borrowed<'a> = &'a Self;
3480        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3481            value
3482        }
3483    }
3484
3485    unsafe impl fidl::encoding::TypeMarker for DeauthenticateRequest {
3486        type Owned = Self;
3487
3488        #[inline(always)]
3489        fn inline_align(_context: fidl::encoding::Context) -> usize {
3490            2
3491        }
3492
3493        #[inline(always)]
3494        fn inline_size(_context: fidl::encoding::Context) -> usize {
3495            8
3496        }
3497    }
3498
3499    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeauthenticateRequest, D>
3500        for &DeauthenticateRequest
3501    {
3502        #[inline]
3503        unsafe fn encode(
3504            self,
3505            encoder: &mut fidl::encoding::Encoder<'_, D>,
3506            offset: usize,
3507            _depth: fidl::encoding::Depth,
3508        ) -> fidl::Result<()> {
3509            encoder.debug_check_bounds::<DeauthenticateRequest>(offset);
3510            // Delegate to tuple encoding.
3511            fidl::encoding::Encode::<DeauthenticateRequest, D>::encode(
3512                (
3513                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
3514                    <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow(&self.reason_code),
3515                ),
3516                encoder, offset, _depth
3517            )
3518        }
3519    }
3520    unsafe impl<
3521        D: fidl::encoding::ResourceDialect,
3522        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
3523        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>,
3524    > fidl::encoding::Encode<DeauthenticateRequest, D> for (T0, T1)
3525    {
3526        #[inline]
3527        unsafe fn encode(
3528            self,
3529            encoder: &mut fidl::encoding::Encoder<'_, D>,
3530            offset: usize,
3531            depth: fidl::encoding::Depth,
3532        ) -> fidl::Result<()> {
3533            encoder.debug_check_bounds::<DeauthenticateRequest>(offset);
3534            // Zero out padding regions. There's no need to apply masks
3535            // because the unmasked parts will be overwritten by fields.
3536            // Write the fields.
3537            self.0.encode(encoder, offset + 0, depth)?;
3538            self.1.encode(encoder, offset + 6, depth)?;
3539            Ok(())
3540        }
3541    }
3542
3543    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeauthenticateRequest {
3544        #[inline(always)]
3545        fn new_empty() -> Self {
3546            Self {
3547                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
3548                reason_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D),
3549            }
3550        }
3551
3552        #[inline]
3553        unsafe fn decode(
3554            &mut self,
3555            decoder: &mut fidl::encoding::Decoder<'_, D>,
3556            offset: usize,
3557            _depth: fidl::encoding::Depth,
3558        ) -> fidl::Result<()> {
3559            decoder.debug_check_bounds::<Self>(offset);
3560            // Verify that padding bytes are zero.
3561            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
3562            fidl::decode!(
3563                fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
3564                D,
3565                &mut self.reason_code,
3566                decoder,
3567                offset + 6,
3568                _depth
3569            )?;
3570            Ok(())
3571        }
3572    }
3573
3574    impl fidl::encoding::ValueTypeMarker for DeleteKeyDescriptor {
3575        type Borrowed<'a> = &'a Self;
3576        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3577            value
3578        }
3579    }
3580
3581    unsafe impl fidl::encoding::TypeMarker for DeleteKeyDescriptor {
3582        type Owned = Self;
3583
3584        #[inline(always)]
3585        fn inline_align(_context: fidl::encoding::Context) -> usize {
3586            4
3587        }
3588
3589        #[inline(always)]
3590        fn inline_size(_context: fidl::encoding::Context) -> usize {
3591            16
3592        }
3593    }
3594
3595    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeleteKeyDescriptor, D>
3596        for &DeleteKeyDescriptor
3597    {
3598        #[inline]
3599        unsafe fn encode(
3600            self,
3601            encoder: &mut fidl::encoding::Encoder<'_, D>,
3602            offset: usize,
3603            _depth: fidl::encoding::Depth,
3604        ) -> fidl::Result<()> {
3605            encoder.debug_check_bounds::<DeleteKeyDescriptor>(offset);
3606            // Delegate to tuple encoding.
3607            fidl::encoding::Encode::<DeleteKeyDescriptor, D>::encode(
3608                (
3609                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.key_id),
3610                    <KeyType as fidl::encoding::ValueTypeMarker>::borrow(&self.key_type),
3611                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
3612                        &self.address,
3613                    ),
3614                ),
3615                encoder,
3616                offset,
3617                _depth,
3618            )
3619        }
3620    }
3621    unsafe impl<
3622        D: fidl::encoding::ResourceDialect,
3623        T0: fidl::encoding::Encode<u16, D>,
3624        T1: fidl::encoding::Encode<KeyType, D>,
3625        T2: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
3626    > fidl::encoding::Encode<DeleteKeyDescriptor, D> for (T0, T1, T2)
3627    {
3628        #[inline]
3629        unsafe fn encode(
3630            self,
3631            encoder: &mut fidl::encoding::Encoder<'_, D>,
3632            offset: usize,
3633            depth: fidl::encoding::Depth,
3634        ) -> fidl::Result<()> {
3635            encoder.debug_check_bounds::<DeleteKeyDescriptor>(offset);
3636            // Zero out padding regions. There's no need to apply masks
3637            // because the unmasked parts will be overwritten by fields.
3638            unsafe {
3639                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3640                (ptr as *mut u32).write_unaligned(0);
3641            }
3642            unsafe {
3643                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(12);
3644                (ptr as *mut u32).write_unaligned(0);
3645            }
3646            // Write the fields.
3647            self.0.encode(encoder, offset + 0, depth)?;
3648            self.1.encode(encoder, offset + 4, depth)?;
3649            self.2.encode(encoder, offset + 8, depth)?;
3650            Ok(())
3651        }
3652    }
3653
3654    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeleteKeyDescriptor {
3655        #[inline(always)]
3656        fn new_empty() -> Self {
3657            Self {
3658                key_id: fidl::new_empty!(u16, D),
3659                key_type: fidl::new_empty!(KeyType, D),
3660                address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
3661            }
3662        }
3663
3664        #[inline]
3665        unsafe fn decode(
3666            &mut self,
3667            decoder: &mut fidl::encoding::Decoder<'_, D>,
3668            offset: usize,
3669            _depth: fidl::encoding::Depth,
3670        ) -> fidl::Result<()> {
3671            decoder.debug_check_bounds::<Self>(offset);
3672            // Verify that padding bytes are zero.
3673            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3674            let padval = unsafe { (ptr as *const u32).read_unaligned() };
3675            let mask = 0xffff0000u32;
3676            let maskedval = padval & mask;
3677            if maskedval != 0 {
3678                return Err(fidl::Error::NonZeroPadding {
3679                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3680                });
3681            }
3682            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(12) };
3683            let padval = unsafe { (ptr as *const u32).read_unaligned() };
3684            let mask = 0xffff0000u32;
3685            let maskedval = padval & mask;
3686            if maskedval != 0 {
3687                return Err(fidl::Error::NonZeroPadding {
3688                    padding_start: offset + 12 + ((mask as u64).trailing_zeros() / 8) as usize,
3689                });
3690            }
3691            fidl::decode!(u16, D, &mut self.key_id, decoder, offset + 0, _depth)?;
3692            fidl::decode!(KeyType, D, &mut self.key_type, decoder, offset + 4, _depth)?;
3693            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.address, decoder, offset + 8, _depth)?;
3694            Ok(())
3695        }
3696    }
3697
3698    impl fidl::encoding::ValueTypeMarker for DeleteKeysRequest {
3699        type Borrowed<'a> = &'a Self;
3700        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3701            value
3702        }
3703    }
3704
3705    unsafe impl fidl::encoding::TypeMarker for DeleteKeysRequest {
3706        type Owned = Self;
3707
3708        #[inline(always)]
3709        fn inline_align(_context: fidl::encoding::Context) -> usize {
3710            8
3711        }
3712
3713        #[inline(always)]
3714        fn inline_size(_context: fidl::encoding::Context) -> usize {
3715            16
3716        }
3717    }
3718
3719    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeleteKeysRequest, D>
3720        for &DeleteKeysRequest
3721    {
3722        #[inline]
3723        unsafe fn encode(
3724            self,
3725            encoder: &mut fidl::encoding::Encoder<'_, D>,
3726            offset: usize,
3727            _depth: fidl::encoding::Depth,
3728        ) -> fidl::Result<()> {
3729            encoder.debug_check_bounds::<DeleteKeysRequest>(offset);
3730            // Delegate to tuple encoding.
3731            fidl::encoding::Encode::<DeleteKeysRequest, D>::encode(
3732                (
3733                    <fidl::encoding::UnboundedVector<DeleteKeyDescriptor> as fidl::encoding::ValueTypeMarker>::borrow(&self.keylist),
3734                ),
3735                encoder, offset, _depth
3736            )
3737        }
3738    }
3739    unsafe impl<
3740        D: fidl::encoding::ResourceDialect,
3741        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<DeleteKeyDescriptor>, D>,
3742    > fidl::encoding::Encode<DeleteKeysRequest, D> for (T0,)
3743    {
3744        #[inline]
3745        unsafe fn encode(
3746            self,
3747            encoder: &mut fidl::encoding::Encoder<'_, D>,
3748            offset: usize,
3749            depth: fidl::encoding::Depth,
3750        ) -> fidl::Result<()> {
3751            encoder.debug_check_bounds::<DeleteKeysRequest>(offset);
3752            // Zero out padding regions. There's no need to apply masks
3753            // because the unmasked parts will be overwritten by fields.
3754            // Write the fields.
3755            self.0.encode(encoder, offset + 0, depth)?;
3756            Ok(())
3757        }
3758    }
3759
3760    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeleteKeysRequest {
3761        #[inline(always)]
3762        fn new_empty() -> Self {
3763            Self {
3764                keylist: fidl::new_empty!(fidl::encoding::UnboundedVector<DeleteKeyDescriptor>, D),
3765            }
3766        }
3767
3768        #[inline]
3769        unsafe fn decode(
3770            &mut self,
3771            decoder: &mut fidl::encoding::Decoder<'_, D>,
3772            offset: usize,
3773            _depth: fidl::encoding::Depth,
3774        ) -> fidl::Result<()> {
3775            decoder.debug_check_bounds::<Self>(offset);
3776            // Verify that padding bytes are zero.
3777            fidl::decode!(
3778                fidl::encoding::UnboundedVector<DeleteKeyDescriptor>,
3779                D,
3780                &mut self.keylist,
3781                decoder,
3782                offset + 0,
3783                _depth
3784            )?;
3785            Ok(())
3786        }
3787    }
3788
3789    impl fidl::encoding::ValueTypeMarker for DeviceInfo {
3790        type Borrowed<'a> = &'a Self;
3791        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3792            value
3793        }
3794    }
3795
3796    unsafe impl fidl::encoding::TypeMarker for DeviceInfo {
3797        type Owned = Self;
3798
3799        #[inline(always)]
3800        fn inline_align(_context: fidl::encoding::Context) -> usize {
3801            8
3802        }
3803
3804        #[inline(always)]
3805        fn inline_size(_context: fidl::encoding::Context) -> usize {
3806            40
3807        }
3808    }
3809
3810    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceInfo, D>
3811        for &DeviceInfo
3812    {
3813        #[inline]
3814        unsafe fn encode(
3815            self,
3816            encoder: &mut fidl::encoding::Encoder<'_, D>,
3817            offset: usize,
3818            _depth: fidl::encoding::Depth,
3819        ) -> fidl::Result<()> {
3820            encoder.debug_check_bounds::<DeviceInfo>(offset);
3821            // Delegate to tuple encoding.
3822            fidl::encoding::Encode::<DeviceInfo, D>::encode(
3823                (
3824                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.sta_addr),
3825                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.factory_addr),
3826                    <fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::ValueTypeMarker>::borrow(&self.role),
3827                    <fidl::encoding::Vector<BandCapability, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.bands),
3828                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.softmac_hardware_capability),
3829                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.qos_capable),
3830                ),
3831                encoder, offset, _depth
3832            )
3833        }
3834    }
3835    unsafe impl<
3836        D: fidl::encoding::ResourceDialect,
3837        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
3838        T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
3839        T2: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::WlanMacRole, D>,
3840        T3: fidl::encoding::Encode<fidl::encoding::Vector<BandCapability, 16>, D>,
3841        T4: fidl::encoding::Encode<u32, D>,
3842        T5: fidl::encoding::Encode<bool, D>,
3843    > fidl::encoding::Encode<DeviceInfo, D> for (T0, T1, T2, T3, T4, T5)
3844    {
3845        #[inline]
3846        unsafe fn encode(
3847            self,
3848            encoder: &mut fidl::encoding::Encoder<'_, D>,
3849            offset: usize,
3850            depth: fidl::encoding::Depth,
3851        ) -> fidl::Result<()> {
3852            encoder.debug_check_bounds::<DeviceInfo>(offset);
3853            // Zero out padding regions. There's no need to apply masks
3854            // because the unmasked parts will be overwritten by fields.
3855            unsafe {
3856                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
3857                (ptr as *mut u64).write_unaligned(0);
3858            }
3859            // Write the fields.
3860            self.0.encode(encoder, offset + 0, depth)?;
3861            self.1.encode(encoder, offset + 6, depth)?;
3862            self.2.encode(encoder, offset + 12, depth)?;
3863            self.3.encode(encoder, offset + 16, depth)?;
3864            self.4.encode(encoder, offset + 32, depth)?;
3865            self.5.encode(encoder, offset + 36, depth)?;
3866            Ok(())
3867        }
3868    }
3869
3870    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceInfo {
3871        #[inline(always)]
3872        fn new_empty() -> Self {
3873            Self {
3874                sta_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
3875                factory_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
3876                role: fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanMacRole, D),
3877                bands: fidl::new_empty!(fidl::encoding::Vector<BandCapability, 16>, D),
3878                softmac_hardware_capability: fidl::new_empty!(u32, D),
3879                qos_capable: fidl::new_empty!(bool, D),
3880            }
3881        }
3882
3883        #[inline]
3884        unsafe fn decode(
3885            &mut self,
3886            decoder: &mut fidl::encoding::Decoder<'_, D>,
3887            offset: usize,
3888            _depth: fidl::encoding::Depth,
3889        ) -> fidl::Result<()> {
3890            decoder.debug_check_bounds::<Self>(offset);
3891            // Verify that padding bytes are zero.
3892            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
3893            let padval = unsafe { (ptr as *const u64).read_unaligned() };
3894            let mask = 0xffffff0000000000u64;
3895            let maskedval = padval & mask;
3896            if maskedval != 0 {
3897                return Err(fidl::Error::NonZeroPadding {
3898                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
3899                });
3900            }
3901            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.sta_addr, decoder, offset + 0, _depth)?;
3902            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.factory_addr, decoder, offset + 6, _depth)?;
3903            fidl::decode!(
3904                fidl_fuchsia_wlan_common__common::WlanMacRole,
3905                D,
3906                &mut self.role,
3907                decoder,
3908                offset + 12,
3909                _depth
3910            )?;
3911            fidl::decode!(fidl::encoding::Vector<BandCapability, 16>, D, &mut self.bands, decoder, offset + 16, _depth)?;
3912            fidl::decode!(
3913                u32,
3914                D,
3915                &mut self.softmac_hardware_capability,
3916                decoder,
3917                offset + 32,
3918                _depth
3919            )?;
3920            fidl::decode!(bool, D, &mut self.qos_capable, decoder, offset + 36, _depth)?;
3921            Ok(())
3922        }
3923    }
3924
3925    impl fidl::encoding::ValueTypeMarker for DisassociateConfirm {
3926        type Borrowed<'a> = &'a Self;
3927        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3928            value
3929        }
3930    }
3931
3932    unsafe impl fidl::encoding::TypeMarker for DisassociateConfirm {
3933        type Owned = Self;
3934
3935        #[inline(always)]
3936        fn inline_align(_context: fidl::encoding::Context) -> usize {
3937            4
3938        }
3939
3940        #[inline(always)]
3941        fn inline_size(_context: fidl::encoding::Context) -> usize {
3942            4
3943        }
3944        #[inline(always)]
3945        fn encode_is_copy() -> bool {
3946            true
3947        }
3948
3949        #[inline(always)]
3950        fn decode_is_copy() -> bool {
3951            true
3952        }
3953    }
3954
3955    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DisassociateConfirm, D>
3956        for &DisassociateConfirm
3957    {
3958        #[inline]
3959        unsafe fn encode(
3960            self,
3961            encoder: &mut fidl::encoding::Encoder<'_, D>,
3962            offset: usize,
3963            _depth: fidl::encoding::Depth,
3964        ) -> fidl::Result<()> {
3965            encoder.debug_check_bounds::<DisassociateConfirm>(offset);
3966            unsafe {
3967                // Copy the object into the buffer.
3968                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3969                (buf_ptr as *mut DisassociateConfirm)
3970                    .write_unaligned((self as *const DisassociateConfirm).read());
3971                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
3972                // done second because the memcpy will write garbage to these bytes.
3973            }
3974            Ok(())
3975        }
3976    }
3977    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
3978        fidl::encoding::Encode<DisassociateConfirm, D> for (T0,)
3979    {
3980        #[inline]
3981        unsafe fn encode(
3982            self,
3983            encoder: &mut fidl::encoding::Encoder<'_, D>,
3984            offset: usize,
3985            depth: fidl::encoding::Depth,
3986        ) -> fidl::Result<()> {
3987            encoder.debug_check_bounds::<DisassociateConfirm>(offset);
3988            // Zero out padding regions. There's no need to apply masks
3989            // because the unmasked parts will be overwritten by fields.
3990            // Write the fields.
3991            self.0.encode(encoder, offset + 0, depth)?;
3992            Ok(())
3993        }
3994    }
3995
3996    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DisassociateConfirm {
3997        #[inline(always)]
3998        fn new_empty() -> Self {
3999            Self { status: fidl::new_empty!(i32, D) }
4000        }
4001
4002        #[inline]
4003        unsafe fn decode(
4004            &mut self,
4005            decoder: &mut fidl::encoding::Decoder<'_, D>,
4006            offset: usize,
4007            _depth: fidl::encoding::Depth,
4008        ) -> fidl::Result<()> {
4009            decoder.debug_check_bounds::<Self>(offset);
4010            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
4011            // Verify that padding bytes are zero.
4012            // Copy from the buffer into the object.
4013            unsafe {
4014                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
4015            }
4016            Ok(())
4017        }
4018    }
4019
4020    impl fidl::encoding::ValueTypeMarker for DisassociateIndication {
4021        type Borrowed<'a> = &'a Self;
4022        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4023            value
4024        }
4025    }
4026
4027    unsafe impl fidl::encoding::TypeMarker for DisassociateIndication {
4028        type Owned = Self;
4029
4030        #[inline(always)]
4031        fn inline_align(_context: fidl::encoding::Context) -> usize {
4032            2
4033        }
4034
4035        #[inline(always)]
4036        fn inline_size(_context: fidl::encoding::Context) -> usize {
4037            10
4038        }
4039    }
4040
4041    unsafe impl<D: fidl::encoding::ResourceDialect>
4042        fidl::encoding::Encode<DisassociateIndication, D> for &DisassociateIndication
4043    {
4044        #[inline]
4045        unsafe fn encode(
4046            self,
4047            encoder: &mut fidl::encoding::Encoder<'_, D>,
4048            offset: usize,
4049            _depth: fidl::encoding::Depth,
4050        ) -> fidl::Result<()> {
4051            encoder.debug_check_bounds::<DisassociateIndication>(offset);
4052            // Delegate to tuple encoding.
4053            fidl::encoding::Encode::<DisassociateIndication, D>::encode(
4054                (
4055                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
4056                    <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow(&self.reason_code),
4057                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.locally_initiated),
4058                ),
4059                encoder, offset, _depth
4060            )
4061        }
4062    }
4063    unsafe impl<
4064        D: fidl::encoding::ResourceDialect,
4065        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
4066        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>,
4067        T2: fidl::encoding::Encode<bool, D>,
4068    > fidl::encoding::Encode<DisassociateIndication, D> for (T0, T1, T2)
4069    {
4070        #[inline]
4071        unsafe fn encode(
4072            self,
4073            encoder: &mut fidl::encoding::Encoder<'_, D>,
4074            offset: usize,
4075            depth: fidl::encoding::Depth,
4076        ) -> fidl::Result<()> {
4077            encoder.debug_check_bounds::<DisassociateIndication>(offset);
4078            // Zero out padding regions. There's no need to apply masks
4079            // because the unmasked parts will be overwritten by fields.
4080            unsafe {
4081                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
4082                (ptr as *mut u16).write_unaligned(0);
4083            }
4084            // Write the fields.
4085            self.0.encode(encoder, offset + 0, depth)?;
4086            self.1.encode(encoder, offset + 6, depth)?;
4087            self.2.encode(encoder, offset + 8, depth)?;
4088            Ok(())
4089        }
4090    }
4091
4092    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4093        for DisassociateIndication
4094    {
4095        #[inline(always)]
4096        fn new_empty() -> Self {
4097            Self {
4098                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
4099                reason_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D),
4100                locally_initiated: fidl::new_empty!(bool, D),
4101            }
4102        }
4103
4104        #[inline]
4105        unsafe fn decode(
4106            &mut self,
4107            decoder: &mut fidl::encoding::Decoder<'_, D>,
4108            offset: usize,
4109            _depth: fidl::encoding::Depth,
4110        ) -> fidl::Result<()> {
4111            decoder.debug_check_bounds::<Self>(offset);
4112            // Verify that padding bytes are zero.
4113            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
4114            let padval = unsafe { (ptr as *const u16).read_unaligned() };
4115            let mask = 0xff00u16;
4116            let maskedval = padval & mask;
4117            if maskedval != 0 {
4118                return Err(fidl::Error::NonZeroPadding {
4119                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
4120                });
4121            }
4122            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
4123            fidl::decode!(
4124                fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
4125                D,
4126                &mut self.reason_code,
4127                decoder,
4128                offset + 6,
4129                _depth
4130            )?;
4131            fidl::decode!(bool, D, &mut self.locally_initiated, decoder, offset + 8, _depth)?;
4132            Ok(())
4133        }
4134    }
4135
4136    impl fidl::encoding::ValueTypeMarker for DisassociateRequest {
4137        type Borrowed<'a> = &'a Self;
4138        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4139            value
4140        }
4141    }
4142
4143    unsafe impl fidl::encoding::TypeMarker for DisassociateRequest {
4144        type Owned = Self;
4145
4146        #[inline(always)]
4147        fn inline_align(_context: fidl::encoding::Context) -> usize {
4148            2
4149        }
4150
4151        #[inline(always)]
4152        fn inline_size(_context: fidl::encoding::Context) -> usize {
4153            8
4154        }
4155    }
4156
4157    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DisassociateRequest, D>
4158        for &DisassociateRequest
4159    {
4160        #[inline]
4161        unsafe fn encode(
4162            self,
4163            encoder: &mut fidl::encoding::Encoder<'_, D>,
4164            offset: usize,
4165            _depth: fidl::encoding::Depth,
4166        ) -> fidl::Result<()> {
4167            encoder.debug_check_bounds::<DisassociateRequest>(offset);
4168            // Delegate to tuple encoding.
4169            fidl::encoding::Encode::<DisassociateRequest, D>::encode(
4170                (
4171                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
4172                    <fidl_fuchsia_wlan_ieee80211__common::ReasonCode as fidl::encoding::ValueTypeMarker>::borrow(&self.reason_code),
4173                ),
4174                encoder, offset, _depth
4175            )
4176        }
4177    }
4178    unsafe impl<
4179        D: fidl::encoding::ResourceDialect,
4180        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
4181        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D>,
4182    > fidl::encoding::Encode<DisassociateRequest, D> for (T0, T1)
4183    {
4184        #[inline]
4185        unsafe fn encode(
4186            self,
4187            encoder: &mut fidl::encoding::Encoder<'_, D>,
4188            offset: usize,
4189            depth: fidl::encoding::Depth,
4190        ) -> fidl::Result<()> {
4191            encoder.debug_check_bounds::<DisassociateRequest>(offset);
4192            // Zero out padding regions. There's no need to apply masks
4193            // because the unmasked parts will be overwritten by fields.
4194            // Write the fields.
4195            self.0.encode(encoder, offset + 0, depth)?;
4196            self.1.encode(encoder, offset + 6, depth)?;
4197            Ok(())
4198        }
4199    }
4200
4201    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DisassociateRequest {
4202        #[inline(always)]
4203        fn new_empty() -> Self {
4204            Self {
4205                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
4206                reason_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::ReasonCode, D),
4207            }
4208        }
4209
4210        #[inline]
4211        unsafe fn decode(
4212            &mut self,
4213            decoder: &mut fidl::encoding::Decoder<'_, D>,
4214            offset: usize,
4215            _depth: fidl::encoding::Depth,
4216        ) -> fidl::Result<()> {
4217            decoder.debug_check_bounds::<Self>(offset);
4218            // Verify that padding bytes are zero.
4219            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
4220            fidl::decode!(
4221                fidl_fuchsia_wlan_ieee80211__common::ReasonCode,
4222                D,
4223                &mut self.reason_code,
4224                decoder,
4225                offset + 6,
4226                _depth
4227            )?;
4228            Ok(())
4229        }
4230    }
4231
4232    impl fidl::encoding::ValueTypeMarker for EapolConfirm {
4233        type Borrowed<'a> = &'a Self;
4234        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4235            value
4236        }
4237    }
4238
4239    unsafe impl fidl::encoding::TypeMarker for EapolConfirm {
4240        type Owned = Self;
4241
4242        #[inline(always)]
4243        fn inline_align(_context: fidl::encoding::Context) -> usize {
4244            4
4245        }
4246
4247        #[inline(always)]
4248        fn inline_size(_context: fidl::encoding::Context) -> usize {
4249            12
4250        }
4251    }
4252
4253    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EapolConfirm, D>
4254        for &EapolConfirm
4255    {
4256        #[inline]
4257        unsafe fn encode(
4258            self,
4259            encoder: &mut fidl::encoding::Encoder<'_, D>,
4260            offset: usize,
4261            _depth: fidl::encoding::Depth,
4262        ) -> fidl::Result<()> {
4263            encoder.debug_check_bounds::<EapolConfirm>(offset);
4264            // Delegate to tuple encoding.
4265            fidl::encoding::Encode::<EapolConfirm, D>::encode(
4266                (
4267                    <EapolResultCode as fidl::encoding::ValueTypeMarker>::borrow(&self.result_code),
4268                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
4269                        &self.dst_addr,
4270                    ),
4271                ),
4272                encoder,
4273                offset,
4274                _depth,
4275            )
4276        }
4277    }
4278    unsafe impl<
4279        D: fidl::encoding::ResourceDialect,
4280        T0: fidl::encoding::Encode<EapolResultCode, D>,
4281        T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
4282    > fidl::encoding::Encode<EapolConfirm, D> for (T0, T1)
4283    {
4284        #[inline]
4285        unsafe fn encode(
4286            self,
4287            encoder: &mut fidl::encoding::Encoder<'_, D>,
4288            offset: usize,
4289            depth: fidl::encoding::Depth,
4290        ) -> fidl::Result<()> {
4291            encoder.debug_check_bounds::<EapolConfirm>(offset);
4292            // Zero out padding regions. There's no need to apply masks
4293            // because the unmasked parts will be overwritten by fields.
4294            unsafe {
4295                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
4296                (ptr as *mut u32).write_unaligned(0);
4297            }
4298            // Write the fields.
4299            self.0.encode(encoder, offset + 0, depth)?;
4300            self.1.encode(encoder, offset + 4, depth)?;
4301            Ok(())
4302        }
4303    }
4304
4305    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EapolConfirm {
4306        #[inline(always)]
4307        fn new_empty() -> Self {
4308            Self {
4309                result_code: fidl::new_empty!(EapolResultCode, D),
4310                dst_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
4311            }
4312        }
4313
4314        #[inline]
4315        unsafe fn decode(
4316            &mut self,
4317            decoder: &mut fidl::encoding::Decoder<'_, D>,
4318            offset: usize,
4319            _depth: fidl::encoding::Depth,
4320        ) -> fidl::Result<()> {
4321            decoder.debug_check_bounds::<Self>(offset);
4322            // Verify that padding bytes are zero.
4323            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
4324            let padval = unsafe { (ptr as *const u32).read_unaligned() };
4325            let mask = 0xffff0000u32;
4326            let maskedval = padval & mask;
4327            if maskedval != 0 {
4328                return Err(fidl::Error::NonZeroPadding {
4329                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
4330                });
4331            }
4332            fidl::decode!(EapolResultCode, D, &mut self.result_code, decoder, offset + 0, _depth)?;
4333            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.dst_addr, decoder, offset + 4, _depth)?;
4334            Ok(())
4335        }
4336    }
4337
4338    impl fidl::encoding::ValueTypeMarker for EapolIndication {
4339        type Borrowed<'a> = &'a Self;
4340        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4341            value
4342        }
4343    }
4344
4345    unsafe impl fidl::encoding::TypeMarker for EapolIndication {
4346        type Owned = Self;
4347
4348        #[inline(always)]
4349        fn inline_align(_context: fidl::encoding::Context) -> usize {
4350            8
4351        }
4352
4353        #[inline(always)]
4354        fn inline_size(_context: fidl::encoding::Context) -> usize {
4355            32
4356        }
4357    }
4358
4359    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EapolIndication, D>
4360        for &EapolIndication
4361    {
4362        #[inline]
4363        unsafe fn encode(
4364            self,
4365            encoder: &mut fidl::encoding::Encoder<'_, D>,
4366            offset: usize,
4367            _depth: fidl::encoding::Depth,
4368        ) -> fidl::Result<()> {
4369            encoder.debug_check_bounds::<EapolIndication>(offset);
4370            // Delegate to tuple encoding.
4371            fidl::encoding::Encode::<EapolIndication, D>::encode(
4372                (
4373                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.src_addr),
4374                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.dst_addr),
4375                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
4376                ),
4377                encoder, offset, _depth
4378            )
4379        }
4380    }
4381    unsafe impl<
4382        D: fidl::encoding::ResourceDialect,
4383        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
4384        T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
4385        T2: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
4386    > fidl::encoding::Encode<EapolIndication, D> for (T0, T1, T2)
4387    {
4388        #[inline]
4389        unsafe fn encode(
4390            self,
4391            encoder: &mut fidl::encoding::Encoder<'_, D>,
4392            offset: usize,
4393            depth: fidl::encoding::Depth,
4394        ) -> fidl::Result<()> {
4395            encoder.debug_check_bounds::<EapolIndication>(offset);
4396            // Zero out padding regions. There's no need to apply masks
4397            // because the unmasked parts will be overwritten by fields.
4398            unsafe {
4399                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
4400                (ptr as *mut u64).write_unaligned(0);
4401            }
4402            // Write the fields.
4403            self.0.encode(encoder, offset + 0, depth)?;
4404            self.1.encode(encoder, offset + 6, depth)?;
4405            self.2.encode(encoder, offset + 16, depth)?;
4406            Ok(())
4407        }
4408    }
4409
4410    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EapolIndication {
4411        #[inline(always)]
4412        fn new_empty() -> Self {
4413            Self {
4414                src_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
4415                dst_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
4416                data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
4417            }
4418        }
4419
4420        #[inline]
4421        unsafe fn decode(
4422            &mut self,
4423            decoder: &mut fidl::encoding::Decoder<'_, D>,
4424            offset: usize,
4425            _depth: fidl::encoding::Depth,
4426        ) -> fidl::Result<()> {
4427            decoder.debug_check_bounds::<Self>(offset);
4428            // Verify that padding bytes are zero.
4429            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
4430            let padval = unsafe { (ptr as *const u64).read_unaligned() };
4431            let mask = 0xffffffff00000000u64;
4432            let maskedval = padval & mask;
4433            if maskedval != 0 {
4434                return Err(fidl::Error::NonZeroPadding {
4435                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
4436                });
4437            }
4438            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.src_addr, decoder, offset + 0, _depth)?;
4439            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.dst_addr, decoder, offset + 6, _depth)?;
4440            fidl::decode!(
4441                fidl::encoding::UnboundedVector<u8>,
4442                D,
4443                &mut self.data,
4444                decoder,
4445                offset + 16,
4446                _depth
4447            )?;
4448            Ok(())
4449        }
4450    }
4451
4452    impl fidl::encoding::ValueTypeMarker for EapolRequest {
4453        type Borrowed<'a> = &'a Self;
4454        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4455            value
4456        }
4457    }
4458
4459    unsafe impl fidl::encoding::TypeMarker for EapolRequest {
4460        type Owned = Self;
4461
4462        #[inline(always)]
4463        fn inline_align(_context: fidl::encoding::Context) -> usize {
4464            8
4465        }
4466
4467        #[inline(always)]
4468        fn inline_size(_context: fidl::encoding::Context) -> usize {
4469            32
4470        }
4471    }
4472
4473    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EapolRequest, D>
4474        for &EapolRequest
4475    {
4476        #[inline]
4477        unsafe fn encode(
4478            self,
4479            encoder: &mut fidl::encoding::Encoder<'_, D>,
4480            offset: usize,
4481            _depth: fidl::encoding::Depth,
4482        ) -> fidl::Result<()> {
4483            encoder.debug_check_bounds::<EapolRequest>(offset);
4484            // Delegate to tuple encoding.
4485            fidl::encoding::Encode::<EapolRequest, D>::encode(
4486                (
4487                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.src_addr),
4488                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.dst_addr),
4489                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
4490                ),
4491                encoder, offset, _depth
4492            )
4493        }
4494    }
4495    unsafe impl<
4496        D: fidl::encoding::ResourceDialect,
4497        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
4498        T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
4499        T2: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
4500    > fidl::encoding::Encode<EapolRequest, D> for (T0, T1, T2)
4501    {
4502        #[inline]
4503        unsafe fn encode(
4504            self,
4505            encoder: &mut fidl::encoding::Encoder<'_, D>,
4506            offset: usize,
4507            depth: fidl::encoding::Depth,
4508        ) -> fidl::Result<()> {
4509            encoder.debug_check_bounds::<EapolRequest>(offset);
4510            // Zero out padding regions. There's no need to apply masks
4511            // because the unmasked parts will be overwritten by fields.
4512            unsafe {
4513                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
4514                (ptr as *mut u64).write_unaligned(0);
4515            }
4516            // Write the fields.
4517            self.0.encode(encoder, offset + 0, depth)?;
4518            self.1.encode(encoder, offset + 6, depth)?;
4519            self.2.encode(encoder, offset + 16, depth)?;
4520            Ok(())
4521        }
4522    }
4523
4524    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EapolRequest {
4525        #[inline(always)]
4526        fn new_empty() -> Self {
4527            Self {
4528                src_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
4529                dst_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
4530                data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
4531            }
4532        }
4533
4534        #[inline]
4535        unsafe fn decode(
4536            &mut self,
4537            decoder: &mut fidl::encoding::Decoder<'_, D>,
4538            offset: usize,
4539            _depth: fidl::encoding::Depth,
4540        ) -> fidl::Result<()> {
4541            decoder.debug_check_bounds::<Self>(offset);
4542            // Verify that padding bytes are zero.
4543            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
4544            let padval = unsafe { (ptr as *const u64).read_unaligned() };
4545            let mask = 0xffffffff00000000u64;
4546            let maskedval = padval & mask;
4547            if maskedval != 0 {
4548                return Err(fidl::Error::NonZeroPadding {
4549                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
4550                });
4551            }
4552            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.src_addr, decoder, offset + 0, _depth)?;
4553            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.dst_addr, decoder, offset + 6, _depth)?;
4554            fidl::decode!(
4555                fidl::encoding::UnboundedVector<u8>,
4556                D,
4557                &mut self.data,
4558                decoder,
4559                offset + 16,
4560                _depth
4561            )?;
4562            Ok(())
4563        }
4564    }
4565
4566    impl fidl::encoding::ValueTypeMarker for MlmeGetApfPacketFilterEnabledResponse {
4567        type Borrowed<'a> = &'a Self;
4568        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4569            value
4570        }
4571    }
4572
4573    unsafe impl fidl::encoding::TypeMarker for MlmeGetApfPacketFilterEnabledResponse {
4574        type Owned = Self;
4575
4576        #[inline(always)]
4577        fn inline_align(_context: fidl::encoding::Context) -> usize {
4578            1
4579        }
4580
4581        #[inline(always)]
4582        fn inline_size(_context: fidl::encoding::Context) -> usize {
4583            1
4584        }
4585    }
4586
4587    unsafe impl<D: fidl::encoding::ResourceDialect>
4588        fidl::encoding::Encode<MlmeGetApfPacketFilterEnabledResponse, D>
4589        for &MlmeGetApfPacketFilterEnabledResponse
4590    {
4591        #[inline]
4592        unsafe fn encode(
4593            self,
4594            encoder: &mut fidl::encoding::Encoder<'_, D>,
4595            offset: usize,
4596            _depth: fidl::encoding::Depth,
4597        ) -> fidl::Result<()> {
4598            encoder.debug_check_bounds::<MlmeGetApfPacketFilterEnabledResponse>(offset);
4599            // Delegate to tuple encoding.
4600            fidl::encoding::Encode::<MlmeGetApfPacketFilterEnabledResponse, D>::encode(
4601                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enabled),),
4602                encoder,
4603                offset,
4604                _depth,
4605            )
4606        }
4607    }
4608    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
4609        fidl::encoding::Encode<MlmeGetApfPacketFilterEnabledResponse, D> for (T0,)
4610    {
4611        #[inline]
4612        unsafe fn encode(
4613            self,
4614            encoder: &mut fidl::encoding::Encoder<'_, D>,
4615            offset: usize,
4616            depth: fidl::encoding::Depth,
4617        ) -> fidl::Result<()> {
4618            encoder.debug_check_bounds::<MlmeGetApfPacketFilterEnabledResponse>(offset);
4619            // Zero out padding regions. There's no need to apply masks
4620            // because the unmasked parts will be overwritten by fields.
4621            // Write the fields.
4622            self.0.encode(encoder, offset + 0, depth)?;
4623            Ok(())
4624        }
4625    }
4626
4627    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4628        for MlmeGetApfPacketFilterEnabledResponse
4629    {
4630        #[inline(always)]
4631        fn new_empty() -> Self {
4632            Self { enabled: fidl::new_empty!(bool, D) }
4633        }
4634
4635        #[inline]
4636        unsafe fn decode(
4637            &mut self,
4638            decoder: &mut fidl::encoding::Decoder<'_, D>,
4639            offset: usize,
4640            _depth: fidl::encoding::Depth,
4641        ) -> fidl::Result<()> {
4642            decoder.debug_check_bounds::<Self>(offset);
4643            // Verify that padding bytes are zero.
4644            fidl::decode!(bool, D, &mut self.enabled, decoder, offset + 0, _depth)?;
4645            Ok(())
4646        }
4647    }
4648
4649    impl fidl::encoding::ValueTypeMarker for MlmeGetScheduledScanEnabledResponse {
4650        type Borrowed<'a> = &'a Self;
4651        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4652            value
4653        }
4654    }
4655
4656    unsafe impl fidl::encoding::TypeMarker for MlmeGetScheduledScanEnabledResponse {
4657        type Owned = Self;
4658
4659        #[inline(always)]
4660        fn inline_align(_context: fidl::encoding::Context) -> usize {
4661            8
4662        }
4663
4664        #[inline(always)]
4665        fn inline_size(_context: fidl::encoding::Context) -> usize {
4666            16
4667        }
4668    }
4669
4670    unsafe impl<D: fidl::encoding::ResourceDialect>
4671        fidl::encoding::Encode<MlmeGetScheduledScanEnabledResponse, D>
4672        for &MlmeGetScheduledScanEnabledResponse
4673    {
4674        #[inline]
4675        unsafe fn encode(
4676            self,
4677            encoder: &mut fidl::encoding::Encoder<'_, D>,
4678            offset: usize,
4679            _depth: fidl::encoding::Depth,
4680        ) -> fidl::Result<()> {
4681            encoder.debug_check_bounds::<MlmeGetScheduledScanEnabledResponse>(offset);
4682            // Delegate to tuple encoding.
4683            fidl::encoding::Encode::<MlmeGetScheduledScanEnabledResponse, D>::encode(
4684                (
4685                    <fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(&self.active_txn_ids),
4686                ),
4687                encoder, offset, _depth
4688            )
4689        }
4690    }
4691    unsafe impl<
4692        D: fidl::encoding::ResourceDialect,
4693        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u64>, D>,
4694    > fidl::encoding::Encode<MlmeGetScheduledScanEnabledResponse, D> for (T0,)
4695    {
4696        #[inline]
4697        unsafe fn encode(
4698            self,
4699            encoder: &mut fidl::encoding::Encoder<'_, D>,
4700            offset: usize,
4701            depth: fidl::encoding::Depth,
4702        ) -> fidl::Result<()> {
4703            encoder.debug_check_bounds::<MlmeGetScheduledScanEnabledResponse>(offset);
4704            // Zero out padding regions. There's no need to apply masks
4705            // because the unmasked parts will be overwritten by fields.
4706            // Write the fields.
4707            self.0.encode(encoder, offset + 0, depth)?;
4708            Ok(())
4709        }
4710    }
4711
4712    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4713        for MlmeGetScheduledScanEnabledResponse
4714    {
4715        #[inline(always)]
4716        fn new_empty() -> Self {
4717            Self { active_txn_ids: fidl::new_empty!(fidl::encoding::UnboundedVector<u64>, D) }
4718        }
4719
4720        #[inline]
4721        unsafe fn decode(
4722            &mut self,
4723            decoder: &mut fidl::encoding::Decoder<'_, D>,
4724            offset: usize,
4725            _depth: fidl::encoding::Depth,
4726        ) -> fidl::Result<()> {
4727            decoder.debug_check_bounds::<Self>(offset);
4728            // Verify that padding bytes are zero.
4729            fidl::decode!(
4730                fidl::encoding::UnboundedVector<u64>,
4731                D,
4732                &mut self.active_txn_ids,
4733                decoder,
4734                offset + 0,
4735                _depth
4736            )?;
4737            Ok(())
4738        }
4739    }
4740
4741    impl fidl::encoding::ValueTypeMarker for MlmeGetSignalReportResponse {
4742        type Borrowed<'a> = &'a Self;
4743        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4744            value
4745        }
4746    }
4747
4748    unsafe impl fidl::encoding::TypeMarker for MlmeGetSignalReportResponse {
4749        type Owned = Self;
4750
4751        #[inline(always)]
4752        fn inline_align(_context: fidl::encoding::Context) -> usize {
4753            8
4754        }
4755
4756        #[inline(always)]
4757        fn inline_size(_context: fidl::encoding::Context) -> usize {
4758            16
4759        }
4760    }
4761
4762    unsafe impl<D: fidl::encoding::ResourceDialect>
4763        fidl::encoding::Encode<MlmeGetSignalReportResponse, D> for &MlmeGetSignalReportResponse
4764    {
4765        #[inline]
4766        unsafe fn encode(
4767            self,
4768            encoder: &mut fidl::encoding::Encoder<'_, D>,
4769            offset: usize,
4770            _depth: fidl::encoding::Depth,
4771        ) -> fidl::Result<()> {
4772            encoder.debug_check_bounds::<MlmeGetSignalReportResponse>(offset);
4773            // Delegate to tuple encoding.
4774            fidl::encoding::Encode::<MlmeGetSignalReportResponse, D>::encode(
4775                (
4776                    <fidl_fuchsia_wlan_stats__common::SignalReport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
4777                ),
4778                encoder, offset, _depth
4779            )
4780        }
4781    }
4782    unsafe impl<
4783        D: fidl::encoding::ResourceDialect,
4784        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::SignalReport, D>,
4785    > fidl::encoding::Encode<MlmeGetSignalReportResponse, D> for (T0,)
4786    {
4787        #[inline]
4788        unsafe fn encode(
4789            self,
4790            encoder: &mut fidl::encoding::Encoder<'_, D>,
4791            offset: usize,
4792            depth: fidl::encoding::Depth,
4793        ) -> fidl::Result<()> {
4794            encoder.debug_check_bounds::<MlmeGetSignalReportResponse>(offset);
4795            // Zero out padding regions. There's no need to apply masks
4796            // because the unmasked parts will be overwritten by fields.
4797            // Write the fields.
4798            self.0.encode(encoder, offset + 0, depth)?;
4799            Ok(())
4800        }
4801    }
4802
4803    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4804        for MlmeGetSignalReportResponse
4805    {
4806        #[inline(always)]
4807        fn new_empty() -> Self {
4808            Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::SignalReport, D) }
4809        }
4810
4811        #[inline]
4812        unsafe fn decode(
4813            &mut self,
4814            decoder: &mut fidl::encoding::Decoder<'_, D>,
4815            offset: usize,
4816            _depth: fidl::encoding::Depth,
4817        ) -> fidl::Result<()> {
4818            decoder.debug_check_bounds::<Self>(offset);
4819            // Verify that padding bytes are zero.
4820            fidl::decode!(
4821                fidl_fuchsia_wlan_stats__common::SignalReport,
4822                D,
4823                &mut self.resp,
4824                decoder,
4825                offset + 0,
4826                _depth
4827            )?;
4828            Ok(())
4829        }
4830    }
4831
4832    impl fidl::encoding::ValueTypeMarker for MlmeQueryTelemetrySupportResponse {
4833        type Borrowed<'a> = &'a Self;
4834        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4835            value
4836        }
4837    }
4838
4839    unsafe impl fidl::encoding::TypeMarker for MlmeQueryTelemetrySupportResponse {
4840        type Owned = Self;
4841
4842        #[inline(always)]
4843        fn inline_align(_context: fidl::encoding::Context) -> usize {
4844            8
4845        }
4846
4847        #[inline(always)]
4848        fn inline_size(_context: fidl::encoding::Context) -> usize {
4849            16
4850        }
4851    }
4852
4853    unsafe impl<D: fidl::encoding::ResourceDialect>
4854        fidl::encoding::Encode<MlmeQueryTelemetrySupportResponse, D>
4855        for &MlmeQueryTelemetrySupportResponse
4856    {
4857        #[inline]
4858        unsafe fn encode(
4859            self,
4860            encoder: &mut fidl::encoding::Encoder<'_, D>,
4861            offset: usize,
4862            _depth: fidl::encoding::Depth,
4863        ) -> fidl::Result<()> {
4864            encoder.debug_check_bounds::<MlmeQueryTelemetrySupportResponse>(offset);
4865            // Delegate to tuple encoding.
4866            fidl::encoding::Encode::<MlmeQueryTelemetrySupportResponse, D>::encode(
4867                (
4868                    <fidl_fuchsia_wlan_stats__common::TelemetrySupport as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
4869                ),
4870                encoder, offset, _depth
4871            )
4872        }
4873    }
4874    unsafe impl<
4875        D: fidl::encoding::ResourceDialect,
4876        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_stats__common::TelemetrySupport, D>,
4877    > fidl::encoding::Encode<MlmeQueryTelemetrySupportResponse, D> for (T0,)
4878    {
4879        #[inline]
4880        unsafe fn encode(
4881            self,
4882            encoder: &mut fidl::encoding::Encoder<'_, D>,
4883            offset: usize,
4884            depth: fidl::encoding::Depth,
4885        ) -> fidl::Result<()> {
4886            encoder.debug_check_bounds::<MlmeQueryTelemetrySupportResponse>(offset);
4887            // Zero out padding regions. There's no need to apply masks
4888            // because the unmasked parts will be overwritten by fields.
4889            // Write the fields.
4890            self.0.encode(encoder, offset + 0, depth)?;
4891            Ok(())
4892        }
4893    }
4894
4895    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4896        for MlmeQueryTelemetrySupportResponse
4897    {
4898        #[inline(always)]
4899        fn new_empty() -> Self {
4900            Self { resp: fidl::new_empty!(fidl_fuchsia_wlan_stats__common::TelemetrySupport, D) }
4901        }
4902
4903        #[inline]
4904        unsafe fn decode(
4905            &mut self,
4906            decoder: &mut fidl::encoding::Decoder<'_, D>,
4907            offset: usize,
4908            _depth: fidl::encoding::Depth,
4909        ) -> fidl::Result<()> {
4910            decoder.debug_check_bounds::<Self>(offset);
4911            // Verify that padding bytes are zero.
4912            fidl::decode!(
4913                fidl_fuchsia_wlan_stats__common::TelemetrySupport,
4914                D,
4915                &mut self.resp,
4916                decoder,
4917                offset + 0,
4918                _depth
4919            )?;
4920            Ok(())
4921        }
4922    }
4923
4924    impl fidl::encoding::ValueTypeMarker for MlmeReadApfPacketFilterDataResponse {
4925        type Borrowed<'a> = &'a Self;
4926        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4927            value
4928        }
4929    }
4930
4931    unsafe impl fidl::encoding::TypeMarker for MlmeReadApfPacketFilterDataResponse {
4932        type Owned = Self;
4933
4934        #[inline(always)]
4935        fn inline_align(_context: fidl::encoding::Context) -> usize {
4936            8
4937        }
4938
4939        #[inline(always)]
4940        fn inline_size(_context: fidl::encoding::Context) -> usize {
4941            16
4942        }
4943    }
4944
4945    unsafe impl<D: fidl::encoding::ResourceDialect>
4946        fidl::encoding::Encode<MlmeReadApfPacketFilterDataResponse, D>
4947        for &MlmeReadApfPacketFilterDataResponse
4948    {
4949        #[inline]
4950        unsafe fn encode(
4951            self,
4952            encoder: &mut fidl::encoding::Encoder<'_, D>,
4953            offset: usize,
4954            _depth: fidl::encoding::Depth,
4955        ) -> fidl::Result<()> {
4956            encoder.debug_check_bounds::<MlmeReadApfPacketFilterDataResponse>(offset);
4957            // Delegate to tuple encoding.
4958            fidl::encoding::Encode::<MlmeReadApfPacketFilterDataResponse, D>::encode(
4959                (<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(
4960                    &self.memory,
4961                ),),
4962                encoder,
4963                offset,
4964                _depth,
4965            )
4966        }
4967    }
4968    unsafe impl<
4969        D: fidl::encoding::ResourceDialect,
4970        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
4971    > fidl::encoding::Encode<MlmeReadApfPacketFilterDataResponse, D> for (T0,)
4972    {
4973        #[inline]
4974        unsafe fn encode(
4975            self,
4976            encoder: &mut fidl::encoding::Encoder<'_, D>,
4977            offset: usize,
4978            depth: fidl::encoding::Depth,
4979        ) -> fidl::Result<()> {
4980            encoder.debug_check_bounds::<MlmeReadApfPacketFilterDataResponse>(offset);
4981            // Zero out padding regions. There's no need to apply masks
4982            // because the unmasked parts will be overwritten by fields.
4983            // Write the fields.
4984            self.0.encode(encoder, offset + 0, depth)?;
4985            Ok(())
4986        }
4987    }
4988
4989    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4990        for MlmeReadApfPacketFilterDataResponse
4991    {
4992        #[inline(always)]
4993        fn new_empty() -> Self {
4994            Self { memory: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D) }
4995        }
4996
4997        #[inline]
4998        unsafe fn decode(
4999            &mut self,
5000            decoder: &mut fidl::encoding::Decoder<'_, D>,
5001            offset: usize,
5002            _depth: fidl::encoding::Depth,
5003        ) -> fidl::Result<()> {
5004            decoder.debug_check_bounds::<Self>(offset);
5005            // Verify that padding bytes are zero.
5006            fidl::decode!(
5007                fidl::encoding::UnboundedVector<u8>,
5008                D,
5009                &mut self.memory,
5010                decoder,
5011                offset + 0,
5012                _depth
5013            )?;
5014            Ok(())
5015        }
5016    }
5017
5018    impl fidl::encoding::ValueTypeMarker for MinstrelListResponse {
5019        type Borrowed<'a> = &'a Self;
5020        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5021            value
5022        }
5023    }
5024
5025    unsafe impl fidl::encoding::TypeMarker for MinstrelListResponse {
5026        type Owned = Self;
5027
5028        #[inline(always)]
5029        fn inline_align(_context: fidl::encoding::Context) -> usize {
5030            8
5031        }
5032
5033        #[inline(always)]
5034        fn inline_size(_context: fidl::encoding::Context) -> usize {
5035            16
5036        }
5037    }
5038
5039    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MinstrelListResponse, D>
5040        for &MinstrelListResponse
5041    {
5042        #[inline]
5043        unsafe fn encode(
5044            self,
5045            encoder: &mut fidl::encoding::Encoder<'_, D>,
5046            offset: usize,
5047            _depth: fidl::encoding::Depth,
5048        ) -> fidl::Result<()> {
5049            encoder.debug_check_bounds::<MinstrelListResponse>(offset);
5050            // Delegate to tuple encoding.
5051            fidl::encoding::Encode::<MinstrelListResponse, D>::encode(
5052                (
5053                    <fidl_fuchsia_wlan_minstrel__common::Peers as fidl::encoding::ValueTypeMarker>::borrow(&self.peers),
5054                ),
5055                encoder, offset, _depth
5056            )
5057        }
5058    }
5059    unsafe impl<
5060        D: fidl::encoding::ResourceDialect,
5061        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_minstrel__common::Peers, D>,
5062    > fidl::encoding::Encode<MinstrelListResponse, D> for (T0,)
5063    {
5064        #[inline]
5065        unsafe fn encode(
5066            self,
5067            encoder: &mut fidl::encoding::Encoder<'_, D>,
5068            offset: usize,
5069            depth: fidl::encoding::Depth,
5070        ) -> fidl::Result<()> {
5071            encoder.debug_check_bounds::<MinstrelListResponse>(offset);
5072            // Zero out padding regions. There's no need to apply masks
5073            // because the unmasked parts will be overwritten by fields.
5074            // Write the fields.
5075            self.0.encode(encoder, offset + 0, depth)?;
5076            Ok(())
5077        }
5078    }
5079
5080    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MinstrelListResponse {
5081        #[inline(always)]
5082        fn new_empty() -> Self {
5083            Self { peers: fidl::new_empty!(fidl_fuchsia_wlan_minstrel__common::Peers, D) }
5084        }
5085
5086        #[inline]
5087        unsafe fn decode(
5088            &mut self,
5089            decoder: &mut fidl::encoding::Decoder<'_, D>,
5090            offset: usize,
5091            _depth: fidl::encoding::Depth,
5092        ) -> fidl::Result<()> {
5093            decoder.debug_check_bounds::<Self>(offset);
5094            // Verify that padding bytes are zero.
5095            fidl::decode!(
5096                fidl_fuchsia_wlan_minstrel__common::Peers,
5097                D,
5098                &mut self.peers,
5099                decoder,
5100                offset + 0,
5101                _depth
5102            )?;
5103            Ok(())
5104        }
5105    }
5106
5107    impl fidl::encoding::ValueTypeMarker for MinstrelStatsRequest {
5108        type Borrowed<'a> = &'a Self;
5109        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5110            value
5111        }
5112    }
5113
5114    unsafe impl fidl::encoding::TypeMarker for MinstrelStatsRequest {
5115        type Owned = Self;
5116
5117        #[inline(always)]
5118        fn inline_align(_context: fidl::encoding::Context) -> usize {
5119            1
5120        }
5121
5122        #[inline(always)]
5123        fn inline_size(_context: fidl::encoding::Context) -> usize {
5124            6
5125        }
5126        #[inline(always)]
5127        fn encode_is_copy() -> bool {
5128            true
5129        }
5130
5131        #[inline(always)]
5132        fn decode_is_copy() -> bool {
5133            true
5134        }
5135    }
5136
5137    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MinstrelStatsRequest, D>
5138        for &MinstrelStatsRequest
5139    {
5140        #[inline]
5141        unsafe fn encode(
5142            self,
5143            encoder: &mut fidl::encoding::Encoder<'_, D>,
5144            offset: usize,
5145            _depth: fidl::encoding::Depth,
5146        ) -> fidl::Result<()> {
5147            encoder.debug_check_bounds::<MinstrelStatsRequest>(offset);
5148            unsafe {
5149                // Copy the object into the buffer.
5150                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
5151                (buf_ptr as *mut MinstrelStatsRequest)
5152                    .write_unaligned((self as *const MinstrelStatsRequest).read());
5153                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
5154                // done second because the memcpy will write garbage to these bytes.
5155            }
5156            Ok(())
5157        }
5158    }
5159    unsafe impl<
5160        D: fidl::encoding::ResourceDialect,
5161        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
5162    > fidl::encoding::Encode<MinstrelStatsRequest, D> for (T0,)
5163    {
5164        #[inline]
5165        unsafe fn encode(
5166            self,
5167            encoder: &mut fidl::encoding::Encoder<'_, D>,
5168            offset: usize,
5169            depth: fidl::encoding::Depth,
5170        ) -> fidl::Result<()> {
5171            encoder.debug_check_bounds::<MinstrelStatsRequest>(offset);
5172            // Zero out padding regions. There's no need to apply masks
5173            // because the unmasked parts will be overwritten by fields.
5174            // Write the fields.
5175            self.0.encode(encoder, offset + 0, depth)?;
5176            Ok(())
5177        }
5178    }
5179
5180    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MinstrelStatsRequest {
5181        #[inline(always)]
5182        fn new_empty() -> Self {
5183            Self { peer_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D) }
5184        }
5185
5186        #[inline]
5187        unsafe fn decode(
5188            &mut self,
5189            decoder: &mut fidl::encoding::Decoder<'_, D>,
5190            offset: usize,
5191            _depth: fidl::encoding::Depth,
5192        ) -> fidl::Result<()> {
5193            decoder.debug_check_bounds::<Self>(offset);
5194            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
5195            // Verify that padding bytes are zero.
5196            // Copy from the buffer into the object.
5197            unsafe {
5198                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 6);
5199            }
5200            Ok(())
5201        }
5202    }
5203
5204    impl fidl::encoding::ValueTypeMarker for MinstrelStatsResponse {
5205        type Borrowed<'a> = &'a Self;
5206        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5207            value
5208        }
5209    }
5210
5211    unsafe impl fidl::encoding::TypeMarker for MinstrelStatsResponse {
5212        type Owned = Self;
5213
5214        #[inline(always)]
5215        fn inline_align(_context: fidl::encoding::Context) -> usize {
5216            8
5217        }
5218
5219        #[inline(always)]
5220        fn inline_size(_context: fidl::encoding::Context) -> usize {
5221            8
5222        }
5223    }
5224
5225    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MinstrelStatsResponse, D>
5226        for &MinstrelStatsResponse
5227    {
5228        #[inline]
5229        unsafe fn encode(
5230            self,
5231            encoder: &mut fidl::encoding::Encoder<'_, D>,
5232            offset: usize,
5233            _depth: fidl::encoding::Depth,
5234        ) -> fidl::Result<()> {
5235            encoder.debug_check_bounds::<MinstrelStatsResponse>(offset);
5236            // Delegate to tuple encoding.
5237            fidl::encoding::Encode::<MinstrelStatsResponse, D>::encode(
5238                (
5239                    <fidl::encoding::Boxed<fidl_fuchsia_wlan_minstrel__common::Peer> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer),
5240                ),
5241                encoder, offset, _depth
5242            )
5243        }
5244    }
5245    unsafe impl<
5246        D: fidl::encoding::ResourceDialect,
5247        T0: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_wlan_minstrel__common::Peer>, D>,
5248    > fidl::encoding::Encode<MinstrelStatsResponse, D> for (T0,)
5249    {
5250        #[inline]
5251        unsafe fn encode(
5252            self,
5253            encoder: &mut fidl::encoding::Encoder<'_, D>,
5254            offset: usize,
5255            depth: fidl::encoding::Depth,
5256        ) -> fidl::Result<()> {
5257            encoder.debug_check_bounds::<MinstrelStatsResponse>(offset);
5258            // Zero out padding regions. There's no need to apply masks
5259            // because the unmasked parts will be overwritten by fields.
5260            // Write the fields.
5261            self.0.encode(encoder, offset + 0, depth)?;
5262            Ok(())
5263        }
5264    }
5265
5266    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MinstrelStatsResponse {
5267        #[inline(always)]
5268        fn new_empty() -> Self {
5269            Self {
5270                peer: fidl::new_empty!(
5271                    fidl::encoding::Boxed<fidl_fuchsia_wlan_minstrel__common::Peer>,
5272                    D
5273                ),
5274            }
5275        }
5276
5277        #[inline]
5278        unsafe fn decode(
5279            &mut self,
5280            decoder: &mut fidl::encoding::Decoder<'_, D>,
5281            offset: usize,
5282            _depth: fidl::encoding::Depth,
5283        ) -> fidl::Result<()> {
5284            decoder.debug_check_bounds::<Self>(offset);
5285            // Verify that padding bytes are zero.
5286            fidl::decode!(
5287                fidl::encoding::Boxed<fidl_fuchsia_wlan_minstrel__common::Peer>,
5288                D,
5289                &mut self.peer,
5290                decoder,
5291                offset + 0,
5292                _depth
5293            )?;
5294            Ok(())
5295        }
5296    }
5297
5298    impl fidl::encoding::ValueTypeMarker for MlmeAssociateIndRequest {
5299        type Borrowed<'a> = &'a Self;
5300        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5301            value
5302        }
5303    }
5304
5305    unsafe impl fidl::encoding::TypeMarker for MlmeAssociateIndRequest {
5306        type Owned = Self;
5307
5308        #[inline(always)]
5309        fn inline_align(_context: fidl::encoding::Context) -> usize {
5310            8
5311        }
5312
5313        #[inline(always)]
5314        fn inline_size(_context: fidl::encoding::Context) -> usize {
5315            64
5316        }
5317    }
5318
5319    unsafe impl<D: fidl::encoding::ResourceDialect>
5320        fidl::encoding::Encode<MlmeAssociateIndRequest, D> for &MlmeAssociateIndRequest
5321    {
5322        #[inline]
5323        unsafe fn encode(
5324            self,
5325            encoder: &mut fidl::encoding::Encoder<'_, D>,
5326            offset: usize,
5327            _depth: fidl::encoding::Depth,
5328        ) -> fidl::Result<()> {
5329            encoder.debug_check_bounds::<MlmeAssociateIndRequest>(offset);
5330            // Delegate to tuple encoding.
5331            fidl::encoding::Encode::<MlmeAssociateIndRequest, D>::encode(
5332                (<AssociateIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),),
5333                encoder,
5334                offset,
5335                _depth,
5336            )
5337        }
5338    }
5339    unsafe impl<
5340        D: fidl::encoding::ResourceDialect,
5341        T0: fidl::encoding::Encode<AssociateIndication, D>,
5342    > fidl::encoding::Encode<MlmeAssociateIndRequest, D> for (T0,)
5343    {
5344        #[inline]
5345        unsafe fn encode(
5346            self,
5347            encoder: &mut fidl::encoding::Encoder<'_, D>,
5348            offset: usize,
5349            depth: fidl::encoding::Depth,
5350        ) -> fidl::Result<()> {
5351            encoder.debug_check_bounds::<MlmeAssociateIndRequest>(offset);
5352            // Zero out padding regions. There's no need to apply masks
5353            // because the unmasked parts will be overwritten by fields.
5354            // Write the fields.
5355            self.0.encode(encoder, offset + 0, depth)?;
5356            Ok(())
5357        }
5358    }
5359
5360    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5361        for MlmeAssociateIndRequest
5362    {
5363        #[inline(always)]
5364        fn new_empty() -> Self {
5365            Self { ind: fidl::new_empty!(AssociateIndication, D) }
5366        }
5367
5368        #[inline]
5369        unsafe fn decode(
5370            &mut self,
5371            decoder: &mut fidl::encoding::Decoder<'_, D>,
5372            offset: usize,
5373            _depth: fidl::encoding::Depth,
5374        ) -> fidl::Result<()> {
5375            decoder.debug_check_bounds::<Self>(offset);
5376            // Verify that padding bytes are zero.
5377            fidl::decode!(AssociateIndication, D, &mut self.ind, decoder, offset + 0, _depth)?;
5378            Ok(())
5379        }
5380    }
5381
5382    impl fidl::encoding::ValueTypeMarker for MlmeAssociateRespRequest {
5383        type Borrowed<'a> = &'a Self;
5384        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5385            value
5386        }
5387    }
5388
5389    unsafe impl fidl::encoding::TypeMarker for MlmeAssociateRespRequest {
5390        type Owned = Self;
5391
5392        #[inline(always)]
5393        fn inline_align(_context: fidl::encoding::Context) -> usize {
5394            8
5395        }
5396
5397        #[inline(always)]
5398        fn inline_size(_context: fidl::encoding::Context) -> usize {
5399            32
5400        }
5401    }
5402
5403    unsafe impl<D: fidl::encoding::ResourceDialect>
5404        fidl::encoding::Encode<MlmeAssociateRespRequest, D> for &MlmeAssociateRespRequest
5405    {
5406        #[inline]
5407        unsafe fn encode(
5408            self,
5409            encoder: &mut fidl::encoding::Encoder<'_, D>,
5410            offset: usize,
5411            _depth: fidl::encoding::Depth,
5412        ) -> fidl::Result<()> {
5413            encoder.debug_check_bounds::<MlmeAssociateRespRequest>(offset);
5414            // Delegate to tuple encoding.
5415            fidl::encoding::Encode::<MlmeAssociateRespRequest, D>::encode(
5416                (<AssociateResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
5417                encoder,
5418                offset,
5419                _depth,
5420            )
5421        }
5422    }
5423    unsafe impl<
5424        D: fidl::encoding::ResourceDialect,
5425        T0: fidl::encoding::Encode<AssociateResponse, D>,
5426    > fidl::encoding::Encode<MlmeAssociateRespRequest, D> for (T0,)
5427    {
5428        #[inline]
5429        unsafe fn encode(
5430            self,
5431            encoder: &mut fidl::encoding::Encoder<'_, D>,
5432            offset: usize,
5433            depth: fidl::encoding::Depth,
5434        ) -> fidl::Result<()> {
5435            encoder.debug_check_bounds::<MlmeAssociateRespRequest>(offset);
5436            // Zero out padding regions. There's no need to apply masks
5437            // because the unmasked parts will be overwritten by fields.
5438            // Write the fields.
5439            self.0.encode(encoder, offset + 0, depth)?;
5440            Ok(())
5441        }
5442    }
5443
5444    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5445        for MlmeAssociateRespRequest
5446    {
5447        #[inline(always)]
5448        fn new_empty() -> Self {
5449            Self { resp: fidl::new_empty!(AssociateResponse, D) }
5450        }
5451
5452        #[inline]
5453        unsafe fn decode(
5454            &mut self,
5455            decoder: &mut fidl::encoding::Decoder<'_, D>,
5456            offset: usize,
5457            _depth: fidl::encoding::Depth,
5458        ) -> fidl::Result<()> {
5459            decoder.debug_check_bounds::<Self>(offset);
5460            // Verify that padding bytes are zero.
5461            fidl::decode!(AssociateResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
5462            Ok(())
5463        }
5464    }
5465
5466    impl fidl::encoding::ValueTypeMarker for MlmeAuthenticateIndRequest {
5467        type Borrowed<'a> = &'a Self;
5468        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5469            value
5470        }
5471    }
5472
5473    unsafe impl fidl::encoding::TypeMarker for MlmeAuthenticateIndRequest {
5474        type Owned = Self;
5475
5476        #[inline(always)]
5477        fn inline_align(_context: fidl::encoding::Context) -> usize {
5478            4
5479        }
5480
5481        #[inline(always)]
5482        fn inline_size(_context: fidl::encoding::Context) -> usize {
5483            12
5484        }
5485    }
5486
5487    unsafe impl<D: fidl::encoding::ResourceDialect>
5488        fidl::encoding::Encode<MlmeAuthenticateIndRequest, D> for &MlmeAuthenticateIndRequest
5489    {
5490        #[inline]
5491        unsafe fn encode(
5492            self,
5493            encoder: &mut fidl::encoding::Encoder<'_, D>,
5494            offset: usize,
5495            _depth: fidl::encoding::Depth,
5496        ) -> fidl::Result<()> {
5497            encoder.debug_check_bounds::<MlmeAuthenticateIndRequest>(offset);
5498            // Delegate to tuple encoding.
5499            fidl::encoding::Encode::<MlmeAuthenticateIndRequest, D>::encode(
5500                (<AuthenticateIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),),
5501                encoder,
5502                offset,
5503                _depth,
5504            )
5505        }
5506    }
5507    unsafe impl<
5508        D: fidl::encoding::ResourceDialect,
5509        T0: fidl::encoding::Encode<AuthenticateIndication, D>,
5510    > fidl::encoding::Encode<MlmeAuthenticateIndRequest, D> for (T0,)
5511    {
5512        #[inline]
5513        unsafe fn encode(
5514            self,
5515            encoder: &mut fidl::encoding::Encoder<'_, D>,
5516            offset: usize,
5517            depth: fidl::encoding::Depth,
5518        ) -> fidl::Result<()> {
5519            encoder.debug_check_bounds::<MlmeAuthenticateIndRequest>(offset);
5520            // Zero out padding regions. There's no need to apply masks
5521            // because the unmasked parts will be overwritten by fields.
5522            // Write the fields.
5523            self.0.encode(encoder, offset + 0, depth)?;
5524            Ok(())
5525        }
5526    }
5527
5528    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5529        for MlmeAuthenticateIndRequest
5530    {
5531        #[inline(always)]
5532        fn new_empty() -> Self {
5533            Self { ind: fidl::new_empty!(AuthenticateIndication, D) }
5534        }
5535
5536        #[inline]
5537        unsafe fn decode(
5538            &mut self,
5539            decoder: &mut fidl::encoding::Decoder<'_, D>,
5540            offset: usize,
5541            _depth: fidl::encoding::Depth,
5542        ) -> fidl::Result<()> {
5543            decoder.debug_check_bounds::<Self>(offset);
5544            // Verify that padding bytes are zero.
5545            fidl::decode!(AuthenticateIndication, D, &mut self.ind, decoder, offset + 0, _depth)?;
5546            Ok(())
5547        }
5548    }
5549
5550    impl fidl::encoding::ValueTypeMarker for MlmeAuthenticateRespRequest {
5551        type Borrowed<'a> = &'a Self;
5552        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5553            value
5554        }
5555    }
5556
5557    unsafe impl fidl::encoding::TypeMarker for MlmeAuthenticateRespRequest {
5558        type Owned = Self;
5559
5560        #[inline(always)]
5561        fn inline_align(_context: fidl::encoding::Context) -> usize {
5562            4
5563        }
5564
5565        #[inline(always)]
5566        fn inline_size(_context: fidl::encoding::Context) -> usize {
5567            12
5568        }
5569    }
5570
5571    unsafe impl<D: fidl::encoding::ResourceDialect>
5572        fidl::encoding::Encode<MlmeAuthenticateRespRequest, D> for &MlmeAuthenticateRespRequest
5573    {
5574        #[inline]
5575        unsafe fn encode(
5576            self,
5577            encoder: &mut fidl::encoding::Encoder<'_, D>,
5578            offset: usize,
5579            _depth: fidl::encoding::Depth,
5580        ) -> fidl::Result<()> {
5581            encoder.debug_check_bounds::<MlmeAuthenticateRespRequest>(offset);
5582            // Delegate to tuple encoding.
5583            fidl::encoding::Encode::<MlmeAuthenticateRespRequest, D>::encode(
5584                (<AuthenticateResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
5585                encoder,
5586                offset,
5587                _depth,
5588            )
5589        }
5590    }
5591    unsafe impl<
5592        D: fidl::encoding::ResourceDialect,
5593        T0: fidl::encoding::Encode<AuthenticateResponse, D>,
5594    > fidl::encoding::Encode<MlmeAuthenticateRespRequest, D> for (T0,)
5595    {
5596        #[inline]
5597        unsafe fn encode(
5598            self,
5599            encoder: &mut fidl::encoding::Encoder<'_, D>,
5600            offset: usize,
5601            depth: fidl::encoding::Depth,
5602        ) -> fidl::Result<()> {
5603            encoder.debug_check_bounds::<MlmeAuthenticateRespRequest>(offset);
5604            // Zero out padding regions. There's no need to apply masks
5605            // because the unmasked parts will be overwritten by fields.
5606            // Write the fields.
5607            self.0.encode(encoder, offset + 0, depth)?;
5608            Ok(())
5609        }
5610    }
5611
5612    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5613        for MlmeAuthenticateRespRequest
5614    {
5615        #[inline(always)]
5616        fn new_empty() -> Self {
5617            Self { resp: fidl::new_empty!(AuthenticateResponse, D) }
5618        }
5619
5620        #[inline]
5621        unsafe fn decode(
5622            &mut self,
5623            decoder: &mut fidl::encoding::Decoder<'_, D>,
5624            offset: usize,
5625            _depth: fidl::encoding::Depth,
5626        ) -> fidl::Result<()> {
5627            decoder.debug_check_bounds::<Self>(offset);
5628            // Verify that padding bytes are zero.
5629            fidl::decode!(AuthenticateResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
5630            Ok(())
5631        }
5632    }
5633
5634    impl fidl::encoding::ValueTypeMarker for MlmeConnectConfRequest {
5635        type Borrowed<'a> = &'a Self;
5636        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5637            value
5638        }
5639    }
5640
5641    unsafe impl fidl::encoding::TypeMarker for MlmeConnectConfRequest {
5642        type Owned = Self;
5643
5644        #[inline(always)]
5645        fn inline_align(_context: fidl::encoding::Context) -> usize {
5646            8
5647        }
5648
5649        #[inline(always)]
5650        fn inline_size(_context: fidl::encoding::Context) -> usize {
5651            32
5652        }
5653    }
5654
5655    unsafe impl<D: fidl::encoding::ResourceDialect>
5656        fidl::encoding::Encode<MlmeConnectConfRequest, D> for &MlmeConnectConfRequest
5657    {
5658        #[inline]
5659        unsafe fn encode(
5660            self,
5661            encoder: &mut fidl::encoding::Encoder<'_, D>,
5662            offset: usize,
5663            _depth: fidl::encoding::Depth,
5664        ) -> fidl::Result<()> {
5665            encoder.debug_check_bounds::<MlmeConnectConfRequest>(offset);
5666            // Delegate to tuple encoding.
5667            fidl::encoding::Encode::<MlmeConnectConfRequest, D>::encode(
5668                (<ConnectConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
5669                encoder,
5670                offset,
5671                _depth,
5672            )
5673        }
5674    }
5675    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ConnectConfirm, D>>
5676        fidl::encoding::Encode<MlmeConnectConfRequest, D> for (T0,)
5677    {
5678        #[inline]
5679        unsafe fn encode(
5680            self,
5681            encoder: &mut fidl::encoding::Encoder<'_, D>,
5682            offset: usize,
5683            depth: fidl::encoding::Depth,
5684        ) -> fidl::Result<()> {
5685            encoder.debug_check_bounds::<MlmeConnectConfRequest>(offset);
5686            // Zero out padding regions. There's no need to apply masks
5687            // because the unmasked parts will be overwritten by fields.
5688            // Write the fields.
5689            self.0.encode(encoder, offset + 0, depth)?;
5690            Ok(())
5691        }
5692    }
5693
5694    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5695        for MlmeConnectConfRequest
5696    {
5697        #[inline(always)]
5698        fn new_empty() -> Self {
5699            Self { resp: fidl::new_empty!(ConnectConfirm, D) }
5700        }
5701
5702        #[inline]
5703        unsafe fn decode(
5704            &mut self,
5705            decoder: &mut fidl::encoding::Decoder<'_, D>,
5706            offset: usize,
5707            _depth: fidl::encoding::Depth,
5708        ) -> fidl::Result<()> {
5709            decoder.debug_check_bounds::<Self>(offset);
5710            // Verify that padding bytes are zero.
5711            fidl::decode!(ConnectConfirm, D, &mut self.resp, decoder, offset + 0, _depth)?;
5712            Ok(())
5713        }
5714    }
5715
5716    impl fidl::encoding::ValueTypeMarker for MlmeConnectReqRequest {
5717        type Borrowed<'a> = &'a Self;
5718        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5719            value
5720        }
5721    }
5722
5723    unsafe impl fidl::encoding::TypeMarker for MlmeConnectReqRequest {
5724        type Owned = Self;
5725
5726        #[inline(always)]
5727        fn inline_align(_context: fidl::encoding::Context) -> usize {
5728            8
5729        }
5730
5731        #[inline(always)]
5732        fn inline_size(_context: fidl::encoding::Context) -> usize {
5733            104
5734        }
5735    }
5736
5737    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeConnectReqRequest, D>
5738        for &MlmeConnectReqRequest
5739    {
5740        #[inline]
5741        unsafe fn encode(
5742            self,
5743            encoder: &mut fidl::encoding::Encoder<'_, D>,
5744            offset: usize,
5745            _depth: fidl::encoding::Depth,
5746        ) -> fidl::Result<()> {
5747            encoder.debug_check_bounds::<MlmeConnectReqRequest>(offset);
5748            // Delegate to tuple encoding.
5749            fidl::encoding::Encode::<MlmeConnectReqRequest, D>::encode(
5750                (<ConnectRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
5751                encoder,
5752                offset,
5753                _depth,
5754            )
5755        }
5756    }
5757    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ConnectRequest, D>>
5758        fidl::encoding::Encode<MlmeConnectReqRequest, D> for (T0,)
5759    {
5760        #[inline]
5761        unsafe fn encode(
5762            self,
5763            encoder: &mut fidl::encoding::Encoder<'_, D>,
5764            offset: usize,
5765            depth: fidl::encoding::Depth,
5766        ) -> fidl::Result<()> {
5767            encoder.debug_check_bounds::<MlmeConnectReqRequest>(offset);
5768            // Zero out padding regions. There's no need to apply masks
5769            // because the unmasked parts will be overwritten by fields.
5770            // Write the fields.
5771            self.0.encode(encoder, offset + 0, depth)?;
5772            Ok(())
5773        }
5774    }
5775
5776    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeConnectReqRequest {
5777        #[inline(always)]
5778        fn new_empty() -> Self {
5779            Self { req: fidl::new_empty!(ConnectRequest, D) }
5780        }
5781
5782        #[inline]
5783        unsafe fn decode(
5784            &mut self,
5785            decoder: &mut fidl::encoding::Decoder<'_, D>,
5786            offset: usize,
5787            _depth: fidl::encoding::Depth,
5788        ) -> fidl::Result<()> {
5789            decoder.debug_check_bounds::<Self>(offset);
5790            // Verify that padding bytes are zero.
5791            fidl::decode!(ConnectRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
5792            Ok(())
5793        }
5794    }
5795
5796    impl fidl::encoding::ValueTypeMarker for MlmeDeauthenticateConfRequest {
5797        type Borrowed<'a> = &'a Self;
5798        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5799            value
5800        }
5801    }
5802
5803    unsafe impl fidl::encoding::TypeMarker for MlmeDeauthenticateConfRequest {
5804        type Owned = Self;
5805
5806        #[inline(always)]
5807        fn inline_align(_context: fidl::encoding::Context) -> usize {
5808            1
5809        }
5810
5811        #[inline(always)]
5812        fn inline_size(_context: fidl::encoding::Context) -> usize {
5813            6
5814        }
5815        #[inline(always)]
5816        fn encode_is_copy() -> bool {
5817            true
5818        }
5819
5820        #[inline(always)]
5821        fn decode_is_copy() -> bool {
5822            true
5823        }
5824    }
5825
5826    unsafe impl<D: fidl::encoding::ResourceDialect>
5827        fidl::encoding::Encode<MlmeDeauthenticateConfRequest, D>
5828        for &MlmeDeauthenticateConfRequest
5829    {
5830        #[inline]
5831        unsafe fn encode(
5832            self,
5833            encoder: &mut fidl::encoding::Encoder<'_, D>,
5834            offset: usize,
5835            _depth: fidl::encoding::Depth,
5836        ) -> fidl::Result<()> {
5837            encoder.debug_check_bounds::<MlmeDeauthenticateConfRequest>(offset);
5838            unsafe {
5839                // Copy the object into the buffer.
5840                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
5841                (buf_ptr as *mut MlmeDeauthenticateConfRequest)
5842                    .write_unaligned((self as *const MlmeDeauthenticateConfRequest).read());
5843                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
5844                // done second because the memcpy will write garbage to these bytes.
5845            }
5846            Ok(())
5847        }
5848    }
5849    unsafe impl<
5850        D: fidl::encoding::ResourceDialect,
5851        T0: fidl::encoding::Encode<DeauthenticateConfirm, D>,
5852    > fidl::encoding::Encode<MlmeDeauthenticateConfRequest, D> for (T0,)
5853    {
5854        #[inline]
5855        unsafe fn encode(
5856            self,
5857            encoder: &mut fidl::encoding::Encoder<'_, D>,
5858            offset: usize,
5859            depth: fidl::encoding::Depth,
5860        ) -> fidl::Result<()> {
5861            encoder.debug_check_bounds::<MlmeDeauthenticateConfRequest>(offset);
5862            // Zero out padding regions. There's no need to apply masks
5863            // because the unmasked parts will be overwritten by fields.
5864            // Write the fields.
5865            self.0.encode(encoder, offset + 0, depth)?;
5866            Ok(())
5867        }
5868    }
5869
5870    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5871        for MlmeDeauthenticateConfRequest
5872    {
5873        #[inline(always)]
5874        fn new_empty() -> Self {
5875            Self { resp: fidl::new_empty!(DeauthenticateConfirm, D) }
5876        }
5877
5878        #[inline]
5879        unsafe fn decode(
5880            &mut self,
5881            decoder: &mut fidl::encoding::Decoder<'_, D>,
5882            offset: usize,
5883            _depth: fidl::encoding::Depth,
5884        ) -> fidl::Result<()> {
5885            decoder.debug_check_bounds::<Self>(offset);
5886            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
5887            // Verify that padding bytes are zero.
5888            // Copy from the buffer into the object.
5889            unsafe {
5890                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 6);
5891            }
5892            Ok(())
5893        }
5894    }
5895
5896    impl fidl::encoding::ValueTypeMarker for MlmeDeauthenticateIndRequest {
5897        type Borrowed<'a> = &'a Self;
5898        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5899            value
5900        }
5901    }
5902
5903    unsafe impl fidl::encoding::TypeMarker for MlmeDeauthenticateIndRequest {
5904        type Owned = Self;
5905
5906        #[inline(always)]
5907        fn inline_align(_context: fidl::encoding::Context) -> usize {
5908            2
5909        }
5910
5911        #[inline(always)]
5912        fn inline_size(_context: fidl::encoding::Context) -> usize {
5913            10
5914        }
5915    }
5916
5917    unsafe impl<D: fidl::encoding::ResourceDialect>
5918        fidl::encoding::Encode<MlmeDeauthenticateIndRequest, D> for &MlmeDeauthenticateIndRequest
5919    {
5920        #[inline]
5921        unsafe fn encode(
5922            self,
5923            encoder: &mut fidl::encoding::Encoder<'_, D>,
5924            offset: usize,
5925            _depth: fidl::encoding::Depth,
5926        ) -> fidl::Result<()> {
5927            encoder.debug_check_bounds::<MlmeDeauthenticateIndRequest>(offset);
5928            // Delegate to tuple encoding.
5929            fidl::encoding::Encode::<MlmeDeauthenticateIndRequest, D>::encode(
5930                (<DeauthenticateIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),),
5931                encoder,
5932                offset,
5933                _depth,
5934            )
5935        }
5936    }
5937    unsafe impl<
5938        D: fidl::encoding::ResourceDialect,
5939        T0: fidl::encoding::Encode<DeauthenticateIndication, D>,
5940    > fidl::encoding::Encode<MlmeDeauthenticateIndRequest, D> for (T0,)
5941    {
5942        #[inline]
5943        unsafe fn encode(
5944            self,
5945            encoder: &mut fidl::encoding::Encoder<'_, D>,
5946            offset: usize,
5947            depth: fidl::encoding::Depth,
5948        ) -> fidl::Result<()> {
5949            encoder.debug_check_bounds::<MlmeDeauthenticateIndRequest>(offset);
5950            // Zero out padding regions. There's no need to apply masks
5951            // because the unmasked parts will be overwritten by fields.
5952            // Write the fields.
5953            self.0.encode(encoder, offset + 0, depth)?;
5954            Ok(())
5955        }
5956    }
5957
5958    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5959        for MlmeDeauthenticateIndRequest
5960    {
5961        #[inline(always)]
5962        fn new_empty() -> Self {
5963            Self { ind: fidl::new_empty!(DeauthenticateIndication, D) }
5964        }
5965
5966        #[inline]
5967        unsafe fn decode(
5968            &mut self,
5969            decoder: &mut fidl::encoding::Decoder<'_, D>,
5970            offset: usize,
5971            _depth: fidl::encoding::Depth,
5972        ) -> fidl::Result<()> {
5973            decoder.debug_check_bounds::<Self>(offset);
5974            // Verify that padding bytes are zero.
5975            fidl::decode!(DeauthenticateIndication, D, &mut self.ind, decoder, offset + 0, _depth)?;
5976            Ok(())
5977        }
5978    }
5979
5980    impl fidl::encoding::ValueTypeMarker for MlmeDeauthenticateReqRequest {
5981        type Borrowed<'a> = &'a Self;
5982        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5983            value
5984        }
5985    }
5986
5987    unsafe impl fidl::encoding::TypeMarker for MlmeDeauthenticateReqRequest {
5988        type Owned = Self;
5989
5990        #[inline(always)]
5991        fn inline_align(_context: fidl::encoding::Context) -> usize {
5992            2
5993        }
5994
5995        #[inline(always)]
5996        fn inline_size(_context: fidl::encoding::Context) -> usize {
5997            8
5998        }
5999    }
6000
6001    unsafe impl<D: fidl::encoding::ResourceDialect>
6002        fidl::encoding::Encode<MlmeDeauthenticateReqRequest, D> for &MlmeDeauthenticateReqRequest
6003    {
6004        #[inline]
6005        unsafe fn encode(
6006            self,
6007            encoder: &mut fidl::encoding::Encoder<'_, D>,
6008            offset: usize,
6009            _depth: fidl::encoding::Depth,
6010        ) -> fidl::Result<()> {
6011            encoder.debug_check_bounds::<MlmeDeauthenticateReqRequest>(offset);
6012            // Delegate to tuple encoding.
6013            fidl::encoding::Encode::<MlmeDeauthenticateReqRequest, D>::encode(
6014                (<DeauthenticateRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
6015                encoder,
6016                offset,
6017                _depth,
6018            )
6019        }
6020    }
6021    unsafe impl<
6022        D: fidl::encoding::ResourceDialect,
6023        T0: fidl::encoding::Encode<DeauthenticateRequest, D>,
6024    > fidl::encoding::Encode<MlmeDeauthenticateReqRequest, D> for (T0,)
6025    {
6026        #[inline]
6027        unsafe fn encode(
6028            self,
6029            encoder: &mut fidl::encoding::Encoder<'_, D>,
6030            offset: usize,
6031            depth: fidl::encoding::Depth,
6032        ) -> fidl::Result<()> {
6033            encoder.debug_check_bounds::<MlmeDeauthenticateReqRequest>(offset);
6034            // Zero out padding regions. There's no need to apply masks
6035            // because the unmasked parts will be overwritten by fields.
6036            // Write the fields.
6037            self.0.encode(encoder, offset + 0, depth)?;
6038            Ok(())
6039        }
6040    }
6041
6042    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6043        for MlmeDeauthenticateReqRequest
6044    {
6045        #[inline(always)]
6046        fn new_empty() -> Self {
6047            Self { req: fidl::new_empty!(DeauthenticateRequest, D) }
6048        }
6049
6050        #[inline]
6051        unsafe fn decode(
6052            &mut self,
6053            decoder: &mut fidl::encoding::Decoder<'_, D>,
6054            offset: usize,
6055            _depth: fidl::encoding::Depth,
6056        ) -> fidl::Result<()> {
6057            decoder.debug_check_bounds::<Self>(offset);
6058            // Verify that padding bytes are zero.
6059            fidl::decode!(DeauthenticateRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
6060            Ok(())
6061        }
6062    }
6063
6064    impl fidl::encoding::ValueTypeMarker for MlmeDeleteKeysReqRequest {
6065        type Borrowed<'a> = &'a Self;
6066        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6067            value
6068        }
6069    }
6070
6071    unsafe impl fidl::encoding::TypeMarker for MlmeDeleteKeysReqRequest {
6072        type Owned = Self;
6073
6074        #[inline(always)]
6075        fn inline_align(_context: fidl::encoding::Context) -> usize {
6076            8
6077        }
6078
6079        #[inline(always)]
6080        fn inline_size(_context: fidl::encoding::Context) -> usize {
6081            16
6082        }
6083    }
6084
6085    unsafe impl<D: fidl::encoding::ResourceDialect>
6086        fidl::encoding::Encode<MlmeDeleteKeysReqRequest, D> for &MlmeDeleteKeysReqRequest
6087    {
6088        #[inline]
6089        unsafe fn encode(
6090            self,
6091            encoder: &mut fidl::encoding::Encoder<'_, D>,
6092            offset: usize,
6093            _depth: fidl::encoding::Depth,
6094        ) -> fidl::Result<()> {
6095            encoder.debug_check_bounds::<MlmeDeleteKeysReqRequest>(offset);
6096            // Delegate to tuple encoding.
6097            fidl::encoding::Encode::<MlmeDeleteKeysReqRequest, D>::encode(
6098                (<DeleteKeysRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
6099                encoder,
6100                offset,
6101                _depth,
6102            )
6103        }
6104    }
6105    unsafe impl<
6106        D: fidl::encoding::ResourceDialect,
6107        T0: fidl::encoding::Encode<DeleteKeysRequest, D>,
6108    > fidl::encoding::Encode<MlmeDeleteKeysReqRequest, D> for (T0,)
6109    {
6110        #[inline]
6111        unsafe fn encode(
6112            self,
6113            encoder: &mut fidl::encoding::Encoder<'_, D>,
6114            offset: usize,
6115            depth: fidl::encoding::Depth,
6116        ) -> fidl::Result<()> {
6117            encoder.debug_check_bounds::<MlmeDeleteKeysReqRequest>(offset);
6118            // Zero out padding regions. There's no need to apply masks
6119            // because the unmasked parts will be overwritten by fields.
6120            // Write the fields.
6121            self.0.encode(encoder, offset + 0, depth)?;
6122            Ok(())
6123        }
6124    }
6125
6126    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6127        for MlmeDeleteKeysReqRequest
6128    {
6129        #[inline(always)]
6130        fn new_empty() -> Self {
6131            Self { req: fidl::new_empty!(DeleteKeysRequest, D) }
6132        }
6133
6134        #[inline]
6135        unsafe fn decode(
6136            &mut self,
6137            decoder: &mut fidl::encoding::Decoder<'_, D>,
6138            offset: usize,
6139            _depth: fidl::encoding::Depth,
6140        ) -> fidl::Result<()> {
6141            decoder.debug_check_bounds::<Self>(offset);
6142            // Verify that padding bytes are zero.
6143            fidl::decode!(DeleteKeysRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
6144            Ok(())
6145        }
6146    }
6147
6148    impl fidl::encoding::ValueTypeMarker for MlmeDisassociateConfRequest {
6149        type Borrowed<'a> = &'a Self;
6150        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6151            value
6152        }
6153    }
6154
6155    unsafe impl fidl::encoding::TypeMarker for MlmeDisassociateConfRequest {
6156        type Owned = Self;
6157
6158        #[inline(always)]
6159        fn inline_align(_context: fidl::encoding::Context) -> usize {
6160            4
6161        }
6162
6163        #[inline(always)]
6164        fn inline_size(_context: fidl::encoding::Context) -> usize {
6165            4
6166        }
6167        #[inline(always)]
6168        fn encode_is_copy() -> bool {
6169            true
6170        }
6171
6172        #[inline(always)]
6173        fn decode_is_copy() -> bool {
6174            true
6175        }
6176    }
6177
6178    unsafe impl<D: fidl::encoding::ResourceDialect>
6179        fidl::encoding::Encode<MlmeDisassociateConfRequest, D> for &MlmeDisassociateConfRequest
6180    {
6181        #[inline]
6182        unsafe fn encode(
6183            self,
6184            encoder: &mut fidl::encoding::Encoder<'_, D>,
6185            offset: usize,
6186            _depth: fidl::encoding::Depth,
6187        ) -> fidl::Result<()> {
6188            encoder.debug_check_bounds::<MlmeDisassociateConfRequest>(offset);
6189            unsafe {
6190                // Copy the object into the buffer.
6191                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
6192                (buf_ptr as *mut MlmeDisassociateConfRequest)
6193                    .write_unaligned((self as *const MlmeDisassociateConfRequest).read());
6194                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
6195                // done second because the memcpy will write garbage to these bytes.
6196            }
6197            Ok(())
6198        }
6199    }
6200    unsafe impl<
6201        D: fidl::encoding::ResourceDialect,
6202        T0: fidl::encoding::Encode<DisassociateConfirm, D>,
6203    > fidl::encoding::Encode<MlmeDisassociateConfRequest, D> for (T0,)
6204    {
6205        #[inline]
6206        unsafe fn encode(
6207            self,
6208            encoder: &mut fidl::encoding::Encoder<'_, D>,
6209            offset: usize,
6210            depth: fidl::encoding::Depth,
6211        ) -> fidl::Result<()> {
6212            encoder.debug_check_bounds::<MlmeDisassociateConfRequest>(offset);
6213            // Zero out padding regions. There's no need to apply masks
6214            // because the unmasked parts will be overwritten by fields.
6215            // Write the fields.
6216            self.0.encode(encoder, offset + 0, depth)?;
6217            Ok(())
6218        }
6219    }
6220
6221    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6222        for MlmeDisassociateConfRequest
6223    {
6224        #[inline(always)]
6225        fn new_empty() -> Self {
6226            Self { resp: fidl::new_empty!(DisassociateConfirm, D) }
6227        }
6228
6229        #[inline]
6230        unsafe fn decode(
6231            &mut self,
6232            decoder: &mut fidl::encoding::Decoder<'_, D>,
6233            offset: usize,
6234            _depth: fidl::encoding::Depth,
6235        ) -> fidl::Result<()> {
6236            decoder.debug_check_bounds::<Self>(offset);
6237            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
6238            // Verify that padding bytes are zero.
6239            // Copy from the buffer into the object.
6240            unsafe {
6241                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
6242            }
6243            Ok(())
6244        }
6245    }
6246
6247    impl fidl::encoding::ValueTypeMarker for MlmeDisassociateIndRequest {
6248        type Borrowed<'a> = &'a Self;
6249        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6250            value
6251        }
6252    }
6253
6254    unsafe impl fidl::encoding::TypeMarker for MlmeDisassociateIndRequest {
6255        type Owned = Self;
6256
6257        #[inline(always)]
6258        fn inline_align(_context: fidl::encoding::Context) -> usize {
6259            2
6260        }
6261
6262        #[inline(always)]
6263        fn inline_size(_context: fidl::encoding::Context) -> usize {
6264            10
6265        }
6266    }
6267
6268    unsafe impl<D: fidl::encoding::ResourceDialect>
6269        fidl::encoding::Encode<MlmeDisassociateIndRequest, D> for &MlmeDisassociateIndRequest
6270    {
6271        #[inline]
6272        unsafe fn encode(
6273            self,
6274            encoder: &mut fidl::encoding::Encoder<'_, D>,
6275            offset: usize,
6276            _depth: fidl::encoding::Depth,
6277        ) -> fidl::Result<()> {
6278            encoder.debug_check_bounds::<MlmeDisassociateIndRequest>(offset);
6279            // Delegate to tuple encoding.
6280            fidl::encoding::Encode::<MlmeDisassociateIndRequest, D>::encode(
6281                (<DisassociateIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),),
6282                encoder,
6283                offset,
6284                _depth,
6285            )
6286        }
6287    }
6288    unsafe impl<
6289        D: fidl::encoding::ResourceDialect,
6290        T0: fidl::encoding::Encode<DisassociateIndication, D>,
6291    > fidl::encoding::Encode<MlmeDisassociateIndRequest, D> for (T0,)
6292    {
6293        #[inline]
6294        unsafe fn encode(
6295            self,
6296            encoder: &mut fidl::encoding::Encoder<'_, D>,
6297            offset: usize,
6298            depth: fidl::encoding::Depth,
6299        ) -> fidl::Result<()> {
6300            encoder.debug_check_bounds::<MlmeDisassociateIndRequest>(offset);
6301            // Zero out padding regions. There's no need to apply masks
6302            // because the unmasked parts will be overwritten by fields.
6303            // Write the fields.
6304            self.0.encode(encoder, offset + 0, depth)?;
6305            Ok(())
6306        }
6307    }
6308
6309    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6310        for MlmeDisassociateIndRequest
6311    {
6312        #[inline(always)]
6313        fn new_empty() -> Self {
6314            Self { ind: fidl::new_empty!(DisassociateIndication, D) }
6315        }
6316
6317        #[inline]
6318        unsafe fn decode(
6319            &mut self,
6320            decoder: &mut fidl::encoding::Decoder<'_, D>,
6321            offset: usize,
6322            _depth: fidl::encoding::Depth,
6323        ) -> fidl::Result<()> {
6324            decoder.debug_check_bounds::<Self>(offset);
6325            // Verify that padding bytes are zero.
6326            fidl::decode!(DisassociateIndication, D, &mut self.ind, decoder, offset + 0, _depth)?;
6327            Ok(())
6328        }
6329    }
6330
6331    impl fidl::encoding::ValueTypeMarker for MlmeDisassociateReqRequest {
6332        type Borrowed<'a> = &'a Self;
6333        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6334            value
6335        }
6336    }
6337
6338    unsafe impl fidl::encoding::TypeMarker for MlmeDisassociateReqRequest {
6339        type Owned = Self;
6340
6341        #[inline(always)]
6342        fn inline_align(_context: fidl::encoding::Context) -> usize {
6343            2
6344        }
6345
6346        #[inline(always)]
6347        fn inline_size(_context: fidl::encoding::Context) -> usize {
6348            8
6349        }
6350    }
6351
6352    unsafe impl<D: fidl::encoding::ResourceDialect>
6353        fidl::encoding::Encode<MlmeDisassociateReqRequest, D> for &MlmeDisassociateReqRequest
6354    {
6355        #[inline]
6356        unsafe fn encode(
6357            self,
6358            encoder: &mut fidl::encoding::Encoder<'_, D>,
6359            offset: usize,
6360            _depth: fidl::encoding::Depth,
6361        ) -> fidl::Result<()> {
6362            encoder.debug_check_bounds::<MlmeDisassociateReqRequest>(offset);
6363            // Delegate to tuple encoding.
6364            fidl::encoding::Encode::<MlmeDisassociateReqRequest, D>::encode(
6365                (<DisassociateRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
6366                encoder,
6367                offset,
6368                _depth,
6369            )
6370        }
6371    }
6372    unsafe impl<
6373        D: fidl::encoding::ResourceDialect,
6374        T0: fidl::encoding::Encode<DisassociateRequest, D>,
6375    > fidl::encoding::Encode<MlmeDisassociateReqRequest, D> for (T0,)
6376    {
6377        #[inline]
6378        unsafe fn encode(
6379            self,
6380            encoder: &mut fidl::encoding::Encoder<'_, D>,
6381            offset: usize,
6382            depth: fidl::encoding::Depth,
6383        ) -> fidl::Result<()> {
6384            encoder.debug_check_bounds::<MlmeDisassociateReqRequest>(offset);
6385            // Zero out padding regions. There's no need to apply masks
6386            // because the unmasked parts will be overwritten by fields.
6387            // Write the fields.
6388            self.0.encode(encoder, offset + 0, depth)?;
6389            Ok(())
6390        }
6391    }
6392
6393    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6394        for MlmeDisassociateReqRequest
6395    {
6396        #[inline(always)]
6397        fn new_empty() -> Self {
6398            Self { req: fidl::new_empty!(DisassociateRequest, D) }
6399        }
6400
6401        #[inline]
6402        unsafe fn decode(
6403            &mut self,
6404            decoder: &mut fidl::encoding::Decoder<'_, D>,
6405            offset: usize,
6406            _depth: fidl::encoding::Depth,
6407        ) -> fidl::Result<()> {
6408            decoder.debug_check_bounds::<Self>(offset);
6409            // Verify that padding bytes are zero.
6410            fidl::decode!(DisassociateRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
6411            Ok(())
6412        }
6413    }
6414
6415    impl fidl::encoding::ValueTypeMarker for MlmeEapolConfRequest {
6416        type Borrowed<'a> = &'a Self;
6417        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6418            value
6419        }
6420    }
6421
6422    unsafe impl fidl::encoding::TypeMarker for MlmeEapolConfRequest {
6423        type Owned = Self;
6424
6425        #[inline(always)]
6426        fn inline_align(_context: fidl::encoding::Context) -> usize {
6427            4
6428        }
6429
6430        #[inline(always)]
6431        fn inline_size(_context: fidl::encoding::Context) -> usize {
6432            12
6433        }
6434    }
6435
6436    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeEapolConfRequest, D>
6437        for &MlmeEapolConfRequest
6438    {
6439        #[inline]
6440        unsafe fn encode(
6441            self,
6442            encoder: &mut fidl::encoding::Encoder<'_, D>,
6443            offset: usize,
6444            _depth: fidl::encoding::Depth,
6445        ) -> fidl::Result<()> {
6446            encoder.debug_check_bounds::<MlmeEapolConfRequest>(offset);
6447            // Delegate to tuple encoding.
6448            fidl::encoding::Encode::<MlmeEapolConfRequest, D>::encode(
6449                (<EapolConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
6450                encoder,
6451                offset,
6452                _depth,
6453            )
6454        }
6455    }
6456    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<EapolConfirm, D>>
6457        fidl::encoding::Encode<MlmeEapolConfRequest, D> for (T0,)
6458    {
6459        #[inline]
6460        unsafe fn encode(
6461            self,
6462            encoder: &mut fidl::encoding::Encoder<'_, D>,
6463            offset: usize,
6464            depth: fidl::encoding::Depth,
6465        ) -> fidl::Result<()> {
6466            encoder.debug_check_bounds::<MlmeEapolConfRequest>(offset);
6467            // Zero out padding regions. There's no need to apply masks
6468            // because the unmasked parts will be overwritten by fields.
6469            // Write the fields.
6470            self.0.encode(encoder, offset + 0, depth)?;
6471            Ok(())
6472        }
6473    }
6474
6475    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeEapolConfRequest {
6476        #[inline(always)]
6477        fn new_empty() -> Self {
6478            Self { resp: fidl::new_empty!(EapolConfirm, D) }
6479        }
6480
6481        #[inline]
6482        unsafe fn decode(
6483            &mut self,
6484            decoder: &mut fidl::encoding::Decoder<'_, D>,
6485            offset: usize,
6486            _depth: fidl::encoding::Depth,
6487        ) -> fidl::Result<()> {
6488            decoder.debug_check_bounds::<Self>(offset);
6489            // Verify that padding bytes are zero.
6490            fidl::decode!(EapolConfirm, D, &mut self.resp, decoder, offset + 0, _depth)?;
6491            Ok(())
6492        }
6493    }
6494
6495    impl fidl::encoding::ValueTypeMarker for MlmeEapolIndRequest {
6496        type Borrowed<'a> = &'a Self;
6497        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6498            value
6499        }
6500    }
6501
6502    unsafe impl fidl::encoding::TypeMarker for MlmeEapolIndRequest {
6503        type Owned = Self;
6504
6505        #[inline(always)]
6506        fn inline_align(_context: fidl::encoding::Context) -> usize {
6507            8
6508        }
6509
6510        #[inline(always)]
6511        fn inline_size(_context: fidl::encoding::Context) -> usize {
6512            32
6513        }
6514    }
6515
6516    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeEapolIndRequest, D>
6517        for &MlmeEapolIndRequest
6518    {
6519        #[inline]
6520        unsafe fn encode(
6521            self,
6522            encoder: &mut fidl::encoding::Encoder<'_, D>,
6523            offset: usize,
6524            _depth: fidl::encoding::Depth,
6525        ) -> fidl::Result<()> {
6526            encoder.debug_check_bounds::<MlmeEapolIndRequest>(offset);
6527            // Delegate to tuple encoding.
6528            fidl::encoding::Encode::<MlmeEapolIndRequest, D>::encode(
6529                (<EapolIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),),
6530                encoder,
6531                offset,
6532                _depth,
6533            )
6534        }
6535    }
6536    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<EapolIndication, D>>
6537        fidl::encoding::Encode<MlmeEapolIndRequest, D> for (T0,)
6538    {
6539        #[inline]
6540        unsafe fn encode(
6541            self,
6542            encoder: &mut fidl::encoding::Encoder<'_, D>,
6543            offset: usize,
6544            depth: fidl::encoding::Depth,
6545        ) -> fidl::Result<()> {
6546            encoder.debug_check_bounds::<MlmeEapolIndRequest>(offset);
6547            // Zero out padding regions. There's no need to apply masks
6548            // because the unmasked parts will be overwritten by fields.
6549            // Write the fields.
6550            self.0.encode(encoder, offset + 0, depth)?;
6551            Ok(())
6552        }
6553    }
6554
6555    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeEapolIndRequest {
6556        #[inline(always)]
6557        fn new_empty() -> Self {
6558            Self { ind: fidl::new_empty!(EapolIndication, D) }
6559        }
6560
6561        #[inline]
6562        unsafe fn decode(
6563            &mut self,
6564            decoder: &mut fidl::encoding::Decoder<'_, D>,
6565            offset: usize,
6566            _depth: fidl::encoding::Depth,
6567        ) -> fidl::Result<()> {
6568            decoder.debug_check_bounds::<Self>(offset);
6569            // Verify that padding bytes are zero.
6570            fidl::decode!(EapolIndication, D, &mut self.ind, decoder, offset + 0, _depth)?;
6571            Ok(())
6572        }
6573    }
6574
6575    impl fidl::encoding::ValueTypeMarker for MlmeEapolReqRequest {
6576        type Borrowed<'a> = &'a Self;
6577        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6578            value
6579        }
6580    }
6581
6582    unsafe impl fidl::encoding::TypeMarker for MlmeEapolReqRequest {
6583        type Owned = Self;
6584
6585        #[inline(always)]
6586        fn inline_align(_context: fidl::encoding::Context) -> usize {
6587            8
6588        }
6589
6590        #[inline(always)]
6591        fn inline_size(_context: fidl::encoding::Context) -> usize {
6592            32
6593        }
6594    }
6595
6596    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeEapolReqRequest, D>
6597        for &MlmeEapolReqRequest
6598    {
6599        #[inline]
6600        unsafe fn encode(
6601            self,
6602            encoder: &mut fidl::encoding::Encoder<'_, D>,
6603            offset: usize,
6604            _depth: fidl::encoding::Depth,
6605        ) -> fidl::Result<()> {
6606            encoder.debug_check_bounds::<MlmeEapolReqRequest>(offset);
6607            // Delegate to tuple encoding.
6608            fidl::encoding::Encode::<MlmeEapolReqRequest, D>::encode(
6609                (<EapolRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
6610                encoder,
6611                offset,
6612                _depth,
6613            )
6614        }
6615    }
6616    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<EapolRequest, D>>
6617        fidl::encoding::Encode<MlmeEapolReqRequest, D> for (T0,)
6618    {
6619        #[inline]
6620        unsafe fn encode(
6621            self,
6622            encoder: &mut fidl::encoding::Encoder<'_, D>,
6623            offset: usize,
6624            depth: fidl::encoding::Depth,
6625        ) -> fidl::Result<()> {
6626            encoder.debug_check_bounds::<MlmeEapolReqRequest>(offset);
6627            // Zero out padding regions. There's no need to apply masks
6628            // because the unmasked parts will be overwritten by fields.
6629            // Write the fields.
6630            self.0.encode(encoder, offset + 0, depth)?;
6631            Ok(())
6632        }
6633    }
6634
6635    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeEapolReqRequest {
6636        #[inline(always)]
6637        fn new_empty() -> Self {
6638            Self { req: fidl::new_empty!(EapolRequest, D) }
6639        }
6640
6641        #[inline]
6642        unsafe fn decode(
6643            &mut self,
6644            decoder: &mut fidl::encoding::Decoder<'_, D>,
6645            offset: usize,
6646            _depth: fidl::encoding::Depth,
6647        ) -> fidl::Result<()> {
6648            decoder.debug_check_bounds::<Self>(offset);
6649            // Verify that padding bytes are zero.
6650            fidl::decode!(EapolRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
6651            Ok(())
6652        }
6653    }
6654
6655    impl fidl::encoding::ValueTypeMarker for MlmeFinalizeAssociationReqRequest {
6656        type Borrowed<'a> = &'a Self;
6657        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6658            value
6659        }
6660    }
6661
6662    unsafe impl fidl::encoding::TypeMarker for MlmeFinalizeAssociationReqRequest {
6663        type Owned = Self;
6664
6665        #[inline(always)]
6666        fn inline_align(_context: fidl::encoding::Context) -> usize {
6667            8
6668        }
6669
6670        #[inline(always)]
6671        fn inline_size(_context: fidl::encoding::Context) -> usize {
6672            56
6673        }
6674    }
6675
6676    unsafe impl<D: fidl::encoding::ResourceDialect>
6677        fidl::encoding::Encode<MlmeFinalizeAssociationReqRequest, D>
6678        for &MlmeFinalizeAssociationReqRequest
6679    {
6680        #[inline]
6681        unsafe fn encode(
6682            self,
6683            encoder: &mut fidl::encoding::Encoder<'_, D>,
6684            offset: usize,
6685            _depth: fidl::encoding::Depth,
6686        ) -> fidl::Result<()> {
6687            encoder.debug_check_bounds::<MlmeFinalizeAssociationReqRequest>(offset);
6688            // Delegate to tuple encoding.
6689            fidl::encoding::Encode::<MlmeFinalizeAssociationReqRequest, D>::encode(
6690                (<NegotiatedCapabilities as fidl::encoding::ValueTypeMarker>::borrow(
6691                    &self.negotiated_capabilities,
6692                ),),
6693                encoder,
6694                offset,
6695                _depth,
6696            )
6697        }
6698    }
6699    unsafe impl<
6700        D: fidl::encoding::ResourceDialect,
6701        T0: fidl::encoding::Encode<NegotiatedCapabilities, D>,
6702    > fidl::encoding::Encode<MlmeFinalizeAssociationReqRequest, D> for (T0,)
6703    {
6704        #[inline]
6705        unsafe fn encode(
6706            self,
6707            encoder: &mut fidl::encoding::Encoder<'_, D>,
6708            offset: usize,
6709            depth: fidl::encoding::Depth,
6710        ) -> fidl::Result<()> {
6711            encoder.debug_check_bounds::<MlmeFinalizeAssociationReqRequest>(offset);
6712            // Zero out padding regions. There's no need to apply masks
6713            // because the unmasked parts will be overwritten by fields.
6714            // Write the fields.
6715            self.0.encode(encoder, offset + 0, depth)?;
6716            Ok(())
6717        }
6718    }
6719
6720    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6721        for MlmeFinalizeAssociationReqRequest
6722    {
6723        #[inline(always)]
6724        fn new_empty() -> Self {
6725            Self { negotiated_capabilities: fidl::new_empty!(NegotiatedCapabilities, D) }
6726        }
6727
6728        #[inline]
6729        unsafe fn decode(
6730            &mut self,
6731            decoder: &mut fidl::encoding::Decoder<'_, D>,
6732            offset: usize,
6733            _depth: fidl::encoding::Depth,
6734        ) -> fidl::Result<()> {
6735            decoder.debug_check_bounds::<Self>(offset);
6736            // Verify that padding bytes are zero.
6737            fidl::decode!(
6738                NegotiatedCapabilities,
6739                D,
6740                &mut self.negotiated_capabilities,
6741                decoder,
6742                offset + 0,
6743                _depth
6744            )?;
6745            Ok(())
6746        }
6747    }
6748
6749    impl fidl::encoding::ValueTypeMarker for MlmeGetIfaceHistogramStatsResponse {
6750        type Borrowed<'a> = &'a Self;
6751        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6752            value
6753        }
6754    }
6755
6756    unsafe impl fidl::encoding::TypeMarker for MlmeGetIfaceHistogramStatsResponse {
6757        type Owned = Self;
6758
6759        #[inline(always)]
6760        fn inline_align(_context: fidl::encoding::Context) -> usize {
6761            8
6762        }
6763
6764        #[inline(always)]
6765        fn inline_size(_context: fidl::encoding::Context) -> usize {
6766            16
6767        }
6768    }
6769
6770    unsafe impl<D: fidl::encoding::ResourceDialect>
6771        fidl::encoding::Encode<MlmeGetIfaceHistogramStatsResponse, D>
6772        for &MlmeGetIfaceHistogramStatsResponse
6773    {
6774        #[inline]
6775        unsafe fn encode(
6776            self,
6777            encoder: &mut fidl::encoding::Encoder<'_, D>,
6778            offset: usize,
6779            _depth: fidl::encoding::Depth,
6780        ) -> fidl::Result<()> {
6781            encoder.debug_check_bounds::<MlmeGetIfaceHistogramStatsResponse>(offset);
6782            // Delegate to tuple encoding.
6783            fidl::encoding::Encode::<MlmeGetIfaceHistogramStatsResponse, D>::encode(
6784                (<GetIfaceHistogramStatsResponse as fidl::encoding::ValueTypeMarker>::borrow(
6785                    &self.resp,
6786                ),),
6787                encoder,
6788                offset,
6789                _depth,
6790            )
6791        }
6792    }
6793    unsafe impl<
6794        D: fidl::encoding::ResourceDialect,
6795        T0: fidl::encoding::Encode<GetIfaceHistogramStatsResponse, D>,
6796    > fidl::encoding::Encode<MlmeGetIfaceHistogramStatsResponse, D> for (T0,)
6797    {
6798        #[inline]
6799        unsafe fn encode(
6800            self,
6801            encoder: &mut fidl::encoding::Encoder<'_, D>,
6802            offset: usize,
6803            depth: fidl::encoding::Depth,
6804        ) -> fidl::Result<()> {
6805            encoder.debug_check_bounds::<MlmeGetIfaceHistogramStatsResponse>(offset);
6806            // Zero out padding regions. There's no need to apply masks
6807            // because the unmasked parts will be overwritten by fields.
6808            // Write the fields.
6809            self.0.encode(encoder, offset + 0, depth)?;
6810            Ok(())
6811        }
6812    }
6813
6814    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6815        for MlmeGetIfaceHistogramStatsResponse
6816    {
6817        #[inline(always)]
6818        fn new_empty() -> Self {
6819            Self { resp: fidl::new_empty!(GetIfaceHistogramStatsResponse, D) }
6820        }
6821
6822        #[inline]
6823        unsafe fn decode(
6824            &mut self,
6825            decoder: &mut fidl::encoding::Decoder<'_, D>,
6826            offset: usize,
6827            _depth: fidl::encoding::Depth,
6828        ) -> fidl::Result<()> {
6829            decoder.debug_check_bounds::<Self>(offset);
6830            // Verify that padding bytes are zero.
6831            fidl::decode!(
6832                GetIfaceHistogramStatsResponse,
6833                D,
6834                &mut self.resp,
6835                decoder,
6836                offset + 0,
6837                _depth
6838            )?;
6839            Ok(())
6840        }
6841    }
6842
6843    impl fidl::encoding::ValueTypeMarker for MlmeGetIfaceStatsResponse {
6844        type Borrowed<'a> = &'a Self;
6845        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6846            value
6847        }
6848    }
6849
6850    unsafe impl fidl::encoding::TypeMarker for MlmeGetIfaceStatsResponse {
6851        type Owned = Self;
6852
6853        #[inline(always)]
6854        fn inline_align(_context: fidl::encoding::Context) -> usize {
6855            8
6856        }
6857
6858        #[inline(always)]
6859        fn inline_size(_context: fidl::encoding::Context) -> usize {
6860            16
6861        }
6862    }
6863
6864    unsafe impl<D: fidl::encoding::ResourceDialect>
6865        fidl::encoding::Encode<MlmeGetIfaceStatsResponse, D> for &MlmeGetIfaceStatsResponse
6866    {
6867        #[inline]
6868        unsafe fn encode(
6869            self,
6870            encoder: &mut fidl::encoding::Encoder<'_, D>,
6871            offset: usize,
6872            _depth: fidl::encoding::Depth,
6873        ) -> fidl::Result<()> {
6874            encoder.debug_check_bounds::<MlmeGetIfaceStatsResponse>(offset);
6875            // Delegate to tuple encoding.
6876            fidl::encoding::Encode::<MlmeGetIfaceStatsResponse, D>::encode(
6877                (<GetIfaceStatsResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
6878                encoder,
6879                offset,
6880                _depth,
6881            )
6882        }
6883    }
6884    unsafe impl<
6885        D: fidl::encoding::ResourceDialect,
6886        T0: fidl::encoding::Encode<GetIfaceStatsResponse, D>,
6887    > fidl::encoding::Encode<MlmeGetIfaceStatsResponse, D> for (T0,)
6888    {
6889        #[inline]
6890        unsafe fn encode(
6891            self,
6892            encoder: &mut fidl::encoding::Encoder<'_, D>,
6893            offset: usize,
6894            depth: fidl::encoding::Depth,
6895        ) -> fidl::Result<()> {
6896            encoder.debug_check_bounds::<MlmeGetIfaceStatsResponse>(offset);
6897            // Zero out padding regions. There's no need to apply masks
6898            // because the unmasked parts will be overwritten by fields.
6899            // Write the fields.
6900            self.0.encode(encoder, offset + 0, depth)?;
6901            Ok(())
6902        }
6903    }
6904
6905    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6906        for MlmeGetIfaceStatsResponse
6907    {
6908        #[inline(always)]
6909        fn new_empty() -> Self {
6910            Self { resp: fidl::new_empty!(GetIfaceStatsResponse, D) }
6911        }
6912
6913        #[inline]
6914        unsafe fn decode(
6915            &mut self,
6916            decoder: &mut fidl::encoding::Decoder<'_, D>,
6917            offset: usize,
6918            _depth: fidl::encoding::Depth,
6919        ) -> fidl::Result<()> {
6920            decoder.debug_check_bounds::<Self>(offset);
6921            // Verify that padding bytes are zero.
6922            fidl::decode!(GetIfaceStatsResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
6923            Ok(())
6924        }
6925    }
6926
6927    impl fidl::encoding::ValueTypeMarker for MlmeGetMinstrelStatsRequest {
6928        type Borrowed<'a> = &'a Self;
6929        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6930            value
6931        }
6932    }
6933
6934    unsafe impl fidl::encoding::TypeMarker for MlmeGetMinstrelStatsRequest {
6935        type Owned = Self;
6936
6937        #[inline(always)]
6938        fn inline_align(_context: fidl::encoding::Context) -> usize {
6939            1
6940        }
6941
6942        #[inline(always)]
6943        fn inline_size(_context: fidl::encoding::Context) -> usize {
6944            6
6945        }
6946        #[inline(always)]
6947        fn encode_is_copy() -> bool {
6948            true
6949        }
6950
6951        #[inline(always)]
6952        fn decode_is_copy() -> bool {
6953            true
6954        }
6955    }
6956
6957    unsafe impl<D: fidl::encoding::ResourceDialect>
6958        fidl::encoding::Encode<MlmeGetMinstrelStatsRequest, D> for &MlmeGetMinstrelStatsRequest
6959    {
6960        #[inline]
6961        unsafe fn encode(
6962            self,
6963            encoder: &mut fidl::encoding::Encoder<'_, D>,
6964            offset: usize,
6965            _depth: fidl::encoding::Depth,
6966        ) -> fidl::Result<()> {
6967            encoder.debug_check_bounds::<MlmeGetMinstrelStatsRequest>(offset);
6968            unsafe {
6969                // Copy the object into the buffer.
6970                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
6971                (buf_ptr as *mut MlmeGetMinstrelStatsRequest)
6972                    .write_unaligned((self as *const MlmeGetMinstrelStatsRequest).read());
6973                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
6974                // done second because the memcpy will write garbage to these bytes.
6975            }
6976            Ok(())
6977        }
6978    }
6979    unsafe impl<
6980        D: fidl::encoding::ResourceDialect,
6981        T0: fidl::encoding::Encode<MinstrelStatsRequest, D>,
6982    > fidl::encoding::Encode<MlmeGetMinstrelStatsRequest, D> for (T0,)
6983    {
6984        #[inline]
6985        unsafe fn encode(
6986            self,
6987            encoder: &mut fidl::encoding::Encoder<'_, D>,
6988            offset: usize,
6989            depth: fidl::encoding::Depth,
6990        ) -> fidl::Result<()> {
6991            encoder.debug_check_bounds::<MlmeGetMinstrelStatsRequest>(offset);
6992            // Zero out padding regions. There's no need to apply masks
6993            // because the unmasked parts will be overwritten by fields.
6994            // Write the fields.
6995            self.0.encode(encoder, offset + 0, depth)?;
6996            Ok(())
6997        }
6998    }
6999
7000    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7001        for MlmeGetMinstrelStatsRequest
7002    {
7003        #[inline(always)]
7004        fn new_empty() -> Self {
7005            Self { req: fidl::new_empty!(MinstrelStatsRequest, D) }
7006        }
7007
7008        #[inline]
7009        unsafe fn decode(
7010            &mut self,
7011            decoder: &mut fidl::encoding::Decoder<'_, D>,
7012            offset: usize,
7013            _depth: fidl::encoding::Depth,
7014        ) -> fidl::Result<()> {
7015            decoder.debug_check_bounds::<Self>(offset);
7016            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
7017            // Verify that padding bytes are zero.
7018            // Copy from the buffer into the object.
7019            unsafe {
7020                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 6);
7021            }
7022            Ok(())
7023        }
7024    }
7025
7026    impl fidl::encoding::ValueTypeMarker for MlmeGetMinstrelStatsResponse {
7027        type Borrowed<'a> = &'a Self;
7028        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7029            value
7030        }
7031    }
7032
7033    unsafe impl fidl::encoding::TypeMarker for MlmeGetMinstrelStatsResponse {
7034        type Owned = Self;
7035
7036        #[inline(always)]
7037        fn inline_align(_context: fidl::encoding::Context) -> usize {
7038            8
7039        }
7040
7041        #[inline(always)]
7042        fn inline_size(_context: fidl::encoding::Context) -> usize {
7043            8
7044        }
7045    }
7046
7047    unsafe impl<D: fidl::encoding::ResourceDialect>
7048        fidl::encoding::Encode<MlmeGetMinstrelStatsResponse, D> for &MlmeGetMinstrelStatsResponse
7049    {
7050        #[inline]
7051        unsafe fn encode(
7052            self,
7053            encoder: &mut fidl::encoding::Encoder<'_, D>,
7054            offset: usize,
7055            _depth: fidl::encoding::Depth,
7056        ) -> fidl::Result<()> {
7057            encoder.debug_check_bounds::<MlmeGetMinstrelStatsResponse>(offset);
7058            // Delegate to tuple encoding.
7059            fidl::encoding::Encode::<MlmeGetMinstrelStatsResponse, D>::encode(
7060                (<MinstrelStatsResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
7061                encoder,
7062                offset,
7063                _depth,
7064            )
7065        }
7066    }
7067    unsafe impl<
7068        D: fidl::encoding::ResourceDialect,
7069        T0: fidl::encoding::Encode<MinstrelStatsResponse, D>,
7070    > fidl::encoding::Encode<MlmeGetMinstrelStatsResponse, D> for (T0,)
7071    {
7072        #[inline]
7073        unsafe fn encode(
7074            self,
7075            encoder: &mut fidl::encoding::Encoder<'_, D>,
7076            offset: usize,
7077            depth: fidl::encoding::Depth,
7078        ) -> fidl::Result<()> {
7079            encoder.debug_check_bounds::<MlmeGetMinstrelStatsResponse>(offset);
7080            // Zero out padding regions. There's no need to apply masks
7081            // because the unmasked parts will be overwritten by fields.
7082            // Write the fields.
7083            self.0.encode(encoder, offset + 0, depth)?;
7084            Ok(())
7085        }
7086    }
7087
7088    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7089        for MlmeGetMinstrelStatsResponse
7090    {
7091        #[inline(always)]
7092        fn new_empty() -> Self {
7093            Self { resp: fidl::new_empty!(MinstrelStatsResponse, D) }
7094        }
7095
7096        #[inline]
7097        unsafe fn decode(
7098            &mut self,
7099            decoder: &mut fidl::encoding::Decoder<'_, D>,
7100            offset: usize,
7101            _depth: fidl::encoding::Depth,
7102        ) -> fidl::Result<()> {
7103            decoder.debug_check_bounds::<Self>(offset);
7104            // Verify that padding bytes are zero.
7105            fidl::decode!(MinstrelStatsResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
7106            Ok(())
7107        }
7108    }
7109
7110    impl fidl::encoding::ValueTypeMarker for MlmeInstallApfPacketFilterRequest {
7111        type Borrowed<'a> = &'a Self;
7112        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7113            value
7114        }
7115    }
7116
7117    unsafe impl fidl::encoding::TypeMarker for MlmeInstallApfPacketFilterRequest {
7118        type Owned = Self;
7119
7120        #[inline(always)]
7121        fn inline_align(_context: fidl::encoding::Context) -> usize {
7122            8
7123        }
7124
7125        #[inline(always)]
7126        fn inline_size(_context: fidl::encoding::Context) -> usize {
7127            16
7128        }
7129    }
7130
7131    unsafe impl<D: fidl::encoding::ResourceDialect>
7132        fidl::encoding::Encode<MlmeInstallApfPacketFilterRequest, D>
7133        for &MlmeInstallApfPacketFilterRequest
7134    {
7135        #[inline]
7136        unsafe fn encode(
7137            self,
7138            encoder: &mut fidl::encoding::Encoder<'_, D>,
7139            offset: usize,
7140            _depth: fidl::encoding::Depth,
7141        ) -> fidl::Result<()> {
7142            encoder.debug_check_bounds::<MlmeInstallApfPacketFilterRequest>(offset);
7143            // Delegate to tuple encoding.
7144            fidl::encoding::Encode::<MlmeInstallApfPacketFilterRequest, D>::encode(
7145                (<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(
7146                    &self.program,
7147                ),),
7148                encoder,
7149                offset,
7150                _depth,
7151            )
7152        }
7153    }
7154    unsafe impl<
7155        D: fidl::encoding::ResourceDialect,
7156        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
7157    > fidl::encoding::Encode<MlmeInstallApfPacketFilterRequest, D> for (T0,)
7158    {
7159        #[inline]
7160        unsafe fn encode(
7161            self,
7162            encoder: &mut fidl::encoding::Encoder<'_, D>,
7163            offset: usize,
7164            depth: fidl::encoding::Depth,
7165        ) -> fidl::Result<()> {
7166            encoder.debug_check_bounds::<MlmeInstallApfPacketFilterRequest>(offset);
7167            // Zero out padding regions. There's no need to apply masks
7168            // because the unmasked parts will be overwritten by fields.
7169            // Write the fields.
7170            self.0.encode(encoder, offset + 0, depth)?;
7171            Ok(())
7172        }
7173    }
7174
7175    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7176        for MlmeInstallApfPacketFilterRequest
7177    {
7178        #[inline(always)]
7179        fn new_empty() -> Self {
7180            Self { program: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D) }
7181        }
7182
7183        #[inline]
7184        unsafe fn decode(
7185            &mut self,
7186            decoder: &mut fidl::encoding::Decoder<'_, D>,
7187            offset: usize,
7188            _depth: fidl::encoding::Depth,
7189        ) -> fidl::Result<()> {
7190            decoder.debug_check_bounds::<Self>(offset);
7191            // Verify that padding bytes are zero.
7192            fidl::decode!(
7193                fidl::encoding::UnboundedVector<u8>,
7194                D,
7195                &mut self.program,
7196                decoder,
7197                offset + 0,
7198                _depth
7199            )?;
7200            Ok(())
7201        }
7202    }
7203
7204    impl fidl::encoding::ValueTypeMarker for MlmeListMinstrelPeersResponse {
7205        type Borrowed<'a> = &'a Self;
7206        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7207            value
7208        }
7209    }
7210
7211    unsafe impl fidl::encoding::TypeMarker for MlmeListMinstrelPeersResponse {
7212        type Owned = Self;
7213
7214        #[inline(always)]
7215        fn inline_align(_context: fidl::encoding::Context) -> usize {
7216            8
7217        }
7218
7219        #[inline(always)]
7220        fn inline_size(_context: fidl::encoding::Context) -> usize {
7221            16
7222        }
7223    }
7224
7225    unsafe impl<D: fidl::encoding::ResourceDialect>
7226        fidl::encoding::Encode<MlmeListMinstrelPeersResponse, D>
7227        for &MlmeListMinstrelPeersResponse
7228    {
7229        #[inline]
7230        unsafe fn encode(
7231            self,
7232            encoder: &mut fidl::encoding::Encoder<'_, D>,
7233            offset: usize,
7234            _depth: fidl::encoding::Depth,
7235        ) -> fidl::Result<()> {
7236            encoder.debug_check_bounds::<MlmeListMinstrelPeersResponse>(offset);
7237            // Delegate to tuple encoding.
7238            fidl::encoding::Encode::<MlmeListMinstrelPeersResponse, D>::encode(
7239                (<MinstrelListResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
7240                encoder,
7241                offset,
7242                _depth,
7243            )
7244        }
7245    }
7246    unsafe impl<
7247        D: fidl::encoding::ResourceDialect,
7248        T0: fidl::encoding::Encode<MinstrelListResponse, D>,
7249    > fidl::encoding::Encode<MlmeListMinstrelPeersResponse, D> for (T0,)
7250    {
7251        #[inline]
7252        unsafe fn encode(
7253            self,
7254            encoder: &mut fidl::encoding::Encoder<'_, D>,
7255            offset: usize,
7256            depth: fidl::encoding::Depth,
7257        ) -> fidl::Result<()> {
7258            encoder.debug_check_bounds::<MlmeListMinstrelPeersResponse>(offset);
7259            // Zero out padding regions. There's no need to apply masks
7260            // because the unmasked parts will be overwritten by fields.
7261            // Write the fields.
7262            self.0.encode(encoder, offset + 0, depth)?;
7263            Ok(())
7264        }
7265    }
7266
7267    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7268        for MlmeListMinstrelPeersResponse
7269    {
7270        #[inline(always)]
7271        fn new_empty() -> Self {
7272            Self { resp: fidl::new_empty!(MinstrelListResponse, D) }
7273        }
7274
7275        #[inline]
7276        unsafe fn decode(
7277            &mut self,
7278            decoder: &mut fidl::encoding::Decoder<'_, D>,
7279            offset: usize,
7280            _depth: fidl::encoding::Depth,
7281        ) -> fidl::Result<()> {
7282            decoder.debug_check_bounds::<Self>(offset);
7283            // Verify that padding bytes are zero.
7284            fidl::decode!(MinstrelListResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
7285            Ok(())
7286        }
7287    }
7288
7289    impl fidl::encoding::ValueTypeMarker for MlmeOnChannelSwitchedRequest {
7290        type Borrowed<'a> = &'a Self;
7291        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7292            value
7293        }
7294    }
7295
7296    unsafe impl fidl::encoding::TypeMarker for MlmeOnChannelSwitchedRequest {
7297        type Owned = Self;
7298
7299        #[inline(always)]
7300        fn inline_align(_context: fidl::encoding::Context) -> usize {
7301            1
7302        }
7303
7304        #[inline(always)]
7305        fn inline_size(_context: fidl::encoding::Context) -> usize {
7306            1
7307        }
7308    }
7309
7310    unsafe impl<D: fidl::encoding::ResourceDialect>
7311        fidl::encoding::Encode<MlmeOnChannelSwitchedRequest, D> for &MlmeOnChannelSwitchedRequest
7312    {
7313        #[inline]
7314        unsafe fn encode(
7315            self,
7316            encoder: &mut fidl::encoding::Encoder<'_, D>,
7317            offset: usize,
7318            _depth: fidl::encoding::Depth,
7319        ) -> fidl::Result<()> {
7320            encoder.debug_check_bounds::<MlmeOnChannelSwitchedRequest>(offset);
7321            // Delegate to tuple encoding.
7322            fidl::encoding::Encode::<MlmeOnChannelSwitchedRequest, D>::encode(
7323                (
7324                    <fidl_fuchsia_wlan_internal__common::ChannelSwitchInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),
7325                ),
7326                encoder, offset, _depth
7327            )
7328        }
7329    }
7330    unsafe impl<
7331        D: fidl::encoding::ResourceDialect,
7332        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_internal__common::ChannelSwitchInfo, D>,
7333    > fidl::encoding::Encode<MlmeOnChannelSwitchedRequest, D> for (T0,)
7334    {
7335        #[inline]
7336        unsafe fn encode(
7337            self,
7338            encoder: &mut fidl::encoding::Encoder<'_, D>,
7339            offset: usize,
7340            depth: fidl::encoding::Depth,
7341        ) -> fidl::Result<()> {
7342            encoder.debug_check_bounds::<MlmeOnChannelSwitchedRequest>(offset);
7343            // Zero out padding regions. There's no need to apply masks
7344            // because the unmasked parts will be overwritten by fields.
7345            // Write the fields.
7346            self.0.encode(encoder, offset + 0, depth)?;
7347            Ok(())
7348        }
7349    }
7350
7351    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7352        for MlmeOnChannelSwitchedRequest
7353    {
7354        #[inline(always)]
7355        fn new_empty() -> Self {
7356            Self {
7357                info: fidl::new_empty!(fidl_fuchsia_wlan_internal__common::ChannelSwitchInfo, D),
7358            }
7359        }
7360
7361        #[inline]
7362        unsafe fn decode(
7363            &mut self,
7364            decoder: &mut fidl::encoding::Decoder<'_, D>,
7365            offset: usize,
7366            _depth: fidl::encoding::Depth,
7367        ) -> fidl::Result<()> {
7368            decoder.debug_check_bounds::<Self>(offset);
7369            // Verify that padding bytes are zero.
7370            fidl::decode!(
7371                fidl_fuchsia_wlan_internal__common::ChannelSwitchInfo,
7372                D,
7373                &mut self.info,
7374                decoder,
7375                offset + 0,
7376                _depth
7377            )?;
7378            Ok(())
7379        }
7380    }
7381
7382    impl fidl::encoding::ValueTypeMarker for MlmeOnPmkAvailableRequest {
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 MlmeOnPmkAvailableRequest {
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            32
7400        }
7401    }
7402
7403    unsafe impl<D: fidl::encoding::ResourceDialect>
7404        fidl::encoding::Encode<MlmeOnPmkAvailableRequest, D> for &MlmeOnPmkAvailableRequest
7405    {
7406        #[inline]
7407        unsafe fn encode(
7408            self,
7409            encoder: &mut fidl::encoding::Encoder<'_, D>,
7410            offset: usize,
7411            _depth: fidl::encoding::Depth,
7412        ) -> fidl::Result<()> {
7413            encoder.debug_check_bounds::<MlmeOnPmkAvailableRequest>(offset);
7414            // Delegate to tuple encoding.
7415            fidl::encoding::Encode::<MlmeOnPmkAvailableRequest, D>::encode(
7416                (<PmkInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
7417                encoder,
7418                offset,
7419                _depth,
7420            )
7421        }
7422    }
7423    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PmkInfo, D>>
7424        fidl::encoding::Encode<MlmeOnPmkAvailableRequest, D> for (T0,)
7425    {
7426        #[inline]
7427        unsafe fn encode(
7428            self,
7429            encoder: &mut fidl::encoding::Encoder<'_, D>,
7430            offset: usize,
7431            depth: fidl::encoding::Depth,
7432        ) -> fidl::Result<()> {
7433            encoder.debug_check_bounds::<MlmeOnPmkAvailableRequest>(offset);
7434            // Zero out padding regions. There's no need to apply masks
7435            // because the unmasked parts will be overwritten by fields.
7436            // Write the fields.
7437            self.0.encode(encoder, offset + 0, depth)?;
7438            Ok(())
7439        }
7440    }
7441
7442    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7443        for MlmeOnPmkAvailableRequest
7444    {
7445        #[inline(always)]
7446        fn new_empty() -> Self {
7447            Self { info: fidl::new_empty!(PmkInfo, D) }
7448        }
7449
7450        #[inline]
7451        unsafe fn decode(
7452            &mut self,
7453            decoder: &mut fidl::encoding::Decoder<'_, D>,
7454            offset: usize,
7455            _depth: fidl::encoding::Depth,
7456        ) -> fidl::Result<()> {
7457            decoder.debug_check_bounds::<Self>(offset);
7458            // Verify that padding bytes are zero.
7459            fidl::decode!(PmkInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
7460            Ok(())
7461        }
7462    }
7463
7464    impl fidl::encoding::ValueTypeMarker for MlmeOnSaeFrameRxRequest {
7465        type Borrowed<'a> = &'a Self;
7466        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7467            value
7468        }
7469    }
7470
7471    unsafe impl fidl::encoding::TypeMarker for MlmeOnSaeFrameRxRequest {
7472        type Owned = Self;
7473
7474        #[inline(always)]
7475        fn inline_align(_context: fidl::encoding::Context) -> usize {
7476            8
7477        }
7478
7479        #[inline(always)]
7480        fn inline_size(_context: fidl::encoding::Context) -> usize {
7481            32
7482        }
7483    }
7484
7485    unsafe impl<D: fidl::encoding::ResourceDialect>
7486        fidl::encoding::Encode<MlmeOnSaeFrameRxRequest, D> for &MlmeOnSaeFrameRxRequest
7487    {
7488        #[inline]
7489        unsafe fn encode(
7490            self,
7491            encoder: &mut fidl::encoding::Encoder<'_, D>,
7492            offset: usize,
7493            _depth: fidl::encoding::Depth,
7494        ) -> fidl::Result<()> {
7495            encoder.debug_check_bounds::<MlmeOnSaeFrameRxRequest>(offset);
7496            // Delegate to tuple encoding.
7497            fidl::encoding::Encode::<MlmeOnSaeFrameRxRequest, D>::encode(
7498                (<SaeFrame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
7499                encoder,
7500                offset,
7501                _depth,
7502            )
7503        }
7504    }
7505    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SaeFrame, D>>
7506        fidl::encoding::Encode<MlmeOnSaeFrameRxRequest, D> for (T0,)
7507    {
7508        #[inline]
7509        unsafe fn encode(
7510            self,
7511            encoder: &mut fidl::encoding::Encoder<'_, D>,
7512            offset: usize,
7513            depth: fidl::encoding::Depth,
7514        ) -> fidl::Result<()> {
7515            encoder.debug_check_bounds::<MlmeOnSaeFrameRxRequest>(offset);
7516            // Zero out padding regions. There's no need to apply masks
7517            // because the unmasked parts will be overwritten by fields.
7518            // Write the fields.
7519            self.0.encode(encoder, offset + 0, depth)?;
7520            Ok(())
7521        }
7522    }
7523
7524    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7525        for MlmeOnSaeFrameRxRequest
7526    {
7527        #[inline(always)]
7528        fn new_empty() -> Self {
7529            Self { frame: fidl::new_empty!(SaeFrame, D) }
7530        }
7531
7532        #[inline]
7533        unsafe fn decode(
7534            &mut self,
7535            decoder: &mut fidl::encoding::Decoder<'_, D>,
7536            offset: usize,
7537            _depth: fidl::encoding::Depth,
7538        ) -> fidl::Result<()> {
7539            decoder.debug_check_bounds::<Self>(offset);
7540            // Verify that padding bytes are zero.
7541            fidl::decode!(SaeFrame, D, &mut self.frame, decoder, offset + 0, _depth)?;
7542            Ok(())
7543        }
7544    }
7545
7546    impl fidl::encoding::ValueTypeMarker for MlmeOnSaeHandshakeIndRequest {
7547        type Borrowed<'a> = &'a Self;
7548        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7549            value
7550        }
7551    }
7552
7553    unsafe impl fidl::encoding::TypeMarker for MlmeOnSaeHandshakeIndRequest {
7554        type Owned = Self;
7555
7556        #[inline(always)]
7557        fn inline_align(_context: fidl::encoding::Context) -> usize {
7558            1
7559        }
7560
7561        #[inline(always)]
7562        fn inline_size(_context: fidl::encoding::Context) -> usize {
7563            6
7564        }
7565        #[inline(always)]
7566        fn encode_is_copy() -> bool {
7567            true
7568        }
7569
7570        #[inline(always)]
7571        fn decode_is_copy() -> bool {
7572            true
7573        }
7574    }
7575
7576    unsafe impl<D: fidl::encoding::ResourceDialect>
7577        fidl::encoding::Encode<MlmeOnSaeHandshakeIndRequest, D> for &MlmeOnSaeHandshakeIndRequest
7578    {
7579        #[inline]
7580        unsafe fn encode(
7581            self,
7582            encoder: &mut fidl::encoding::Encoder<'_, D>,
7583            offset: usize,
7584            _depth: fidl::encoding::Depth,
7585        ) -> fidl::Result<()> {
7586            encoder.debug_check_bounds::<MlmeOnSaeHandshakeIndRequest>(offset);
7587            unsafe {
7588                // Copy the object into the buffer.
7589                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
7590                (buf_ptr as *mut MlmeOnSaeHandshakeIndRequest)
7591                    .write_unaligned((self as *const MlmeOnSaeHandshakeIndRequest).read());
7592                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
7593                // done second because the memcpy will write garbage to these bytes.
7594            }
7595            Ok(())
7596        }
7597    }
7598    unsafe impl<
7599        D: fidl::encoding::ResourceDialect,
7600        T0: fidl::encoding::Encode<SaeHandshakeIndication, D>,
7601    > fidl::encoding::Encode<MlmeOnSaeHandshakeIndRequest, D> for (T0,)
7602    {
7603        #[inline]
7604        unsafe fn encode(
7605            self,
7606            encoder: &mut fidl::encoding::Encoder<'_, D>,
7607            offset: usize,
7608            depth: fidl::encoding::Depth,
7609        ) -> fidl::Result<()> {
7610            encoder.debug_check_bounds::<MlmeOnSaeHandshakeIndRequest>(offset);
7611            // Zero out padding regions. There's no need to apply masks
7612            // because the unmasked parts will be overwritten by fields.
7613            // Write the fields.
7614            self.0.encode(encoder, offset + 0, depth)?;
7615            Ok(())
7616        }
7617    }
7618
7619    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7620        for MlmeOnSaeHandshakeIndRequest
7621    {
7622        #[inline(always)]
7623        fn new_empty() -> Self {
7624            Self { ind: fidl::new_empty!(SaeHandshakeIndication, D) }
7625        }
7626
7627        #[inline]
7628        unsafe fn decode(
7629            &mut self,
7630            decoder: &mut fidl::encoding::Decoder<'_, D>,
7631            offset: usize,
7632            _depth: fidl::encoding::Depth,
7633        ) -> fidl::Result<()> {
7634            decoder.debug_check_bounds::<Self>(offset);
7635            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
7636            // Verify that padding bytes are zero.
7637            // Copy from the buffer into the object.
7638            unsafe {
7639                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 6);
7640            }
7641            Ok(())
7642        }
7643    }
7644
7645    impl fidl::encoding::ValueTypeMarker for MlmeOnScanEndRequest {
7646        type Borrowed<'a> = &'a Self;
7647        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7648            value
7649        }
7650    }
7651
7652    unsafe impl fidl::encoding::TypeMarker for MlmeOnScanEndRequest {
7653        type Owned = Self;
7654
7655        #[inline(always)]
7656        fn inline_align(_context: fidl::encoding::Context) -> usize {
7657            8
7658        }
7659
7660        #[inline(always)]
7661        fn inline_size(_context: fidl::encoding::Context) -> usize {
7662            16
7663        }
7664    }
7665
7666    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeOnScanEndRequest, D>
7667        for &MlmeOnScanEndRequest
7668    {
7669        #[inline]
7670        unsafe fn encode(
7671            self,
7672            encoder: &mut fidl::encoding::Encoder<'_, D>,
7673            offset: usize,
7674            _depth: fidl::encoding::Depth,
7675        ) -> fidl::Result<()> {
7676            encoder.debug_check_bounds::<MlmeOnScanEndRequest>(offset);
7677            // Delegate to tuple encoding.
7678            fidl::encoding::Encode::<MlmeOnScanEndRequest, D>::encode(
7679                (<ScanEnd as fidl::encoding::ValueTypeMarker>::borrow(&self.end),),
7680                encoder,
7681                offset,
7682                _depth,
7683            )
7684        }
7685    }
7686    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ScanEnd, D>>
7687        fidl::encoding::Encode<MlmeOnScanEndRequest, D> for (T0,)
7688    {
7689        #[inline]
7690        unsafe fn encode(
7691            self,
7692            encoder: &mut fidl::encoding::Encoder<'_, D>,
7693            offset: usize,
7694            depth: fidl::encoding::Depth,
7695        ) -> fidl::Result<()> {
7696            encoder.debug_check_bounds::<MlmeOnScanEndRequest>(offset);
7697            // Zero out padding regions. There's no need to apply masks
7698            // because the unmasked parts will be overwritten by fields.
7699            // Write the fields.
7700            self.0.encode(encoder, offset + 0, depth)?;
7701            Ok(())
7702        }
7703    }
7704
7705    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeOnScanEndRequest {
7706        #[inline(always)]
7707        fn new_empty() -> Self {
7708            Self { end: fidl::new_empty!(ScanEnd, D) }
7709        }
7710
7711        #[inline]
7712        unsafe fn decode(
7713            &mut self,
7714            decoder: &mut fidl::encoding::Decoder<'_, D>,
7715            offset: usize,
7716            _depth: fidl::encoding::Depth,
7717        ) -> fidl::Result<()> {
7718            decoder.debug_check_bounds::<Self>(offset);
7719            // Verify that padding bytes are zero.
7720            fidl::decode!(ScanEnd, D, &mut self.end, decoder, offset + 0, _depth)?;
7721            Ok(())
7722        }
7723    }
7724
7725    impl fidl::encoding::ValueTypeMarker for MlmeOnScanResultRequest {
7726        type Borrowed<'a> = &'a Self;
7727        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7728            value
7729        }
7730    }
7731
7732    unsafe impl fidl::encoding::TypeMarker for MlmeOnScanResultRequest {
7733        type Owned = Self;
7734
7735        #[inline(always)]
7736        fn inline_align(_context: fidl::encoding::Context) -> usize {
7737            8
7738        }
7739
7740        #[inline(always)]
7741        fn inline_size(_context: fidl::encoding::Context) -> usize {
7742            64
7743        }
7744    }
7745
7746    unsafe impl<D: fidl::encoding::ResourceDialect>
7747        fidl::encoding::Encode<MlmeOnScanResultRequest, D> for &MlmeOnScanResultRequest
7748    {
7749        #[inline]
7750        unsafe fn encode(
7751            self,
7752            encoder: &mut fidl::encoding::Encoder<'_, D>,
7753            offset: usize,
7754            _depth: fidl::encoding::Depth,
7755        ) -> fidl::Result<()> {
7756            encoder.debug_check_bounds::<MlmeOnScanResultRequest>(offset);
7757            // Delegate to tuple encoding.
7758            fidl::encoding::Encode::<MlmeOnScanResultRequest, D>::encode(
7759                (<ScanResult as fidl::encoding::ValueTypeMarker>::borrow(&self.result),),
7760                encoder,
7761                offset,
7762                _depth,
7763            )
7764        }
7765    }
7766    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ScanResult, D>>
7767        fidl::encoding::Encode<MlmeOnScanResultRequest, D> for (T0,)
7768    {
7769        #[inline]
7770        unsafe fn encode(
7771            self,
7772            encoder: &mut fidl::encoding::Encoder<'_, D>,
7773            offset: usize,
7774            depth: fidl::encoding::Depth,
7775        ) -> fidl::Result<()> {
7776            encoder.debug_check_bounds::<MlmeOnScanResultRequest>(offset);
7777            // Zero out padding regions. There's no need to apply masks
7778            // because the unmasked parts will be overwritten by fields.
7779            // Write the fields.
7780            self.0.encode(encoder, offset + 0, depth)?;
7781            Ok(())
7782        }
7783    }
7784
7785    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7786        for MlmeOnScanResultRequest
7787    {
7788        #[inline(always)]
7789        fn new_empty() -> Self {
7790            Self { result: fidl::new_empty!(ScanResult, D) }
7791        }
7792
7793        #[inline]
7794        unsafe fn decode(
7795            &mut self,
7796            decoder: &mut fidl::encoding::Decoder<'_, D>,
7797            offset: usize,
7798            _depth: fidl::encoding::Depth,
7799        ) -> fidl::Result<()> {
7800            decoder.debug_check_bounds::<Self>(offset);
7801            // Verify that padding bytes are zero.
7802            fidl::decode!(ScanResult, D, &mut self.result, decoder, offset + 0, _depth)?;
7803            Ok(())
7804        }
7805    }
7806
7807    impl fidl::encoding::ValueTypeMarker for MlmeOnScheduledScanMatchesAvailableRequest {
7808        type Borrowed<'a> = &'a Self;
7809        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7810            value
7811        }
7812    }
7813
7814    unsafe impl fidl::encoding::TypeMarker for MlmeOnScheduledScanMatchesAvailableRequest {
7815        type Owned = Self;
7816
7817        #[inline(always)]
7818        fn inline_align(_context: fidl::encoding::Context) -> usize {
7819            8
7820        }
7821
7822        #[inline(always)]
7823        fn inline_size(_context: fidl::encoding::Context) -> usize {
7824            8
7825        }
7826        #[inline(always)]
7827        fn encode_is_copy() -> bool {
7828            true
7829        }
7830
7831        #[inline(always)]
7832        fn decode_is_copy() -> bool {
7833            true
7834        }
7835    }
7836
7837    unsafe impl<D: fidl::encoding::ResourceDialect>
7838        fidl::encoding::Encode<MlmeOnScheduledScanMatchesAvailableRequest, D>
7839        for &MlmeOnScheduledScanMatchesAvailableRequest
7840    {
7841        #[inline]
7842        unsafe fn encode(
7843            self,
7844            encoder: &mut fidl::encoding::Encoder<'_, D>,
7845            offset: usize,
7846            _depth: fidl::encoding::Depth,
7847        ) -> fidl::Result<()> {
7848            encoder.debug_check_bounds::<MlmeOnScheduledScanMatchesAvailableRequest>(offset);
7849            unsafe {
7850                // Copy the object into the buffer.
7851                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
7852                (buf_ptr as *mut MlmeOnScheduledScanMatchesAvailableRequest).write_unaligned(
7853                    (self as *const MlmeOnScheduledScanMatchesAvailableRequest).read(),
7854                );
7855                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
7856                // done second because the memcpy will write garbage to these bytes.
7857            }
7858            Ok(())
7859        }
7860    }
7861    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
7862        fidl::encoding::Encode<MlmeOnScheduledScanMatchesAvailableRequest, D> for (T0,)
7863    {
7864        #[inline]
7865        unsafe fn encode(
7866            self,
7867            encoder: &mut fidl::encoding::Encoder<'_, D>,
7868            offset: usize,
7869            depth: fidl::encoding::Depth,
7870        ) -> fidl::Result<()> {
7871            encoder.debug_check_bounds::<MlmeOnScheduledScanMatchesAvailableRequest>(offset);
7872            // Zero out padding regions. There's no need to apply masks
7873            // because the unmasked parts will be overwritten by fields.
7874            // Write the fields.
7875            self.0.encode(encoder, offset + 0, depth)?;
7876            Ok(())
7877        }
7878    }
7879
7880    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7881        for MlmeOnScheduledScanMatchesAvailableRequest
7882    {
7883        #[inline(always)]
7884        fn new_empty() -> Self {
7885            Self { txn_id: fidl::new_empty!(u64, D) }
7886        }
7887
7888        #[inline]
7889        unsafe fn decode(
7890            &mut self,
7891            decoder: &mut fidl::encoding::Decoder<'_, D>,
7892            offset: usize,
7893            _depth: fidl::encoding::Depth,
7894        ) -> fidl::Result<()> {
7895            decoder.debug_check_bounds::<Self>(offset);
7896            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
7897            // Verify that padding bytes are zero.
7898            // Copy from the buffer into the object.
7899            unsafe {
7900                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
7901            }
7902            Ok(())
7903        }
7904    }
7905
7906    impl fidl::encoding::ValueTypeMarker for MlmeOnScheduledScanStoppedByFirmwareRequest {
7907        type Borrowed<'a> = &'a Self;
7908        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7909            value
7910        }
7911    }
7912
7913    unsafe impl fidl::encoding::TypeMarker for MlmeOnScheduledScanStoppedByFirmwareRequest {
7914        type Owned = Self;
7915
7916        #[inline(always)]
7917        fn inline_align(_context: fidl::encoding::Context) -> usize {
7918            8
7919        }
7920
7921        #[inline(always)]
7922        fn inline_size(_context: fidl::encoding::Context) -> usize {
7923            8
7924        }
7925        #[inline(always)]
7926        fn encode_is_copy() -> bool {
7927            true
7928        }
7929
7930        #[inline(always)]
7931        fn decode_is_copy() -> bool {
7932            true
7933        }
7934    }
7935
7936    unsafe impl<D: fidl::encoding::ResourceDialect>
7937        fidl::encoding::Encode<MlmeOnScheduledScanStoppedByFirmwareRequest, D>
7938        for &MlmeOnScheduledScanStoppedByFirmwareRequest
7939    {
7940        #[inline]
7941        unsafe fn encode(
7942            self,
7943            encoder: &mut fidl::encoding::Encoder<'_, D>,
7944            offset: usize,
7945            _depth: fidl::encoding::Depth,
7946        ) -> fidl::Result<()> {
7947            encoder.debug_check_bounds::<MlmeOnScheduledScanStoppedByFirmwareRequest>(offset);
7948            unsafe {
7949                // Copy the object into the buffer.
7950                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
7951                (buf_ptr as *mut MlmeOnScheduledScanStoppedByFirmwareRequest).write_unaligned(
7952                    (self as *const MlmeOnScheduledScanStoppedByFirmwareRequest).read(),
7953                );
7954                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
7955                // done second because the memcpy will write garbage to these bytes.
7956            }
7957            Ok(())
7958        }
7959    }
7960    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
7961        fidl::encoding::Encode<MlmeOnScheduledScanStoppedByFirmwareRequest, D> for (T0,)
7962    {
7963        #[inline]
7964        unsafe fn encode(
7965            self,
7966            encoder: &mut fidl::encoding::Encoder<'_, D>,
7967            offset: usize,
7968            depth: fidl::encoding::Depth,
7969        ) -> fidl::Result<()> {
7970            encoder.debug_check_bounds::<MlmeOnScheduledScanStoppedByFirmwareRequest>(offset);
7971            // Zero out padding regions. There's no need to apply masks
7972            // because the unmasked parts will be overwritten by fields.
7973            // Write the fields.
7974            self.0.encode(encoder, offset + 0, depth)?;
7975            Ok(())
7976        }
7977    }
7978
7979    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7980        for MlmeOnScheduledScanStoppedByFirmwareRequest
7981    {
7982        #[inline(always)]
7983        fn new_empty() -> Self {
7984            Self { txn_id: fidl::new_empty!(u64, D) }
7985        }
7986
7987        #[inline]
7988        unsafe fn decode(
7989            &mut self,
7990            decoder: &mut fidl::encoding::Decoder<'_, D>,
7991            offset: usize,
7992            _depth: fidl::encoding::Depth,
7993        ) -> fidl::Result<()> {
7994            decoder.debug_check_bounds::<Self>(offset);
7995            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
7996            // Verify that padding bytes are zero.
7997            // Copy from the buffer into the object.
7998            unsafe {
7999                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
8000            }
8001            Ok(())
8002        }
8003    }
8004
8005    impl fidl::encoding::ValueTypeMarker for MlmeOnWmmStatusRespRequest {
8006        type Borrowed<'a> = &'a Self;
8007        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8008            value
8009        }
8010    }
8011
8012    unsafe impl fidl::encoding::TypeMarker for MlmeOnWmmStatusRespRequest {
8013        type Owned = Self;
8014
8015        #[inline(always)]
8016        fn inline_align(_context: fidl::encoding::Context) -> usize {
8017            4
8018        }
8019
8020        #[inline(always)]
8021        fn inline_size(_context: fidl::encoding::Context) -> usize {
8022            40
8023        }
8024    }
8025
8026    unsafe impl<D: fidl::encoding::ResourceDialect>
8027        fidl::encoding::Encode<MlmeOnWmmStatusRespRequest, D> for &MlmeOnWmmStatusRespRequest
8028    {
8029        #[inline]
8030        unsafe fn encode(
8031            self,
8032            encoder: &mut fidl::encoding::Encoder<'_, D>,
8033            offset: usize,
8034            _depth: fidl::encoding::Depth,
8035        ) -> fidl::Result<()> {
8036            encoder.debug_check_bounds::<MlmeOnWmmStatusRespRequest>(offset);
8037            // Delegate to tuple encoding.
8038            fidl::encoding::Encode::<MlmeOnWmmStatusRespRequest, D>::encode(
8039                (
8040                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
8041                    <fidl_fuchsia_wlan_internal__common::WmmStatusResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),
8042                ),
8043                encoder, offset, _depth
8044            )
8045        }
8046    }
8047    unsafe impl<
8048        D: fidl::encoding::ResourceDialect,
8049        T0: fidl::encoding::Encode<i32, D>,
8050        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_internal__common::WmmStatusResponse, D>,
8051    > fidl::encoding::Encode<MlmeOnWmmStatusRespRequest, D> for (T0, T1)
8052    {
8053        #[inline]
8054        unsafe fn encode(
8055            self,
8056            encoder: &mut fidl::encoding::Encoder<'_, D>,
8057            offset: usize,
8058            depth: fidl::encoding::Depth,
8059        ) -> fidl::Result<()> {
8060            encoder.debug_check_bounds::<MlmeOnWmmStatusRespRequest>(offset);
8061            // Zero out padding regions. There's no need to apply masks
8062            // because the unmasked parts will be overwritten by fields.
8063            unsafe {
8064                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(36);
8065                (ptr as *mut u32).write_unaligned(0);
8066            }
8067            // Write the fields.
8068            self.0.encode(encoder, offset + 0, depth)?;
8069            self.1.encode(encoder, offset + 4, depth)?;
8070            Ok(())
8071        }
8072    }
8073
8074    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8075        for MlmeOnWmmStatusRespRequest
8076    {
8077        #[inline(always)]
8078        fn new_empty() -> Self {
8079            Self {
8080                status: fidl::new_empty!(i32, D),
8081                resp: fidl::new_empty!(fidl_fuchsia_wlan_internal__common::WmmStatusResponse, D),
8082            }
8083        }
8084
8085        #[inline]
8086        unsafe fn decode(
8087            &mut self,
8088            decoder: &mut fidl::encoding::Decoder<'_, D>,
8089            offset: usize,
8090            _depth: fidl::encoding::Depth,
8091        ) -> fidl::Result<()> {
8092            decoder.debug_check_bounds::<Self>(offset);
8093            // Verify that padding bytes are zero.
8094            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(36) };
8095            let padval = unsafe { (ptr as *const u32).read_unaligned() };
8096            let mask = 0xffff0000u32;
8097            let maskedval = padval & mask;
8098            if maskedval != 0 {
8099                return Err(fidl::Error::NonZeroPadding {
8100                    padding_start: offset + 36 + ((mask as u64).trailing_zeros() / 8) as usize,
8101                });
8102            }
8103            fidl::decode!(i32, D, &mut self.status, decoder, offset + 0, _depth)?;
8104            fidl::decode!(
8105                fidl_fuchsia_wlan_internal__common::WmmStatusResponse,
8106                D,
8107                &mut self.resp,
8108                decoder,
8109                offset + 4,
8110                _depth
8111            )?;
8112            Ok(())
8113        }
8114    }
8115
8116    impl fidl::encoding::ValueTypeMarker for MlmeQueryDeviceInfoResponse {
8117        type Borrowed<'a> = &'a Self;
8118        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8119            value
8120        }
8121    }
8122
8123    unsafe impl fidl::encoding::TypeMarker for MlmeQueryDeviceInfoResponse {
8124        type Owned = Self;
8125
8126        #[inline(always)]
8127        fn inline_align(_context: fidl::encoding::Context) -> usize {
8128            8
8129        }
8130
8131        #[inline(always)]
8132        fn inline_size(_context: fidl::encoding::Context) -> usize {
8133            40
8134        }
8135    }
8136
8137    unsafe impl<D: fidl::encoding::ResourceDialect>
8138        fidl::encoding::Encode<MlmeQueryDeviceInfoResponse, D> for &MlmeQueryDeviceInfoResponse
8139    {
8140        #[inline]
8141        unsafe fn encode(
8142            self,
8143            encoder: &mut fidl::encoding::Encoder<'_, D>,
8144            offset: usize,
8145            _depth: fidl::encoding::Depth,
8146        ) -> fidl::Result<()> {
8147            encoder.debug_check_bounds::<MlmeQueryDeviceInfoResponse>(offset);
8148            // Delegate to tuple encoding.
8149            fidl::encoding::Encode::<MlmeQueryDeviceInfoResponse, D>::encode(
8150                (<DeviceInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
8151                encoder,
8152                offset,
8153                _depth,
8154            )
8155        }
8156    }
8157    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<DeviceInfo, D>>
8158        fidl::encoding::Encode<MlmeQueryDeviceInfoResponse, D> for (T0,)
8159    {
8160        #[inline]
8161        unsafe fn encode(
8162            self,
8163            encoder: &mut fidl::encoding::Encoder<'_, D>,
8164            offset: usize,
8165            depth: fidl::encoding::Depth,
8166        ) -> fidl::Result<()> {
8167            encoder.debug_check_bounds::<MlmeQueryDeviceInfoResponse>(offset);
8168            // Zero out padding regions. There's no need to apply masks
8169            // because the unmasked parts will be overwritten by fields.
8170            // Write the fields.
8171            self.0.encode(encoder, offset + 0, depth)?;
8172            Ok(())
8173        }
8174    }
8175
8176    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8177        for MlmeQueryDeviceInfoResponse
8178    {
8179        #[inline(always)]
8180        fn new_empty() -> Self {
8181            Self { info: fidl::new_empty!(DeviceInfo, D) }
8182        }
8183
8184        #[inline]
8185        unsafe fn decode(
8186            &mut self,
8187            decoder: &mut fidl::encoding::Decoder<'_, D>,
8188            offset: usize,
8189            _depth: fidl::encoding::Depth,
8190        ) -> fidl::Result<()> {
8191            decoder.debug_check_bounds::<Self>(offset);
8192            // Verify that padding bytes are zero.
8193            fidl::decode!(DeviceInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
8194            Ok(())
8195        }
8196    }
8197
8198    impl fidl::encoding::ValueTypeMarker for MlmeReconnectReqRequest {
8199        type Borrowed<'a> = &'a Self;
8200        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8201            value
8202        }
8203    }
8204
8205    unsafe impl fidl::encoding::TypeMarker for MlmeReconnectReqRequest {
8206        type Owned = Self;
8207
8208        #[inline(always)]
8209        fn inline_align(_context: fidl::encoding::Context) -> usize {
8210            1
8211        }
8212
8213        #[inline(always)]
8214        fn inline_size(_context: fidl::encoding::Context) -> usize {
8215            6
8216        }
8217        #[inline(always)]
8218        fn encode_is_copy() -> bool {
8219            true
8220        }
8221
8222        #[inline(always)]
8223        fn decode_is_copy() -> bool {
8224            true
8225        }
8226    }
8227
8228    unsafe impl<D: fidl::encoding::ResourceDialect>
8229        fidl::encoding::Encode<MlmeReconnectReqRequest, D> for &MlmeReconnectReqRequest
8230    {
8231        #[inline]
8232        unsafe fn encode(
8233            self,
8234            encoder: &mut fidl::encoding::Encoder<'_, D>,
8235            offset: usize,
8236            _depth: fidl::encoding::Depth,
8237        ) -> fidl::Result<()> {
8238            encoder.debug_check_bounds::<MlmeReconnectReqRequest>(offset);
8239            unsafe {
8240                // Copy the object into the buffer.
8241                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
8242                (buf_ptr as *mut MlmeReconnectReqRequest)
8243                    .write_unaligned((self as *const MlmeReconnectReqRequest).read());
8244                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
8245                // done second because the memcpy will write garbage to these bytes.
8246            }
8247            Ok(())
8248        }
8249    }
8250    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ReconnectRequest, D>>
8251        fidl::encoding::Encode<MlmeReconnectReqRequest, D> for (T0,)
8252    {
8253        #[inline]
8254        unsafe fn encode(
8255            self,
8256            encoder: &mut fidl::encoding::Encoder<'_, D>,
8257            offset: usize,
8258            depth: fidl::encoding::Depth,
8259        ) -> fidl::Result<()> {
8260            encoder.debug_check_bounds::<MlmeReconnectReqRequest>(offset);
8261            // Zero out padding regions. There's no need to apply masks
8262            // because the unmasked parts will be overwritten by fields.
8263            // Write the fields.
8264            self.0.encode(encoder, offset + 0, depth)?;
8265            Ok(())
8266        }
8267    }
8268
8269    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8270        for MlmeReconnectReqRequest
8271    {
8272        #[inline(always)]
8273        fn new_empty() -> Self {
8274            Self { req: fidl::new_empty!(ReconnectRequest, D) }
8275        }
8276
8277        #[inline]
8278        unsafe fn decode(
8279            &mut self,
8280            decoder: &mut fidl::encoding::Decoder<'_, D>,
8281            offset: usize,
8282            _depth: fidl::encoding::Depth,
8283        ) -> fidl::Result<()> {
8284            decoder.debug_check_bounds::<Self>(offset);
8285            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
8286            // Verify that padding bytes are zero.
8287            // Copy from the buffer into the object.
8288            unsafe {
8289                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 6);
8290            }
8291            Ok(())
8292        }
8293    }
8294
8295    impl fidl::encoding::ValueTypeMarker for MlmeRelayCapturedFrameRequest {
8296        type Borrowed<'a> = &'a Self;
8297        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8298            value
8299        }
8300    }
8301
8302    unsafe impl fidl::encoding::TypeMarker for MlmeRelayCapturedFrameRequest {
8303        type Owned = Self;
8304
8305        #[inline(always)]
8306        fn inline_align(_context: fidl::encoding::Context) -> usize {
8307            8
8308        }
8309
8310        #[inline(always)]
8311        fn inline_size(_context: fidl::encoding::Context) -> usize {
8312            16
8313        }
8314    }
8315
8316    unsafe impl<D: fidl::encoding::ResourceDialect>
8317        fidl::encoding::Encode<MlmeRelayCapturedFrameRequest, D>
8318        for &MlmeRelayCapturedFrameRequest
8319    {
8320        #[inline]
8321        unsafe fn encode(
8322            self,
8323            encoder: &mut fidl::encoding::Encoder<'_, D>,
8324            offset: usize,
8325            _depth: fidl::encoding::Depth,
8326        ) -> fidl::Result<()> {
8327            encoder.debug_check_bounds::<MlmeRelayCapturedFrameRequest>(offset);
8328            // Delegate to tuple encoding.
8329            fidl::encoding::Encode::<MlmeRelayCapturedFrameRequest, D>::encode(
8330                (<CapturedFrameResult as fidl::encoding::ValueTypeMarker>::borrow(&self.result),),
8331                encoder,
8332                offset,
8333                _depth,
8334            )
8335        }
8336    }
8337    unsafe impl<
8338        D: fidl::encoding::ResourceDialect,
8339        T0: fidl::encoding::Encode<CapturedFrameResult, D>,
8340    > fidl::encoding::Encode<MlmeRelayCapturedFrameRequest, D> for (T0,)
8341    {
8342        #[inline]
8343        unsafe fn encode(
8344            self,
8345            encoder: &mut fidl::encoding::Encoder<'_, D>,
8346            offset: usize,
8347            depth: fidl::encoding::Depth,
8348        ) -> fidl::Result<()> {
8349            encoder.debug_check_bounds::<MlmeRelayCapturedFrameRequest>(offset);
8350            // Zero out padding regions. There's no need to apply masks
8351            // because the unmasked parts will be overwritten by fields.
8352            // Write the fields.
8353            self.0.encode(encoder, offset + 0, depth)?;
8354            Ok(())
8355        }
8356    }
8357
8358    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8359        for MlmeRelayCapturedFrameRequest
8360    {
8361        #[inline(always)]
8362        fn new_empty() -> Self {
8363            Self { result: fidl::new_empty!(CapturedFrameResult, D) }
8364        }
8365
8366        #[inline]
8367        unsafe fn decode(
8368            &mut self,
8369            decoder: &mut fidl::encoding::Decoder<'_, D>,
8370            offset: usize,
8371            _depth: fidl::encoding::Depth,
8372        ) -> fidl::Result<()> {
8373            decoder.debug_check_bounds::<Self>(offset);
8374            // Verify that padding bytes are zero.
8375            fidl::decode!(CapturedFrameResult, D, &mut self.result, decoder, offset + 0, _depth)?;
8376            Ok(())
8377        }
8378    }
8379
8380    impl fidl::encoding::ValueTypeMarker for MlmeResetReqRequest {
8381        type Borrowed<'a> = &'a Self;
8382        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8383            value
8384        }
8385    }
8386
8387    unsafe impl fidl::encoding::TypeMarker for MlmeResetReqRequest {
8388        type Owned = Self;
8389
8390        #[inline(always)]
8391        fn inline_align(_context: fidl::encoding::Context) -> usize {
8392            1
8393        }
8394
8395        #[inline(always)]
8396        fn inline_size(_context: fidl::encoding::Context) -> usize {
8397            7
8398        }
8399    }
8400
8401    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeResetReqRequest, D>
8402        for &MlmeResetReqRequest
8403    {
8404        #[inline]
8405        unsafe fn encode(
8406            self,
8407            encoder: &mut fidl::encoding::Encoder<'_, D>,
8408            offset: usize,
8409            _depth: fidl::encoding::Depth,
8410        ) -> fidl::Result<()> {
8411            encoder.debug_check_bounds::<MlmeResetReqRequest>(offset);
8412            // Delegate to tuple encoding.
8413            fidl::encoding::Encode::<MlmeResetReqRequest, D>::encode(
8414                (<ResetRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
8415                encoder,
8416                offset,
8417                _depth,
8418            )
8419        }
8420    }
8421    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ResetRequest, D>>
8422        fidl::encoding::Encode<MlmeResetReqRequest, D> for (T0,)
8423    {
8424        #[inline]
8425        unsafe fn encode(
8426            self,
8427            encoder: &mut fidl::encoding::Encoder<'_, D>,
8428            offset: usize,
8429            depth: fidl::encoding::Depth,
8430        ) -> fidl::Result<()> {
8431            encoder.debug_check_bounds::<MlmeResetReqRequest>(offset);
8432            // Zero out padding regions. There's no need to apply masks
8433            // because the unmasked parts will be overwritten by fields.
8434            // Write the fields.
8435            self.0.encode(encoder, offset + 0, depth)?;
8436            Ok(())
8437        }
8438    }
8439
8440    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeResetReqRequest {
8441        #[inline(always)]
8442        fn new_empty() -> Self {
8443            Self { req: fidl::new_empty!(ResetRequest, D) }
8444        }
8445
8446        #[inline]
8447        unsafe fn decode(
8448            &mut self,
8449            decoder: &mut fidl::encoding::Decoder<'_, D>,
8450            offset: usize,
8451            _depth: fidl::encoding::Depth,
8452        ) -> fidl::Result<()> {
8453            decoder.debug_check_bounds::<Self>(offset);
8454            // Verify that padding bytes are zero.
8455            fidl::decode!(ResetRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
8456            Ok(())
8457        }
8458    }
8459
8460    impl fidl::encoding::ValueTypeMarker for MlmeRoamConfRequest {
8461        type Borrowed<'a> = &'a Self;
8462        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8463            value
8464        }
8465    }
8466
8467    unsafe impl fidl::encoding::TypeMarker for MlmeRoamConfRequest {
8468        type Owned = Self;
8469
8470        #[inline(always)]
8471        fn inline_align(_context: fidl::encoding::Context) -> usize {
8472            8
8473        }
8474
8475        #[inline(always)]
8476        fn inline_size(_context: fidl::encoding::Context) -> usize {
8477            32
8478        }
8479    }
8480
8481    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeRoamConfRequest, D>
8482        for &MlmeRoamConfRequest
8483    {
8484        #[inline]
8485        unsafe fn encode(
8486            self,
8487            encoder: &mut fidl::encoding::Encoder<'_, D>,
8488            offset: usize,
8489            _depth: fidl::encoding::Depth,
8490        ) -> fidl::Result<()> {
8491            encoder.debug_check_bounds::<MlmeRoamConfRequest>(offset);
8492            // Delegate to tuple encoding.
8493            fidl::encoding::Encode::<MlmeRoamConfRequest, D>::encode(
8494                (<RoamConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.conf),),
8495                encoder,
8496                offset,
8497                _depth,
8498            )
8499        }
8500    }
8501    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<RoamConfirm, D>>
8502        fidl::encoding::Encode<MlmeRoamConfRequest, D> for (T0,)
8503    {
8504        #[inline]
8505        unsafe fn encode(
8506            self,
8507            encoder: &mut fidl::encoding::Encoder<'_, D>,
8508            offset: usize,
8509            depth: fidl::encoding::Depth,
8510        ) -> fidl::Result<()> {
8511            encoder.debug_check_bounds::<MlmeRoamConfRequest>(offset);
8512            // Zero out padding regions. There's no need to apply masks
8513            // because the unmasked parts will be overwritten by fields.
8514            // Write the fields.
8515            self.0.encode(encoder, offset + 0, depth)?;
8516            Ok(())
8517        }
8518    }
8519
8520    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeRoamConfRequest {
8521        #[inline(always)]
8522        fn new_empty() -> Self {
8523            Self { conf: fidl::new_empty!(RoamConfirm, D) }
8524        }
8525
8526        #[inline]
8527        unsafe fn decode(
8528            &mut self,
8529            decoder: &mut fidl::encoding::Decoder<'_, D>,
8530            offset: usize,
8531            _depth: fidl::encoding::Depth,
8532        ) -> fidl::Result<()> {
8533            decoder.debug_check_bounds::<Self>(offset);
8534            // Verify that padding bytes are zero.
8535            fidl::decode!(RoamConfirm, D, &mut self.conf, decoder, offset + 0, _depth)?;
8536            Ok(())
8537        }
8538    }
8539
8540    impl fidl::encoding::ValueTypeMarker for MlmeRoamReqRequest {
8541        type Borrowed<'a> = &'a Self;
8542        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8543            value
8544        }
8545    }
8546
8547    unsafe impl fidl::encoding::TypeMarker for MlmeRoamReqRequest {
8548        type Owned = Self;
8549
8550        #[inline(always)]
8551        fn inline_align(_context: fidl::encoding::Context) -> usize {
8552            8
8553        }
8554
8555        #[inline(always)]
8556        fn inline_size(_context: fidl::encoding::Context) -> usize {
8557            48
8558        }
8559    }
8560
8561    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeRoamReqRequest, D>
8562        for &MlmeRoamReqRequest
8563    {
8564        #[inline]
8565        unsafe fn encode(
8566            self,
8567            encoder: &mut fidl::encoding::Encoder<'_, D>,
8568            offset: usize,
8569            _depth: fidl::encoding::Depth,
8570        ) -> fidl::Result<()> {
8571            encoder.debug_check_bounds::<MlmeRoamReqRequest>(offset);
8572            // Delegate to tuple encoding.
8573            fidl::encoding::Encode::<MlmeRoamReqRequest, D>::encode(
8574                (<RoamRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
8575                encoder,
8576                offset,
8577                _depth,
8578            )
8579        }
8580    }
8581    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<RoamRequest, D>>
8582        fidl::encoding::Encode<MlmeRoamReqRequest, D> for (T0,)
8583    {
8584        #[inline]
8585        unsafe fn encode(
8586            self,
8587            encoder: &mut fidl::encoding::Encoder<'_, D>,
8588            offset: usize,
8589            depth: fidl::encoding::Depth,
8590        ) -> fidl::Result<()> {
8591            encoder.debug_check_bounds::<MlmeRoamReqRequest>(offset);
8592            // Zero out padding regions. There's no need to apply masks
8593            // because the unmasked parts will be overwritten by fields.
8594            // Write the fields.
8595            self.0.encode(encoder, offset + 0, depth)?;
8596            Ok(())
8597        }
8598    }
8599
8600    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeRoamReqRequest {
8601        #[inline(always)]
8602        fn new_empty() -> Self {
8603            Self { req: fidl::new_empty!(RoamRequest, D) }
8604        }
8605
8606        #[inline]
8607        unsafe fn decode(
8608            &mut self,
8609            decoder: &mut fidl::encoding::Decoder<'_, D>,
8610            offset: usize,
8611            _depth: fidl::encoding::Depth,
8612        ) -> fidl::Result<()> {
8613            decoder.debug_check_bounds::<Self>(offset);
8614            // Verify that padding bytes are zero.
8615            fidl::decode!(RoamRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
8616            Ok(())
8617        }
8618    }
8619
8620    impl fidl::encoding::ValueTypeMarker for MlmeRoamResultIndRequest {
8621        type Borrowed<'a> = &'a Self;
8622        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8623            value
8624        }
8625    }
8626
8627    unsafe impl fidl::encoding::TypeMarker for MlmeRoamResultIndRequest {
8628        type Owned = Self;
8629
8630        #[inline(always)]
8631        fn inline_align(_context: fidl::encoding::Context) -> usize {
8632            8
8633        }
8634
8635        #[inline(always)]
8636        fn inline_size(_context: fidl::encoding::Context) -> usize {
8637            32
8638        }
8639    }
8640
8641    unsafe impl<D: fidl::encoding::ResourceDialect>
8642        fidl::encoding::Encode<MlmeRoamResultIndRequest, D> for &MlmeRoamResultIndRequest
8643    {
8644        #[inline]
8645        unsafe fn encode(
8646            self,
8647            encoder: &mut fidl::encoding::Encoder<'_, D>,
8648            offset: usize,
8649            _depth: fidl::encoding::Depth,
8650        ) -> fidl::Result<()> {
8651            encoder.debug_check_bounds::<MlmeRoamResultIndRequest>(offset);
8652            // Delegate to tuple encoding.
8653            fidl::encoding::Encode::<MlmeRoamResultIndRequest, D>::encode(
8654                (<RoamResultIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),),
8655                encoder,
8656                offset,
8657                _depth,
8658            )
8659        }
8660    }
8661    unsafe impl<
8662        D: fidl::encoding::ResourceDialect,
8663        T0: fidl::encoding::Encode<RoamResultIndication, D>,
8664    > fidl::encoding::Encode<MlmeRoamResultIndRequest, D> for (T0,)
8665    {
8666        #[inline]
8667        unsafe fn encode(
8668            self,
8669            encoder: &mut fidl::encoding::Encoder<'_, D>,
8670            offset: usize,
8671            depth: fidl::encoding::Depth,
8672        ) -> fidl::Result<()> {
8673            encoder.debug_check_bounds::<MlmeRoamResultIndRequest>(offset);
8674            // Zero out padding regions. There's no need to apply masks
8675            // because the unmasked parts will be overwritten by fields.
8676            // Write the fields.
8677            self.0.encode(encoder, offset + 0, depth)?;
8678            Ok(())
8679        }
8680    }
8681
8682    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8683        for MlmeRoamResultIndRequest
8684    {
8685        #[inline(always)]
8686        fn new_empty() -> Self {
8687            Self { ind: fidl::new_empty!(RoamResultIndication, D) }
8688        }
8689
8690        #[inline]
8691        unsafe fn decode(
8692            &mut self,
8693            decoder: &mut fidl::encoding::Decoder<'_, D>,
8694            offset: usize,
8695            _depth: fidl::encoding::Depth,
8696        ) -> fidl::Result<()> {
8697            decoder.debug_check_bounds::<Self>(offset);
8698            // Verify that padding bytes are zero.
8699            fidl::decode!(RoamResultIndication, D, &mut self.ind, decoder, offset + 0, _depth)?;
8700            Ok(())
8701        }
8702    }
8703
8704    impl fidl::encoding::ValueTypeMarker for MlmeRoamStartIndRequest {
8705        type Borrowed<'a> = &'a Self;
8706        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8707            value
8708        }
8709    }
8710
8711    unsafe impl fidl::encoding::TypeMarker for MlmeRoamStartIndRequest {
8712        type Owned = Self;
8713
8714        #[inline(always)]
8715        fn inline_align(_context: fidl::encoding::Context) -> usize {
8716            8
8717        }
8718
8719        #[inline(always)]
8720        fn inline_size(_context: fidl::encoding::Context) -> usize {
8721            64
8722        }
8723    }
8724
8725    unsafe impl<D: fidl::encoding::ResourceDialect>
8726        fidl::encoding::Encode<MlmeRoamStartIndRequest, D> for &MlmeRoamStartIndRequest
8727    {
8728        #[inline]
8729        unsafe fn encode(
8730            self,
8731            encoder: &mut fidl::encoding::Encoder<'_, D>,
8732            offset: usize,
8733            _depth: fidl::encoding::Depth,
8734        ) -> fidl::Result<()> {
8735            encoder.debug_check_bounds::<MlmeRoamStartIndRequest>(offset);
8736            // Delegate to tuple encoding.
8737            fidl::encoding::Encode::<MlmeRoamStartIndRequest, D>::encode(
8738                (<RoamStartIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),),
8739                encoder,
8740                offset,
8741                _depth,
8742            )
8743        }
8744    }
8745    unsafe impl<
8746        D: fidl::encoding::ResourceDialect,
8747        T0: fidl::encoding::Encode<RoamStartIndication, D>,
8748    > fidl::encoding::Encode<MlmeRoamStartIndRequest, D> for (T0,)
8749    {
8750        #[inline]
8751        unsafe fn encode(
8752            self,
8753            encoder: &mut fidl::encoding::Encoder<'_, D>,
8754            offset: usize,
8755            depth: fidl::encoding::Depth,
8756        ) -> fidl::Result<()> {
8757            encoder.debug_check_bounds::<MlmeRoamStartIndRequest>(offset);
8758            // Zero out padding regions. There's no need to apply masks
8759            // because the unmasked parts will be overwritten by fields.
8760            // Write the fields.
8761            self.0.encode(encoder, offset + 0, depth)?;
8762            Ok(())
8763        }
8764    }
8765
8766    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8767        for MlmeRoamStartIndRequest
8768    {
8769        #[inline(always)]
8770        fn new_empty() -> Self {
8771            Self { ind: fidl::new_empty!(RoamStartIndication, D) }
8772        }
8773
8774        #[inline]
8775        unsafe fn decode(
8776            &mut self,
8777            decoder: &mut fidl::encoding::Decoder<'_, D>,
8778            offset: usize,
8779            _depth: fidl::encoding::Depth,
8780        ) -> fidl::Result<()> {
8781            decoder.debug_check_bounds::<Self>(offset);
8782            // Verify that padding bytes are zero.
8783            fidl::decode!(RoamStartIndication, D, &mut self.ind, decoder, offset + 0, _depth)?;
8784            Ok(())
8785        }
8786    }
8787
8788    impl fidl::encoding::ValueTypeMarker for MlmeSaeFrameTxRequest {
8789        type Borrowed<'a> = &'a Self;
8790        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8791            value
8792        }
8793    }
8794
8795    unsafe impl fidl::encoding::TypeMarker for MlmeSaeFrameTxRequest {
8796        type Owned = Self;
8797
8798        #[inline(always)]
8799        fn inline_align(_context: fidl::encoding::Context) -> usize {
8800            8
8801        }
8802
8803        #[inline(always)]
8804        fn inline_size(_context: fidl::encoding::Context) -> usize {
8805            32
8806        }
8807    }
8808
8809    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeSaeFrameTxRequest, D>
8810        for &MlmeSaeFrameTxRequest
8811    {
8812        #[inline]
8813        unsafe fn encode(
8814            self,
8815            encoder: &mut fidl::encoding::Encoder<'_, D>,
8816            offset: usize,
8817            _depth: fidl::encoding::Depth,
8818        ) -> fidl::Result<()> {
8819            encoder.debug_check_bounds::<MlmeSaeFrameTxRequest>(offset);
8820            // Delegate to tuple encoding.
8821            fidl::encoding::Encode::<MlmeSaeFrameTxRequest, D>::encode(
8822                (<SaeFrame as fidl::encoding::ValueTypeMarker>::borrow(&self.frame),),
8823                encoder,
8824                offset,
8825                _depth,
8826            )
8827        }
8828    }
8829    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SaeFrame, D>>
8830        fidl::encoding::Encode<MlmeSaeFrameTxRequest, D> for (T0,)
8831    {
8832        #[inline]
8833        unsafe fn encode(
8834            self,
8835            encoder: &mut fidl::encoding::Encoder<'_, D>,
8836            offset: usize,
8837            depth: fidl::encoding::Depth,
8838        ) -> fidl::Result<()> {
8839            encoder.debug_check_bounds::<MlmeSaeFrameTxRequest>(offset);
8840            // Zero out padding regions. There's no need to apply masks
8841            // because the unmasked parts will be overwritten by fields.
8842            // Write the fields.
8843            self.0.encode(encoder, offset + 0, depth)?;
8844            Ok(())
8845        }
8846    }
8847
8848    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeSaeFrameTxRequest {
8849        #[inline(always)]
8850        fn new_empty() -> Self {
8851            Self { frame: fidl::new_empty!(SaeFrame, D) }
8852        }
8853
8854        #[inline]
8855        unsafe fn decode(
8856            &mut self,
8857            decoder: &mut fidl::encoding::Decoder<'_, D>,
8858            offset: usize,
8859            _depth: fidl::encoding::Depth,
8860        ) -> fidl::Result<()> {
8861            decoder.debug_check_bounds::<Self>(offset);
8862            // Verify that padding bytes are zero.
8863            fidl::decode!(SaeFrame, D, &mut self.frame, decoder, offset + 0, _depth)?;
8864            Ok(())
8865        }
8866    }
8867
8868    impl fidl::encoding::ValueTypeMarker for MlmeSaeHandshakeRespRequest {
8869        type Borrowed<'a> = &'a Self;
8870        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8871            value
8872        }
8873    }
8874
8875    unsafe impl fidl::encoding::TypeMarker for MlmeSaeHandshakeRespRequest {
8876        type Owned = Self;
8877
8878        #[inline(always)]
8879        fn inline_align(_context: fidl::encoding::Context) -> usize {
8880            2
8881        }
8882
8883        #[inline(always)]
8884        fn inline_size(_context: fidl::encoding::Context) -> usize {
8885            8
8886        }
8887    }
8888
8889    unsafe impl<D: fidl::encoding::ResourceDialect>
8890        fidl::encoding::Encode<MlmeSaeHandshakeRespRequest, D> for &MlmeSaeHandshakeRespRequest
8891    {
8892        #[inline]
8893        unsafe fn encode(
8894            self,
8895            encoder: &mut fidl::encoding::Encoder<'_, D>,
8896            offset: usize,
8897            _depth: fidl::encoding::Depth,
8898        ) -> fidl::Result<()> {
8899            encoder.debug_check_bounds::<MlmeSaeHandshakeRespRequest>(offset);
8900            // Delegate to tuple encoding.
8901            fidl::encoding::Encode::<MlmeSaeHandshakeRespRequest, D>::encode(
8902                (<SaeHandshakeResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
8903                encoder,
8904                offset,
8905                _depth,
8906            )
8907        }
8908    }
8909    unsafe impl<
8910        D: fidl::encoding::ResourceDialect,
8911        T0: fidl::encoding::Encode<SaeHandshakeResponse, D>,
8912    > fidl::encoding::Encode<MlmeSaeHandshakeRespRequest, D> for (T0,)
8913    {
8914        #[inline]
8915        unsafe fn encode(
8916            self,
8917            encoder: &mut fidl::encoding::Encoder<'_, D>,
8918            offset: usize,
8919            depth: fidl::encoding::Depth,
8920        ) -> fidl::Result<()> {
8921            encoder.debug_check_bounds::<MlmeSaeHandshakeRespRequest>(offset);
8922            // Zero out padding regions. There's no need to apply masks
8923            // because the unmasked parts will be overwritten by fields.
8924            // Write the fields.
8925            self.0.encode(encoder, offset + 0, depth)?;
8926            Ok(())
8927        }
8928    }
8929
8930    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8931        for MlmeSaeHandshakeRespRequest
8932    {
8933        #[inline(always)]
8934        fn new_empty() -> Self {
8935            Self { resp: fidl::new_empty!(SaeHandshakeResponse, D) }
8936        }
8937
8938        #[inline]
8939        unsafe fn decode(
8940            &mut self,
8941            decoder: &mut fidl::encoding::Decoder<'_, D>,
8942            offset: usize,
8943            _depth: fidl::encoding::Depth,
8944        ) -> fidl::Result<()> {
8945            decoder.debug_check_bounds::<Self>(offset);
8946            // Verify that padding bytes are zero.
8947            fidl::decode!(SaeHandshakeResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
8948            Ok(())
8949        }
8950    }
8951
8952    impl fidl::encoding::ValueTypeMarker for MlmeSetApfPacketFilterEnabledRequest {
8953        type Borrowed<'a> = &'a Self;
8954        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8955            value
8956        }
8957    }
8958
8959    unsafe impl fidl::encoding::TypeMarker for MlmeSetApfPacketFilterEnabledRequest {
8960        type Owned = Self;
8961
8962        #[inline(always)]
8963        fn inline_align(_context: fidl::encoding::Context) -> usize {
8964            1
8965        }
8966
8967        #[inline(always)]
8968        fn inline_size(_context: fidl::encoding::Context) -> usize {
8969            1
8970        }
8971    }
8972
8973    unsafe impl<D: fidl::encoding::ResourceDialect>
8974        fidl::encoding::Encode<MlmeSetApfPacketFilterEnabledRequest, D>
8975        for &MlmeSetApfPacketFilterEnabledRequest
8976    {
8977        #[inline]
8978        unsafe fn encode(
8979            self,
8980            encoder: &mut fidl::encoding::Encoder<'_, D>,
8981            offset: usize,
8982            _depth: fidl::encoding::Depth,
8983        ) -> fidl::Result<()> {
8984            encoder.debug_check_bounds::<MlmeSetApfPacketFilterEnabledRequest>(offset);
8985            // Delegate to tuple encoding.
8986            fidl::encoding::Encode::<MlmeSetApfPacketFilterEnabledRequest, D>::encode(
8987                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enabled),),
8988                encoder,
8989                offset,
8990                _depth,
8991            )
8992        }
8993    }
8994    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
8995        fidl::encoding::Encode<MlmeSetApfPacketFilterEnabledRequest, D> for (T0,)
8996    {
8997        #[inline]
8998        unsafe fn encode(
8999            self,
9000            encoder: &mut fidl::encoding::Encoder<'_, D>,
9001            offset: usize,
9002            depth: fidl::encoding::Depth,
9003        ) -> fidl::Result<()> {
9004            encoder.debug_check_bounds::<MlmeSetApfPacketFilterEnabledRequest>(offset);
9005            // Zero out padding regions. There's no need to apply masks
9006            // because the unmasked parts will be overwritten by fields.
9007            // Write the fields.
9008            self.0.encode(encoder, offset + 0, depth)?;
9009            Ok(())
9010        }
9011    }
9012
9013    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9014        for MlmeSetApfPacketFilterEnabledRequest
9015    {
9016        #[inline(always)]
9017        fn new_empty() -> Self {
9018            Self { enabled: fidl::new_empty!(bool, D) }
9019        }
9020
9021        #[inline]
9022        unsafe fn decode(
9023            &mut self,
9024            decoder: &mut fidl::encoding::Decoder<'_, D>,
9025            offset: usize,
9026            _depth: fidl::encoding::Depth,
9027        ) -> fidl::Result<()> {
9028            decoder.debug_check_bounds::<Self>(offset);
9029            // Verify that padding bytes are zero.
9030            fidl::decode!(bool, D, &mut self.enabled, decoder, offset + 0, _depth)?;
9031            Ok(())
9032        }
9033    }
9034
9035    impl fidl::encoding::ValueTypeMarker for MlmeSetControlledPortRequest {
9036        type Borrowed<'a> = &'a Self;
9037        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9038            value
9039        }
9040    }
9041
9042    unsafe impl fidl::encoding::TypeMarker for MlmeSetControlledPortRequest {
9043        type Owned = Self;
9044
9045        #[inline(always)]
9046        fn inline_align(_context: fidl::encoding::Context) -> usize {
9047            4
9048        }
9049
9050        #[inline(always)]
9051        fn inline_size(_context: fidl::encoding::Context) -> usize {
9052            12
9053        }
9054    }
9055
9056    unsafe impl<D: fidl::encoding::ResourceDialect>
9057        fidl::encoding::Encode<MlmeSetControlledPortRequest, D> for &MlmeSetControlledPortRequest
9058    {
9059        #[inline]
9060        unsafe fn encode(
9061            self,
9062            encoder: &mut fidl::encoding::Encoder<'_, D>,
9063            offset: usize,
9064            _depth: fidl::encoding::Depth,
9065        ) -> fidl::Result<()> {
9066            encoder.debug_check_bounds::<MlmeSetControlledPortRequest>(offset);
9067            // Delegate to tuple encoding.
9068            fidl::encoding::Encode::<MlmeSetControlledPortRequest, D>::encode(
9069                (<SetControlledPortRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
9070                encoder,
9071                offset,
9072                _depth,
9073            )
9074        }
9075    }
9076    unsafe impl<
9077        D: fidl::encoding::ResourceDialect,
9078        T0: fidl::encoding::Encode<SetControlledPortRequest, D>,
9079    > fidl::encoding::Encode<MlmeSetControlledPortRequest, D> for (T0,)
9080    {
9081        #[inline]
9082        unsafe fn encode(
9083            self,
9084            encoder: &mut fidl::encoding::Encoder<'_, D>,
9085            offset: usize,
9086            depth: fidl::encoding::Depth,
9087        ) -> fidl::Result<()> {
9088            encoder.debug_check_bounds::<MlmeSetControlledPortRequest>(offset);
9089            // Zero out padding regions. There's no need to apply masks
9090            // because the unmasked parts will be overwritten by fields.
9091            // Write the fields.
9092            self.0.encode(encoder, offset + 0, depth)?;
9093            Ok(())
9094        }
9095    }
9096
9097    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9098        for MlmeSetControlledPortRequest
9099    {
9100        #[inline(always)]
9101        fn new_empty() -> Self {
9102            Self { req: fidl::new_empty!(SetControlledPortRequest, D) }
9103        }
9104
9105        #[inline]
9106        unsafe fn decode(
9107            &mut self,
9108            decoder: &mut fidl::encoding::Decoder<'_, D>,
9109            offset: usize,
9110            _depth: fidl::encoding::Depth,
9111        ) -> fidl::Result<()> {
9112            decoder.debug_check_bounds::<Self>(offset);
9113            // Verify that padding bytes are zero.
9114            fidl::decode!(SetControlledPortRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
9115            Ok(())
9116        }
9117    }
9118
9119    impl fidl::encoding::ValueTypeMarker for MlmeSetKeysConfRequest {
9120        type Borrowed<'a> = &'a Self;
9121        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9122            value
9123        }
9124    }
9125
9126    unsafe impl fidl::encoding::TypeMarker for MlmeSetKeysConfRequest {
9127        type Owned = Self;
9128
9129        #[inline(always)]
9130        fn inline_align(_context: fidl::encoding::Context) -> usize {
9131            8
9132        }
9133
9134        #[inline(always)]
9135        fn inline_size(_context: fidl::encoding::Context) -> usize {
9136            16
9137        }
9138    }
9139
9140    unsafe impl<D: fidl::encoding::ResourceDialect>
9141        fidl::encoding::Encode<MlmeSetKeysConfRequest, D> for &MlmeSetKeysConfRequest
9142    {
9143        #[inline]
9144        unsafe fn encode(
9145            self,
9146            encoder: &mut fidl::encoding::Encoder<'_, D>,
9147            offset: usize,
9148            _depth: fidl::encoding::Depth,
9149        ) -> fidl::Result<()> {
9150            encoder.debug_check_bounds::<MlmeSetKeysConfRequest>(offset);
9151            // Delegate to tuple encoding.
9152            fidl::encoding::Encode::<MlmeSetKeysConfRequest, D>::encode(
9153                (<SetKeysConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.conf),),
9154                encoder,
9155                offset,
9156                _depth,
9157            )
9158        }
9159    }
9160    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SetKeysConfirm, D>>
9161        fidl::encoding::Encode<MlmeSetKeysConfRequest, D> for (T0,)
9162    {
9163        #[inline]
9164        unsafe fn encode(
9165            self,
9166            encoder: &mut fidl::encoding::Encoder<'_, D>,
9167            offset: usize,
9168            depth: fidl::encoding::Depth,
9169        ) -> fidl::Result<()> {
9170            encoder.debug_check_bounds::<MlmeSetKeysConfRequest>(offset);
9171            // Zero out padding regions. There's no need to apply masks
9172            // because the unmasked parts will be overwritten by fields.
9173            // Write the fields.
9174            self.0.encode(encoder, offset + 0, depth)?;
9175            Ok(())
9176        }
9177    }
9178
9179    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9180        for MlmeSetKeysConfRequest
9181    {
9182        #[inline(always)]
9183        fn new_empty() -> Self {
9184            Self { conf: fidl::new_empty!(SetKeysConfirm, D) }
9185        }
9186
9187        #[inline]
9188        unsafe fn decode(
9189            &mut self,
9190            decoder: &mut fidl::encoding::Decoder<'_, D>,
9191            offset: usize,
9192            _depth: fidl::encoding::Depth,
9193        ) -> fidl::Result<()> {
9194            decoder.debug_check_bounds::<Self>(offset);
9195            // Verify that padding bytes are zero.
9196            fidl::decode!(SetKeysConfirm, D, &mut self.conf, decoder, offset + 0, _depth)?;
9197            Ok(())
9198        }
9199    }
9200
9201    impl fidl::encoding::ValueTypeMarker for MlmeSetKeysReqRequest {
9202        type Borrowed<'a> = &'a Self;
9203        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9204            value
9205        }
9206    }
9207
9208    unsafe impl fidl::encoding::TypeMarker for MlmeSetKeysReqRequest {
9209        type Owned = Self;
9210
9211        #[inline(always)]
9212        fn inline_align(_context: fidl::encoding::Context) -> usize {
9213            8
9214        }
9215
9216        #[inline(always)]
9217        fn inline_size(_context: fidl::encoding::Context) -> usize {
9218            16
9219        }
9220    }
9221
9222    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeSetKeysReqRequest, D>
9223        for &MlmeSetKeysReqRequest
9224    {
9225        #[inline]
9226        unsafe fn encode(
9227            self,
9228            encoder: &mut fidl::encoding::Encoder<'_, D>,
9229            offset: usize,
9230            _depth: fidl::encoding::Depth,
9231        ) -> fidl::Result<()> {
9232            encoder.debug_check_bounds::<MlmeSetKeysReqRequest>(offset);
9233            // Delegate to tuple encoding.
9234            fidl::encoding::Encode::<MlmeSetKeysReqRequest, D>::encode(
9235                (<SetKeysRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
9236                encoder,
9237                offset,
9238                _depth,
9239            )
9240        }
9241    }
9242    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SetKeysRequest, D>>
9243        fidl::encoding::Encode<MlmeSetKeysReqRequest, D> for (T0,)
9244    {
9245        #[inline]
9246        unsafe fn encode(
9247            self,
9248            encoder: &mut fidl::encoding::Encoder<'_, D>,
9249            offset: usize,
9250            depth: fidl::encoding::Depth,
9251        ) -> fidl::Result<()> {
9252            encoder.debug_check_bounds::<MlmeSetKeysReqRequest>(offset);
9253            // Zero out padding regions. There's no need to apply masks
9254            // because the unmasked parts will be overwritten by fields.
9255            // Write the fields.
9256            self.0.encode(encoder, offset + 0, depth)?;
9257            Ok(())
9258        }
9259    }
9260
9261    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeSetKeysReqRequest {
9262        #[inline(always)]
9263        fn new_empty() -> Self {
9264            Self { req: fidl::new_empty!(SetKeysRequest, D) }
9265        }
9266
9267        #[inline]
9268        unsafe fn decode(
9269            &mut self,
9270            decoder: &mut fidl::encoding::Decoder<'_, D>,
9271            offset: usize,
9272            _depth: fidl::encoding::Depth,
9273        ) -> fidl::Result<()> {
9274            decoder.debug_check_bounds::<Self>(offset);
9275            // Verify that padding bytes are zero.
9276            fidl::decode!(SetKeysRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
9277            Ok(())
9278        }
9279    }
9280
9281    impl fidl::encoding::ValueTypeMarker for MlmeSetMacAddressRequest {
9282        type Borrowed<'a> = &'a Self;
9283        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9284            value
9285        }
9286    }
9287
9288    unsafe impl fidl::encoding::TypeMarker for MlmeSetMacAddressRequest {
9289        type Owned = Self;
9290
9291        #[inline(always)]
9292        fn inline_align(_context: fidl::encoding::Context) -> usize {
9293            1
9294        }
9295
9296        #[inline(always)]
9297        fn inline_size(_context: fidl::encoding::Context) -> usize {
9298            6
9299        }
9300        #[inline(always)]
9301        fn encode_is_copy() -> bool {
9302            true
9303        }
9304
9305        #[inline(always)]
9306        fn decode_is_copy() -> bool {
9307            true
9308        }
9309    }
9310
9311    unsafe impl<D: fidl::encoding::ResourceDialect>
9312        fidl::encoding::Encode<MlmeSetMacAddressRequest, D> for &MlmeSetMacAddressRequest
9313    {
9314        #[inline]
9315        unsafe fn encode(
9316            self,
9317            encoder: &mut fidl::encoding::Encoder<'_, D>,
9318            offset: usize,
9319            _depth: fidl::encoding::Depth,
9320        ) -> fidl::Result<()> {
9321            encoder.debug_check_bounds::<MlmeSetMacAddressRequest>(offset);
9322            unsafe {
9323                // Copy the object into the buffer.
9324                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
9325                (buf_ptr as *mut MlmeSetMacAddressRequest)
9326                    .write_unaligned((self as *const MlmeSetMacAddressRequest).read());
9327                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
9328                // done second because the memcpy will write garbage to these bytes.
9329            }
9330            Ok(())
9331        }
9332    }
9333    unsafe impl<
9334        D: fidl::encoding::ResourceDialect,
9335        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
9336    > fidl::encoding::Encode<MlmeSetMacAddressRequest, D> for (T0,)
9337    {
9338        #[inline]
9339        unsafe fn encode(
9340            self,
9341            encoder: &mut fidl::encoding::Encoder<'_, D>,
9342            offset: usize,
9343            depth: fidl::encoding::Depth,
9344        ) -> fidl::Result<()> {
9345            encoder.debug_check_bounds::<MlmeSetMacAddressRequest>(offset);
9346            // Zero out padding regions. There's no need to apply masks
9347            // because the unmasked parts will be overwritten by fields.
9348            // Write the fields.
9349            self.0.encode(encoder, offset + 0, depth)?;
9350            Ok(())
9351        }
9352    }
9353
9354    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9355        for MlmeSetMacAddressRequest
9356    {
9357        #[inline(always)]
9358        fn new_empty() -> Self {
9359            Self { mac_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D) }
9360        }
9361
9362        #[inline]
9363        unsafe fn decode(
9364            &mut self,
9365            decoder: &mut fidl::encoding::Decoder<'_, D>,
9366            offset: usize,
9367            _depth: fidl::encoding::Depth,
9368        ) -> fidl::Result<()> {
9369            decoder.debug_check_bounds::<Self>(offset);
9370            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
9371            // Verify that padding bytes are zero.
9372            // Copy from the buffer into the object.
9373            unsafe {
9374                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 6);
9375            }
9376            Ok(())
9377        }
9378    }
9379
9380    impl fidl::encoding::ValueTypeMarker for MlmeSignalReportRequest {
9381        type Borrowed<'a> = &'a Self;
9382        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9383            value
9384        }
9385    }
9386
9387    unsafe impl fidl::encoding::TypeMarker for MlmeSignalReportRequest {
9388        type Owned = Self;
9389
9390        #[inline(always)]
9391        fn inline_align(_context: fidl::encoding::Context) -> usize {
9392            1
9393        }
9394
9395        #[inline(always)]
9396        fn inline_size(_context: fidl::encoding::Context) -> usize {
9397            2
9398        }
9399    }
9400
9401    unsafe impl<D: fidl::encoding::ResourceDialect>
9402        fidl::encoding::Encode<MlmeSignalReportRequest, D> for &MlmeSignalReportRequest
9403    {
9404        #[inline]
9405        unsafe fn encode(
9406            self,
9407            encoder: &mut fidl::encoding::Encoder<'_, D>,
9408            offset: usize,
9409            _depth: fidl::encoding::Depth,
9410        ) -> fidl::Result<()> {
9411            encoder.debug_check_bounds::<MlmeSignalReportRequest>(offset);
9412            // Delegate to tuple encoding.
9413            fidl::encoding::Encode::<MlmeSignalReportRequest, D>::encode(
9414                (
9415                    <fidl_fuchsia_wlan_internal__common::SignalReportIndication as fidl::encoding::ValueTypeMarker>::borrow(&self.ind),
9416                ),
9417                encoder, offset, _depth
9418            )
9419        }
9420    }
9421    unsafe impl<
9422        D: fidl::encoding::ResourceDialect,
9423        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_internal__common::SignalReportIndication, D>,
9424    > fidl::encoding::Encode<MlmeSignalReportRequest, D> for (T0,)
9425    {
9426        #[inline]
9427        unsafe fn encode(
9428            self,
9429            encoder: &mut fidl::encoding::Encoder<'_, D>,
9430            offset: usize,
9431            depth: fidl::encoding::Depth,
9432        ) -> fidl::Result<()> {
9433            encoder.debug_check_bounds::<MlmeSignalReportRequest>(offset);
9434            // Zero out padding regions. There's no need to apply masks
9435            // because the unmasked parts will be overwritten by fields.
9436            // Write the fields.
9437            self.0.encode(encoder, offset + 0, depth)?;
9438            Ok(())
9439        }
9440    }
9441
9442    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9443        for MlmeSignalReportRequest
9444    {
9445        #[inline(always)]
9446        fn new_empty() -> Self {
9447            Self {
9448                ind: fidl::new_empty!(
9449                    fidl_fuchsia_wlan_internal__common::SignalReportIndication,
9450                    D
9451                ),
9452            }
9453        }
9454
9455        #[inline]
9456        unsafe fn decode(
9457            &mut self,
9458            decoder: &mut fidl::encoding::Decoder<'_, D>,
9459            offset: usize,
9460            _depth: fidl::encoding::Depth,
9461        ) -> fidl::Result<()> {
9462            decoder.debug_check_bounds::<Self>(offset);
9463            // Verify that padding bytes are zero.
9464            fidl::decode!(
9465                fidl_fuchsia_wlan_internal__common::SignalReportIndication,
9466                D,
9467                &mut self.ind,
9468                decoder,
9469                offset + 0,
9470                _depth
9471            )?;
9472            Ok(())
9473        }
9474    }
9475
9476    impl fidl::encoding::ValueTypeMarker for MlmeStartCaptureFramesRequest {
9477        type Borrowed<'a> = &'a Self;
9478        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9479            value
9480        }
9481    }
9482
9483    unsafe impl fidl::encoding::TypeMarker for MlmeStartCaptureFramesRequest {
9484        type Owned = Self;
9485
9486        #[inline(always)]
9487        fn inline_align(_context: fidl::encoding::Context) -> usize {
9488            4
9489        }
9490
9491        #[inline(always)]
9492        fn inline_size(_context: fidl::encoding::Context) -> usize {
9493            4
9494        }
9495    }
9496
9497    unsafe impl<D: fidl::encoding::ResourceDialect>
9498        fidl::encoding::Encode<MlmeStartCaptureFramesRequest, D>
9499        for &MlmeStartCaptureFramesRequest
9500    {
9501        #[inline]
9502        unsafe fn encode(
9503            self,
9504            encoder: &mut fidl::encoding::Encoder<'_, D>,
9505            offset: usize,
9506            _depth: fidl::encoding::Depth,
9507        ) -> fidl::Result<()> {
9508            encoder.debug_check_bounds::<MlmeStartCaptureFramesRequest>(offset);
9509            // Delegate to tuple encoding.
9510            fidl::encoding::Encode::<MlmeStartCaptureFramesRequest, D>::encode(
9511                (<StartCaptureFramesRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
9512                encoder,
9513                offset,
9514                _depth,
9515            )
9516        }
9517    }
9518    unsafe impl<
9519        D: fidl::encoding::ResourceDialect,
9520        T0: fidl::encoding::Encode<StartCaptureFramesRequest, D>,
9521    > fidl::encoding::Encode<MlmeStartCaptureFramesRequest, D> for (T0,)
9522    {
9523        #[inline]
9524        unsafe fn encode(
9525            self,
9526            encoder: &mut fidl::encoding::Encoder<'_, D>,
9527            offset: usize,
9528            depth: fidl::encoding::Depth,
9529        ) -> fidl::Result<()> {
9530            encoder.debug_check_bounds::<MlmeStartCaptureFramesRequest>(offset);
9531            // Zero out padding regions. There's no need to apply masks
9532            // because the unmasked parts will be overwritten by fields.
9533            // Write the fields.
9534            self.0.encode(encoder, offset + 0, depth)?;
9535            Ok(())
9536        }
9537    }
9538
9539    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9540        for MlmeStartCaptureFramesRequest
9541    {
9542        #[inline(always)]
9543        fn new_empty() -> Self {
9544            Self { req: fidl::new_empty!(StartCaptureFramesRequest, D) }
9545        }
9546
9547        #[inline]
9548        unsafe fn decode(
9549            &mut self,
9550            decoder: &mut fidl::encoding::Decoder<'_, D>,
9551            offset: usize,
9552            _depth: fidl::encoding::Depth,
9553        ) -> fidl::Result<()> {
9554            decoder.debug_check_bounds::<Self>(offset);
9555            // Verify that padding bytes are zero.
9556            fidl::decode!(
9557                StartCaptureFramesRequest,
9558                D,
9559                &mut self.req,
9560                decoder,
9561                offset + 0,
9562                _depth
9563            )?;
9564            Ok(())
9565        }
9566    }
9567
9568    impl fidl::encoding::ValueTypeMarker for MlmeStartCaptureFramesResponse {
9569        type Borrowed<'a> = &'a Self;
9570        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9571            value
9572        }
9573    }
9574
9575    unsafe impl fidl::encoding::TypeMarker for MlmeStartCaptureFramesResponse {
9576        type Owned = Self;
9577
9578        #[inline(always)]
9579        fn inline_align(_context: fidl::encoding::Context) -> usize {
9580            4
9581        }
9582
9583        #[inline(always)]
9584        fn inline_size(_context: fidl::encoding::Context) -> usize {
9585            8
9586        }
9587    }
9588
9589    unsafe impl<D: fidl::encoding::ResourceDialect>
9590        fidl::encoding::Encode<MlmeStartCaptureFramesResponse, D>
9591        for &MlmeStartCaptureFramesResponse
9592    {
9593        #[inline]
9594        unsafe fn encode(
9595            self,
9596            encoder: &mut fidl::encoding::Encoder<'_, D>,
9597            offset: usize,
9598            _depth: fidl::encoding::Depth,
9599        ) -> fidl::Result<()> {
9600            encoder.debug_check_bounds::<MlmeStartCaptureFramesResponse>(offset);
9601            // Delegate to tuple encoding.
9602            fidl::encoding::Encode::<MlmeStartCaptureFramesResponse, D>::encode(
9603                (<StartCaptureFramesResponse as fidl::encoding::ValueTypeMarker>::borrow(
9604                    &self.resp,
9605                ),),
9606                encoder,
9607                offset,
9608                _depth,
9609            )
9610        }
9611    }
9612    unsafe impl<
9613        D: fidl::encoding::ResourceDialect,
9614        T0: fidl::encoding::Encode<StartCaptureFramesResponse, D>,
9615    > fidl::encoding::Encode<MlmeStartCaptureFramesResponse, D> for (T0,)
9616    {
9617        #[inline]
9618        unsafe fn encode(
9619            self,
9620            encoder: &mut fidl::encoding::Encoder<'_, D>,
9621            offset: usize,
9622            depth: fidl::encoding::Depth,
9623        ) -> fidl::Result<()> {
9624            encoder.debug_check_bounds::<MlmeStartCaptureFramesResponse>(offset);
9625            // Zero out padding regions. There's no need to apply masks
9626            // because the unmasked parts will be overwritten by fields.
9627            // Write the fields.
9628            self.0.encode(encoder, offset + 0, depth)?;
9629            Ok(())
9630        }
9631    }
9632
9633    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9634        for MlmeStartCaptureFramesResponse
9635    {
9636        #[inline(always)]
9637        fn new_empty() -> Self {
9638            Self { resp: fidl::new_empty!(StartCaptureFramesResponse, D) }
9639        }
9640
9641        #[inline]
9642        unsafe fn decode(
9643            &mut self,
9644            decoder: &mut fidl::encoding::Decoder<'_, D>,
9645            offset: usize,
9646            _depth: fidl::encoding::Depth,
9647        ) -> fidl::Result<()> {
9648            decoder.debug_check_bounds::<Self>(offset);
9649            // Verify that padding bytes are zero.
9650            fidl::decode!(
9651                StartCaptureFramesResponse,
9652                D,
9653                &mut self.resp,
9654                decoder,
9655                offset + 0,
9656                _depth
9657            )?;
9658            Ok(())
9659        }
9660    }
9661
9662    impl fidl::encoding::ValueTypeMarker for MlmeStartConfRequest {
9663        type Borrowed<'a> = &'a Self;
9664        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9665            value
9666        }
9667    }
9668
9669    unsafe impl fidl::encoding::TypeMarker for MlmeStartConfRequest {
9670        type Owned = Self;
9671
9672        #[inline(always)]
9673        fn inline_align(_context: fidl::encoding::Context) -> usize {
9674            4
9675        }
9676
9677        #[inline(always)]
9678        fn inline_size(_context: fidl::encoding::Context) -> usize {
9679            4
9680        }
9681    }
9682
9683    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeStartConfRequest, D>
9684        for &MlmeStartConfRequest
9685    {
9686        #[inline]
9687        unsafe fn encode(
9688            self,
9689            encoder: &mut fidl::encoding::Encoder<'_, D>,
9690            offset: usize,
9691            _depth: fidl::encoding::Depth,
9692        ) -> fidl::Result<()> {
9693            encoder.debug_check_bounds::<MlmeStartConfRequest>(offset);
9694            // Delegate to tuple encoding.
9695            fidl::encoding::Encode::<MlmeStartConfRequest, D>::encode(
9696                (<StartConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
9697                encoder,
9698                offset,
9699                _depth,
9700            )
9701        }
9702    }
9703    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StartConfirm, D>>
9704        fidl::encoding::Encode<MlmeStartConfRequest, D> for (T0,)
9705    {
9706        #[inline]
9707        unsafe fn encode(
9708            self,
9709            encoder: &mut fidl::encoding::Encoder<'_, D>,
9710            offset: usize,
9711            depth: fidl::encoding::Depth,
9712        ) -> fidl::Result<()> {
9713            encoder.debug_check_bounds::<MlmeStartConfRequest>(offset);
9714            // Zero out padding regions. There's no need to apply masks
9715            // because the unmasked parts will be overwritten by fields.
9716            // Write the fields.
9717            self.0.encode(encoder, offset + 0, depth)?;
9718            Ok(())
9719        }
9720    }
9721
9722    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeStartConfRequest {
9723        #[inline(always)]
9724        fn new_empty() -> Self {
9725            Self { resp: fidl::new_empty!(StartConfirm, D) }
9726        }
9727
9728        #[inline]
9729        unsafe fn decode(
9730            &mut self,
9731            decoder: &mut fidl::encoding::Decoder<'_, D>,
9732            offset: usize,
9733            _depth: fidl::encoding::Depth,
9734        ) -> fidl::Result<()> {
9735            decoder.debug_check_bounds::<Self>(offset);
9736            // Verify that padding bytes are zero.
9737            fidl::decode!(StartConfirm, D, &mut self.resp, decoder, offset + 0, _depth)?;
9738            Ok(())
9739        }
9740    }
9741
9742    impl fidl::encoding::ValueTypeMarker for MlmeStartReqRequest {
9743        type Borrowed<'a> = &'a Self;
9744        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9745            value
9746        }
9747    }
9748
9749    unsafe impl fidl::encoding::TypeMarker for MlmeStartReqRequest {
9750        type Owned = Self;
9751
9752        #[inline(always)]
9753        fn inline_align(_context: fidl::encoding::Context) -> usize {
9754            8
9755        }
9756
9757        #[inline(always)]
9758        fn inline_size(_context: fidl::encoding::Context) -> usize {
9759            96
9760        }
9761    }
9762
9763    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeStartReqRequest, D>
9764        for &MlmeStartReqRequest
9765    {
9766        #[inline]
9767        unsafe fn encode(
9768            self,
9769            encoder: &mut fidl::encoding::Encoder<'_, D>,
9770            offset: usize,
9771            _depth: fidl::encoding::Depth,
9772        ) -> fidl::Result<()> {
9773            encoder.debug_check_bounds::<MlmeStartReqRequest>(offset);
9774            // Delegate to tuple encoding.
9775            fidl::encoding::Encode::<MlmeStartReqRequest, D>::encode(
9776                (<StartRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
9777                encoder,
9778                offset,
9779                _depth,
9780            )
9781        }
9782    }
9783    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StartRequest, D>>
9784        fidl::encoding::Encode<MlmeStartReqRequest, D> for (T0,)
9785    {
9786        #[inline]
9787        unsafe fn encode(
9788            self,
9789            encoder: &mut fidl::encoding::Encoder<'_, D>,
9790            offset: usize,
9791            depth: fidl::encoding::Depth,
9792        ) -> fidl::Result<()> {
9793            encoder.debug_check_bounds::<MlmeStartReqRequest>(offset);
9794            // Zero out padding regions. There's no need to apply masks
9795            // because the unmasked parts will be overwritten by fields.
9796            // Write the fields.
9797            self.0.encode(encoder, offset + 0, depth)?;
9798            Ok(())
9799        }
9800    }
9801
9802    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeStartReqRequest {
9803        #[inline(always)]
9804        fn new_empty() -> Self {
9805            Self { req: fidl::new_empty!(StartRequest, D) }
9806        }
9807
9808        #[inline]
9809        unsafe fn decode(
9810            &mut self,
9811            decoder: &mut fidl::encoding::Decoder<'_, D>,
9812            offset: usize,
9813            _depth: fidl::encoding::Depth,
9814        ) -> fidl::Result<()> {
9815            decoder.debug_check_bounds::<Self>(offset);
9816            // Verify that padding bytes are zero.
9817            fidl::decode!(StartRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
9818            Ok(())
9819        }
9820    }
9821
9822    impl fidl::encoding::ValueTypeMarker for MlmeStartScanRequest {
9823        type Borrowed<'a> = &'a Self;
9824        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9825            value
9826        }
9827    }
9828
9829    unsafe impl fidl::encoding::TypeMarker for MlmeStartScanRequest {
9830        type Owned = Self;
9831
9832        #[inline(always)]
9833        fn inline_align(_context: fidl::encoding::Context) -> usize {
9834            8
9835        }
9836
9837        #[inline(always)]
9838        fn inline_size(_context: fidl::encoding::Context) -> usize {
9839            64
9840        }
9841    }
9842
9843    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeStartScanRequest, D>
9844        for &MlmeStartScanRequest
9845    {
9846        #[inline]
9847        unsafe fn encode(
9848            self,
9849            encoder: &mut fidl::encoding::Encoder<'_, D>,
9850            offset: usize,
9851            _depth: fidl::encoding::Depth,
9852        ) -> fidl::Result<()> {
9853            encoder.debug_check_bounds::<MlmeStartScanRequest>(offset);
9854            // Delegate to tuple encoding.
9855            fidl::encoding::Encode::<MlmeStartScanRequest, D>::encode(
9856                (<ScanRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
9857                encoder,
9858                offset,
9859                _depth,
9860            )
9861        }
9862    }
9863    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ScanRequest, D>>
9864        fidl::encoding::Encode<MlmeStartScanRequest, D> for (T0,)
9865    {
9866        #[inline]
9867        unsafe fn encode(
9868            self,
9869            encoder: &mut fidl::encoding::Encoder<'_, D>,
9870            offset: usize,
9871            depth: fidl::encoding::Depth,
9872        ) -> fidl::Result<()> {
9873            encoder.debug_check_bounds::<MlmeStartScanRequest>(offset);
9874            // Zero out padding regions. There's no need to apply masks
9875            // because the unmasked parts will be overwritten by fields.
9876            // Write the fields.
9877            self.0.encode(encoder, offset + 0, depth)?;
9878            Ok(())
9879        }
9880    }
9881
9882    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeStartScanRequest {
9883        #[inline(always)]
9884        fn new_empty() -> Self {
9885            Self { req: fidl::new_empty!(ScanRequest, D) }
9886        }
9887
9888        #[inline]
9889        unsafe fn decode(
9890            &mut self,
9891            decoder: &mut fidl::encoding::Decoder<'_, D>,
9892            offset: usize,
9893            _depth: fidl::encoding::Depth,
9894        ) -> fidl::Result<()> {
9895            decoder.debug_check_bounds::<Self>(offset);
9896            // Verify that padding bytes are zero.
9897            fidl::decode!(ScanRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
9898            Ok(())
9899        }
9900    }
9901
9902    impl fidl::encoding::ValueTypeMarker for MlmeStartScheduledScanRequest {
9903        type Borrowed<'a> = &'a Self;
9904        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9905            value
9906        }
9907    }
9908
9909    unsafe impl fidl::encoding::TypeMarker for MlmeStartScheduledScanRequest {
9910        type Owned = Self;
9911
9912        #[inline(always)]
9913        fn inline_align(_context: fidl::encoding::Context) -> usize {
9914            8
9915        }
9916
9917        #[inline(always)]
9918        fn inline_size(_context: fidl::encoding::Context) -> usize {
9919            24
9920        }
9921    }
9922
9923    unsafe impl<D: fidl::encoding::ResourceDialect>
9924        fidl::encoding::Encode<MlmeStartScheduledScanRequest, D>
9925        for &MlmeStartScheduledScanRequest
9926    {
9927        #[inline]
9928        unsafe fn encode(
9929            self,
9930            encoder: &mut fidl::encoding::Encoder<'_, D>,
9931            offset: usize,
9932            _depth: fidl::encoding::Depth,
9933        ) -> fidl::Result<()> {
9934            encoder.debug_check_bounds::<MlmeStartScheduledScanRequest>(offset);
9935            // Delegate to tuple encoding.
9936            fidl::encoding::Encode::<MlmeStartScheduledScanRequest, D>::encode(
9937                (
9938                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.txn_id),
9939                    <fidl_fuchsia_wlan_common__common::ScheduledScanRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),
9940                ),
9941                encoder, offset, _depth
9942            )
9943        }
9944    }
9945    unsafe impl<
9946        D: fidl::encoding::ResourceDialect,
9947        T0: fidl::encoding::Encode<u64, D>,
9948        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::ScheduledScanRequest, D>,
9949    > fidl::encoding::Encode<MlmeStartScheduledScanRequest, D> for (T0, T1)
9950    {
9951        #[inline]
9952        unsafe fn encode(
9953            self,
9954            encoder: &mut fidl::encoding::Encoder<'_, D>,
9955            offset: usize,
9956            depth: fidl::encoding::Depth,
9957        ) -> fidl::Result<()> {
9958            encoder.debug_check_bounds::<MlmeStartScheduledScanRequest>(offset);
9959            // Zero out padding regions. There's no need to apply masks
9960            // because the unmasked parts will be overwritten by fields.
9961            // Write the fields.
9962            self.0.encode(encoder, offset + 0, depth)?;
9963            self.1.encode(encoder, offset + 8, depth)?;
9964            Ok(())
9965        }
9966    }
9967
9968    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9969        for MlmeStartScheduledScanRequest
9970    {
9971        #[inline(always)]
9972        fn new_empty() -> Self {
9973            Self {
9974                txn_id: fidl::new_empty!(u64, D),
9975                req: fidl::new_empty!(fidl_fuchsia_wlan_common__common::ScheduledScanRequest, D),
9976            }
9977        }
9978
9979        #[inline]
9980        unsafe fn decode(
9981            &mut self,
9982            decoder: &mut fidl::encoding::Decoder<'_, D>,
9983            offset: usize,
9984            _depth: fidl::encoding::Depth,
9985        ) -> fidl::Result<()> {
9986            decoder.debug_check_bounds::<Self>(offset);
9987            // Verify that padding bytes are zero.
9988            fidl::decode!(u64, D, &mut self.txn_id, decoder, offset + 0, _depth)?;
9989            fidl::decode!(
9990                fidl_fuchsia_wlan_common__common::ScheduledScanRequest,
9991                D,
9992                &mut self.req,
9993                decoder,
9994                offset + 8,
9995                _depth
9996            )?;
9997            Ok(())
9998        }
9999    }
10000
10001    impl fidl::encoding::ValueTypeMarker for MlmeStopConfRequest {
10002        type Borrowed<'a> = &'a Self;
10003        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10004            value
10005        }
10006    }
10007
10008    unsafe impl fidl::encoding::TypeMarker for MlmeStopConfRequest {
10009        type Owned = Self;
10010
10011        #[inline(always)]
10012        fn inline_align(_context: fidl::encoding::Context) -> usize {
10013            4
10014        }
10015
10016        #[inline(always)]
10017        fn inline_size(_context: fidl::encoding::Context) -> usize {
10018            4
10019        }
10020    }
10021
10022    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeStopConfRequest, D>
10023        for &MlmeStopConfRequest
10024    {
10025        #[inline]
10026        unsafe fn encode(
10027            self,
10028            encoder: &mut fidl::encoding::Encoder<'_, D>,
10029            offset: usize,
10030            _depth: fidl::encoding::Depth,
10031        ) -> fidl::Result<()> {
10032            encoder.debug_check_bounds::<MlmeStopConfRequest>(offset);
10033            // Delegate to tuple encoding.
10034            fidl::encoding::Encode::<MlmeStopConfRequest, D>::encode(
10035                (<StopConfirm as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
10036                encoder,
10037                offset,
10038                _depth,
10039            )
10040        }
10041    }
10042    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StopConfirm, D>>
10043        fidl::encoding::Encode<MlmeStopConfRequest, D> for (T0,)
10044    {
10045        #[inline]
10046        unsafe fn encode(
10047            self,
10048            encoder: &mut fidl::encoding::Encoder<'_, D>,
10049            offset: usize,
10050            depth: fidl::encoding::Depth,
10051        ) -> fidl::Result<()> {
10052            encoder.debug_check_bounds::<MlmeStopConfRequest>(offset);
10053            // Zero out padding regions. There's no need to apply masks
10054            // because the unmasked parts will be overwritten by fields.
10055            // Write the fields.
10056            self.0.encode(encoder, offset + 0, depth)?;
10057            Ok(())
10058        }
10059    }
10060
10061    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeStopConfRequest {
10062        #[inline(always)]
10063        fn new_empty() -> Self {
10064            Self { resp: fidl::new_empty!(StopConfirm, D) }
10065        }
10066
10067        #[inline]
10068        unsafe fn decode(
10069            &mut self,
10070            decoder: &mut fidl::encoding::Decoder<'_, D>,
10071            offset: usize,
10072            _depth: fidl::encoding::Depth,
10073        ) -> fidl::Result<()> {
10074            decoder.debug_check_bounds::<Self>(offset);
10075            // Verify that padding bytes are zero.
10076            fidl::decode!(StopConfirm, D, &mut self.resp, decoder, offset + 0, _depth)?;
10077            Ok(())
10078        }
10079    }
10080
10081    impl fidl::encoding::ValueTypeMarker for MlmeStopReqRequest {
10082        type Borrowed<'a> = &'a Self;
10083        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10084            value
10085        }
10086    }
10087
10088    unsafe impl fidl::encoding::TypeMarker for MlmeStopReqRequest {
10089        type Owned = Self;
10090
10091        #[inline(always)]
10092        fn inline_align(_context: fidl::encoding::Context) -> usize {
10093            8
10094        }
10095
10096        #[inline(always)]
10097        fn inline_size(_context: fidl::encoding::Context) -> usize {
10098            16
10099        }
10100    }
10101
10102    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MlmeStopReqRequest, D>
10103        for &MlmeStopReqRequest
10104    {
10105        #[inline]
10106        unsafe fn encode(
10107            self,
10108            encoder: &mut fidl::encoding::Encoder<'_, D>,
10109            offset: usize,
10110            _depth: fidl::encoding::Depth,
10111        ) -> fidl::Result<()> {
10112            encoder.debug_check_bounds::<MlmeStopReqRequest>(offset);
10113            // Delegate to tuple encoding.
10114            fidl::encoding::Encode::<MlmeStopReqRequest, D>::encode(
10115                (<StopRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
10116                encoder,
10117                offset,
10118                _depth,
10119            )
10120        }
10121    }
10122    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StopRequest, D>>
10123        fidl::encoding::Encode<MlmeStopReqRequest, D> for (T0,)
10124    {
10125        #[inline]
10126        unsafe fn encode(
10127            self,
10128            encoder: &mut fidl::encoding::Encoder<'_, D>,
10129            offset: usize,
10130            depth: fidl::encoding::Depth,
10131        ) -> fidl::Result<()> {
10132            encoder.debug_check_bounds::<MlmeStopReqRequest>(offset);
10133            // Zero out padding regions. There's no need to apply masks
10134            // because the unmasked parts will be overwritten by fields.
10135            // Write the fields.
10136            self.0.encode(encoder, offset + 0, depth)?;
10137            Ok(())
10138        }
10139    }
10140
10141    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MlmeStopReqRequest {
10142        #[inline(always)]
10143        fn new_empty() -> Self {
10144            Self { req: fidl::new_empty!(StopRequest, D) }
10145        }
10146
10147        #[inline]
10148        unsafe fn decode(
10149            &mut self,
10150            decoder: &mut fidl::encoding::Decoder<'_, D>,
10151            offset: usize,
10152            _depth: fidl::encoding::Depth,
10153        ) -> fidl::Result<()> {
10154            decoder.debug_check_bounds::<Self>(offset);
10155            // Verify that padding bytes are zero.
10156            fidl::decode!(StopRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
10157            Ok(())
10158        }
10159    }
10160
10161    impl fidl::encoding::ValueTypeMarker for MlmeStopScheduledScanRequest {
10162        type Borrowed<'a> = &'a Self;
10163        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10164            value
10165        }
10166    }
10167
10168    unsafe impl fidl::encoding::TypeMarker for MlmeStopScheduledScanRequest {
10169        type Owned = Self;
10170
10171        #[inline(always)]
10172        fn inline_align(_context: fidl::encoding::Context) -> usize {
10173            8
10174        }
10175
10176        #[inline(always)]
10177        fn inline_size(_context: fidl::encoding::Context) -> usize {
10178            8
10179        }
10180        #[inline(always)]
10181        fn encode_is_copy() -> bool {
10182            true
10183        }
10184
10185        #[inline(always)]
10186        fn decode_is_copy() -> bool {
10187            true
10188        }
10189    }
10190
10191    unsafe impl<D: fidl::encoding::ResourceDialect>
10192        fidl::encoding::Encode<MlmeStopScheduledScanRequest, D> for &MlmeStopScheduledScanRequest
10193    {
10194        #[inline]
10195        unsafe fn encode(
10196            self,
10197            encoder: &mut fidl::encoding::Encoder<'_, D>,
10198            offset: usize,
10199            _depth: fidl::encoding::Depth,
10200        ) -> fidl::Result<()> {
10201            encoder.debug_check_bounds::<MlmeStopScheduledScanRequest>(offset);
10202            unsafe {
10203                // Copy the object into the buffer.
10204                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
10205                (buf_ptr as *mut MlmeStopScheduledScanRequest)
10206                    .write_unaligned((self as *const MlmeStopScheduledScanRequest).read());
10207                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
10208                // done second because the memcpy will write garbage to these bytes.
10209            }
10210            Ok(())
10211        }
10212    }
10213    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
10214        fidl::encoding::Encode<MlmeStopScheduledScanRequest, D> for (T0,)
10215    {
10216        #[inline]
10217        unsafe fn encode(
10218            self,
10219            encoder: &mut fidl::encoding::Encoder<'_, D>,
10220            offset: usize,
10221            depth: fidl::encoding::Depth,
10222        ) -> fidl::Result<()> {
10223            encoder.debug_check_bounds::<MlmeStopScheduledScanRequest>(offset);
10224            // Zero out padding regions. There's no need to apply masks
10225            // because the unmasked parts will be overwritten by fields.
10226            // Write the fields.
10227            self.0.encode(encoder, offset + 0, depth)?;
10228            Ok(())
10229        }
10230    }
10231
10232    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10233        for MlmeStopScheduledScanRequest
10234    {
10235        #[inline(always)]
10236        fn new_empty() -> Self {
10237            Self { txn_id: fidl::new_empty!(u64, D) }
10238        }
10239
10240        #[inline]
10241        unsafe fn decode(
10242            &mut self,
10243            decoder: &mut fidl::encoding::Decoder<'_, D>,
10244            offset: usize,
10245            _depth: fidl::encoding::Depth,
10246        ) -> fidl::Result<()> {
10247            decoder.debug_check_bounds::<Self>(offset);
10248            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10249            // Verify that padding bytes are zero.
10250            // Copy from the buffer into the object.
10251            unsafe {
10252                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
10253            }
10254            Ok(())
10255        }
10256    }
10257
10258    impl fidl::encoding::ValueTypeMarker for NegotiatedCapabilities {
10259        type Borrowed<'a> = &'a Self;
10260        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10261            value
10262        }
10263    }
10264
10265    unsafe impl fidl::encoding::TypeMarker for NegotiatedCapabilities {
10266        type Owned = Self;
10267
10268        #[inline(always)]
10269        fn inline_align(_context: fidl::encoding::Context) -> usize {
10270            8
10271        }
10272
10273        #[inline(always)]
10274        fn inline_size(_context: fidl::encoding::Context) -> usize {
10275            56
10276        }
10277    }
10278
10279    unsafe impl<D: fidl::encoding::ResourceDialect>
10280        fidl::encoding::Encode<NegotiatedCapabilities, D> for &NegotiatedCapabilities
10281    {
10282        #[inline]
10283        unsafe fn encode(
10284            self,
10285            encoder: &mut fidl::encoding::Encoder<'_, D>,
10286            offset: usize,
10287            _depth: fidl::encoding::Depth,
10288        ) -> fidl::Result<()> {
10289            encoder.debug_check_bounds::<NegotiatedCapabilities>(offset);
10290            // Delegate to tuple encoding.
10291            fidl::encoding::Encode::<NegotiatedCapabilities, D>::encode(
10292                (
10293                    <fidl_fuchsia_wlan_ieee80211__common::WlanChannel as fidl::encoding::ValueTypeMarker>::borrow(&self.channel),
10294                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.capability_info),
10295                    <fidl::encoding::Vector<u8, 14> as fidl::encoding::ValueTypeMarker>::borrow(&self.rates),
10296                    <fidl::encoding::Boxed<WmmParameter> as fidl::encoding::ValueTypeMarker>::borrow(&self.wmm_param),
10297                    <fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities> as fidl::encoding::ValueTypeMarker>::borrow(&self.ht_cap),
10298                    <fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities> as fidl::encoding::ValueTypeMarker>::borrow(&self.vht_cap),
10299                ),
10300                encoder, offset, _depth
10301            )
10302        }
10303    }
10304    unsafe impl<
10305        D: fidl::encoding::ResourceDialect,
10306        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::WlanChannel, D>,
10307        T1: fidl::encoding::Encode<u16, D>,
10308        T2: fidl::encoding::Encode<fidl::encoding::Vector<u8, 14>, D>,
10309        T3: fidl::encoding::Encode<fidl::encoding::Boxed<WmmParameter>, D>,
10310        T4: fidl::encoding::Encode<
10311                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>,
10312                D,
10313            >,
10314        T5: fidl::encoding::Encode<
10315                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>,
10316                D,
10317            >,
10318    > fidl::encoding::Encode<NegotiatedCapabilities, D> for (T0, T1, T2, T3, T4, T5)
10319    {
10320        #[inline]
10321        unsafe fn encode(
10322            self,
10323            encoder: &mut fidl::encoding::Encoder<'_, D>,
10324            offset: usize,
10325            depth: fidl::encoding::Depth,
10326        ) -> fidl::Result<()> {
10327            encoder.debug_check_bounds::<NegotiatedCapabilities>(offset);
10328            // Zero out padding regions. There's no need to apply masks
10329            // because the unmasked parts will be overwritten by fields.
10330            unsafe {
10331                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
10332                (ptr as *mut u64).write_unaligned(0);
10333            }
10334            // Write the fields.
10335            self.0.encode(encoder, offset + 0, depth)?;
10336            self.1.encode(encoder, offset + 12, depth)?;
10337            self.2.encode(encoder, offset + 16, depth)?;
10338            self.3.encode(encoder, offset + 32, depth)?;
10339            self.4.encode(encoder, offset + 40, depth)?;
10340            self.5.encode(encoder, offset + 48, depth)?;
10341            Ok(())
10342        }
10343    }
10344
10345    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10346        for NegotiatedCapabilities
10347    {
10348        #[inline(always)]
10349        fn new_empty() -> Self {
10350            Self {
10351                channel: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::WlanChannel, D),
10352                capability_info: fidl::new_empty!(u16, D),
10353                rates: fidl::new_empty!(fidl::encoding::Vector<u8, 14>, D),
10354                wmm_param: fidl::new_empty!(fidl::encoding::Boxed<WmmParameter>, D),
10355                ht_cap: fidl::new_empty!(
10356                    fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>,
10357                    D
10358                ),
10359                vht_cap: fidl::new_empty!(
10360                    fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>,
10361                    D
10362                ),
10363            }
10364        }
10365
10366        #[inline]
10367        unsafe fn decode(
10368            &mut self,
10369            decoder: &mut fidl::encoding::Decoder<'_, D>,
10370            offset: usize,
10371            _depth: fidl::encoding::Depth,
10372        ) -> fidl::Result<()> {
10373            decoder.debug_check_bounds::<Self>(offset);
10374            // Verify that padding bytes are zero.
10375            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
10376            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10377            let mask = 0xffff000000000000u64;
10378            let maskedval = padval & mask;
10379            if maskedval != 0 {
10380                return Err(fidl::Error::NonZeroPadding {
10381                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
10382                });
10383            }
10384            fidl::decode!(
10385                fidl_fuchsia_wlan_ieee80211__common::WlanChannel,
10386                D,
10387                &mut self.channel,
10388                decoder,
10389                offset + 0,
10390                _depth
10391            )?;
10392            fidl::decode!(u16, D, &mut self.capability_info, decoder, offset + 12, _depth)?;
10393            fidl::decode!(fidl::encoding::Vector<u8, 14>, D, &mut self.rates, decoder, offset + 16, _depth)?;
10394            fidl::decode!(
10395                fidl::encoding::Boxed<WmmParameter>,
10396                D,
10397                &mut self.wmm_param,
10398                decoder,
10399                offset + 32,
10400                _depth
10401            )?;
10402            fidl::decode!(
10403                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::HtCapabilities>,
10404                D,
10405                &mut self.ht_cap,
10406                decoder,
10407                offset + 40,
10408                _depth
10409            )?;
10410            fidl::decode!(
10411                fidl::encoding::Boxed<fidl_fuchsia_wlan_ieee80211__common::VhtCapabilities>,
10412                D,
10413                &mut self.vht_cap,
10414                decoder,
10415                offset + 48,
10416                _depth
10417            )?;
10418            Ok(())
10419        }
10420    }
10421
10422    impl fidl::encoding::ValueTypeMarker for PmkInfo {
10423        type Borrowed<'a> = &'a Self;
10424        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10425            value
10426        }
10427    }
10428
10429    unsafe impl fidl::encoding::TypeMarker for PmkInfo {
10430        type Owned = Self;
10431
10432        #[inline(always)]
10433        fn inline_align(_context: fidl::encoding::Context) -> usize {
10434            8
10435        }
10436
10437        #[inline(always)]
10438        fn inline_size(_context: fidl::encoding::Context) -> usize {
10439            32
10440        }
10441    }
10442
10443    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PmkInfo, D> for &PmkInfo {
10444        #[inline]
10445        unsafe fn encode(
10446            self,
10447            encoder: &mut fidl::encoding::Encoder<'_, D>,
10448            offset: usize,
10449            _depth: fidl::encoding::Depth,
10450        ) -> fidl::Result<()> {
10451            encoder.debug_check_bounds::<PmkInfo>(offset);
10452            // Delegate to tuple encoding.
10453            fidl::encoding::Encode::<PmkInfo, D>::encode(
10454                (
10455                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.pmk),
10456                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.pmkid),
10457                ),
10458                encoder, offset, _depth
10459            )
10460        }
10461    }
10462    unsafe impl<
10463        D: fidl::encoding::ResourceDialect,
10464        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
10465        T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
10466    > fidl::encoding::Encode<PmkInfo, D> for (T0, T1)
10467    {
10468        #[inline]
10469        unsafe fn encode(
10470            self,
10471            encoder: &mut fidl::encoding::Encoder<'_, D>,
10472            offset: usize,
10473            depth: fidl::encoding::Depth,
10474        ) -> fidl::Result<()> {
10475            encoder.debug_check_bounds::<PmkInfo>(offset);
10476            // Zero out padding regions. There's no need to apply masks
10477            // because the unmasked parts will be overwritten by fields.
10478            // Write the fields.
10479            self.0.encode(encoder, offset + 0, depth)?;
10480            self.1.encode(encoder, offset + 16, depth)?;
10481            Ok(())
10482        }
10483    }
10484
10485    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PmkInfo {
10486        #[inline(always)]
10487        fn new_empty() -> Self {
10488            Self {
10489                pmk: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
10490                pmkid: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
10491            }
10492        }
10493
10494        #[inline]
10495        unsafe fn decode(
10496            &mut self,
10497            decoder: &mut fidl::encoding::Decoder<'_, D>,
10498            offset: usize,
10499            _depth: fidl::encoding::Depth,
10500        ) -> fidl::Result<()> {
10501            decoder.debug_check_bounds::<Self>(offset);
10502            // Verify that padding bytes are zero.
10503            fidl::decode!(
10504                fidl::encoding::UnboundedVector<u8>,
10505                D,
10506                &mut self.pmk,
10507                decoder,
10508                offset + 0,
10509                _depth
10510            )?;
10511            fidl::decode!(
10512                fidl::encoding::UnboundedVector<u8>,
10513                D,
10514                &mut self.pmkid,
10515                decoder,
10516                offset + 16,
10517                _depth
10518            )?;
10519            Ok(())
10520        }
10521    }
10522
10523    impl fidl::encoding::ValueTypeMarker for ReconnectRequest {
10524        type Borrowed<'a> = &'a Self;
10525        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10526            value
10527        }
10528    }
10529
10530    unsafe impl fidl::encoding::TypeMarker for ReconnectRequest {
10531        type Owned = Self;
10532
10533        #[inline(always)]
10534        fn inline_align(_context: fidl::encoding::Context) -> usize {
10535            1
10536        }
10537
10538        #[inline(always)]
10539        fn inline_size(_context: fidl::encoding::Context) -> usize {
10540            6
10541        }
10542        #[inline(always)]
10543        fn encode_is_copy() -> bool {
10544            true
10545        }
10546
10547        #[inline(always)]
10548        fn decode_is_copy() -> bool {
10549            true
10550        }
10551    }
10552
10553    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ReconnectRequest, D>
10554        for &ReconnectRequest
10555    {
10556        #[inline]
10557        unsafe fn encode(
10558            self,
10559            encoder: &mut fidl::encoding::Encoder<'_, D>,
10560            offset: usize,
10561            _depth: fidl::encoding::Depth,
10562        ) -> fidl::Result<()> {
10563            encoder.debug_check_bounds::<ReconnectRequest>(offset);
10564            unsafe {
10565                // Copy the object into the buffer.
10566                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
10567                (buf_ptr as *mut ReconnectRequest)
10568                    .write_unaligned((self as *const ReconnectRequest).read());
10569                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
10570                // done second because the memcpy will write garbage to these bytes.
10571            }
10572            Ok(())
10573        }
10574    }
10575    unsafe impl<
10576        D: fidl::encoding::ResourceDialect,
10577        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
10578    > fidl::encoding::Encode<ReconnectRequest, D> for (T0,)
10579    {
10580        #[inline]
10581        unsafe fn encode(
10582            self,
10583            encoder: &mut fidl::encoding::Encoder<'_, D>,
10584            offset: usize,
10585            depth: fidl::encoding::Depth,
10586        ) -> fidl::Result<()> {
10587            encoder.debug_check_bounds::<ReconnectRequest>(offset);
10588            // Zero out padding regions. There's no need to apply masks
10589            // because the unmasked parts will be overwritten by fields.
10590            // Write the fields.
10591            self.0.encode(encoder, offset + 0, depth)?;
10592            Ok(())
10593        }
10594    }
10595
10596    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ReconnectRequest {
10597        #[inline(always)]
10598        fn new_empty() -> Self {
10599            Self { peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D) }
10600        }
10601
10602        #[inline]
10603        unsafe fn decode(
10604            &mut self,
10605            decoder: &mut fidl::encoding::Decoder<'_, D>,
10606            offset: usize,
10607            _depth: fidl::encoding::Depth,
10608        ) -> fidl::Result<()> {
10609            decoder.debug_check_bounds::<Self>(offset);
10610            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
10611            // Verify that padding bytes are zero.
10612            // Copy from the buffer into the object.
10613            unsafe {
10614                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 6);
10615            }
10616            Ok(())
10617        }
10618    }
10619
10620    impl fidl::encoding::ValueTypeMarker for ResetRequest {
10621        type Borrowed<'a> = &'a Self;
10622        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10623            value
10624        }
10625    }
10626
10627    unsafe impl fidl::encoding::TypeMarker for ResetRequest {
10628        type Owned = Self;
10629
10630        #[inline(always)]
10631        fn inline_align(_context: fidl::encoding::Context) -> usize {
10632            1
10633        }
10634
10635        #[inline(always)]
10636        fn inline_size(_context: fidl::encoding::Context) -> usize {
10637            7
10638        }
10639    }
10640
10641    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ResetRequest, D>
10642        for &ResetRequest
10643    {
10644        #[inline]
10645        unsafe fn encode(
10646            self,
10647            encoder: &mut fidl::encoding::Encoder<'_, D>,
10648            offset: usize,
10649            _depth: fidl::encoding::Depth,
10650        ) -> fidl::Result<()> {
10651            encoder.debug_check_bounds::<ResetRequest>(offset);
10652            // Delegate to tuple encoding.
10653            fidl::encoding::Encode::<ResetRequest, D>::encode(
10654                (
10655                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
10656                        &self.sta_address,
10657                    ),
10658                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.set_default_mib),
10659                ),
10660                encoder,
10661                offset,
10662                _depth,
10663            )
10664        }
10665    }
10666    unsafe impl<
10667        D: fidl::encoding::ResourceDialect,
10668        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
10669        T1: fidl::encoding::Encode<bool, D>,
10670    > fidl::encoding::Encode<ResetRequest, D> for (T0, T1)
10671    {
10672        #[inline]
10673        unsafe fn encode(
10674            self,
10675            encoder: &mut fidl::encoding::Encoder<'_, D>,
10676            offset: usize,
10677            depth: fidl::encoding::Depth,
10678        ) -> fidl::Result<()> {
10679            encoder.debug_check_bounds::<ResetRequest>(offset);
10680            // Zero out padding regions. There's no need to apply masks
10681            // because the unmasked parts will be overwritten by fields.
10682            // Write the fields.
10683            self.0.encode(encoder, offset + 0, depth)?;
10684            self.1.encode(encoder, offset + 6, depth)?;
10685            Ok(())
10686        }
10687    }
10688
10689    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResetRequest {
10690        #[inline(always)]
10691        fn new_empty() -> Self {
10692            Self {
10693                sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
10694                set_default_mib: fidl::new_empty!(bool, D),
10695            }
10696        }
10697
10698        #[inline]
10699        unsafe fn decode(
10700            &mut self,
10701            decoder: &mut fidl::encoding::Decoder<'_, D>,
10702            offset: usize,
10703            _depth: fidl::encoding::Depth,
10704        ) -> fidl::Result<()> {
10705            decoder.debug_check_bounds::<Self>(offset);
10706            // Verify that padding bytes are zero.
10707            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.sta_address, decoder, offset + 0, _depth)?;
10708            fidl::decode!(bool, D, &mut self.set_default_mib, decoder, offset + 6, _depth)?;
10709            Ok(())
10710        }
10711    }
10712
10713    impl fidl::encoding::ValueTypeMarker for RoamConfirm {
10714        type Borrowed<'a> = &'a Self;
10715        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10716            value
10717        }
10718    }
10719
10720    unsafe impl fidl::encoding::TypeMarker for RoamConfirm {
10721        type Owned = Self;
10722
10723        #[inline(always)]
10724        fn inline_align(_context: fidl::encoding::Context) -> usize {
10725            8
10726        }
10727
10728        #[inline(always)]
10729        fn inline_size(_context: fidl::encoding::Context) -> usize {
10730            32
10731        }
10732    }
10733
10734    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RoamConfirm, D>
10735        for &RoamConfirm
10736    {
10737        #[inline]
10738        unsafe fn encode(
10739            self,
10740            encoder: &mut fidl::encoding::Encoder<'_, D>,
10741            offset: usize,
10742            _depth: fidl::encoding::Depth,
10743        ) -> fidl::Result<()> {
10744            encoder.debug_check_bounds::<RoamConfirm>(offset);
10745            // Delegate to tuple encoding.
10746            fidl::encoding::Encode::<RoamConfirm, D>::encode(
10747                (
10748                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.selected_bssid),
10749                    <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow(&self.status_code),
10750                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.original_association_maintained),
10751                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.target_bss_authenticated),
10752                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.association_id),
10753                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.association_ies),
10754                ),
10755                encoder, offset, _depth
10756            )
10757        }
10758    }
10759    unsafe impl<
10760        D: fidl::encoding::ResourceDialect,
10761        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
10762        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>,
10763        T2: fidl::encoding::Encode<bool, D>,
10764        T3: fidl::encoding::Encode<bool, D>,
10765        T4: fidl::encoding::Encode<u16, D>,
10766        T5: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
10767    > fidl::encoding::Encode<RoamConfirm, D> for (T0, T1, T2, T3, T4, T5)
10768    {
10769        #[inline]
10770        unsafe fn encode(
10771            self,
10772            encoder: &mut fidl::encoding::Encoder<'_, D>,
10773            offset: usize,
10774            depth: fidl::encoding::Depth,
10775        ) -> fidl::Result<()> {
10776            encoder.debug_check_bounds::<RoamConfirm>(offset);
10777            // Zero out padding regions. There's no need to apply masks
10778            // because the unmasked parts will be overwritten by fields.
10779            unsafe {
10780                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
10781                (ptr as *mut u64).write_unaligned(0);
10782            }
10783            // Write the fields.
10784            self.0.encode(encoder, offset + 0, depth)?;
10785            self.1.encode(encoder, offset + 6, depth)?;
10786            self.2.encode(encoder, offset + 8, depth)?;
10787            self.3.encode(encoder, offset + 9, depth)?;
10788            self.4.encode(encoder, offset + 10, depth)?;
10789            self.5.encode(encoder, offset + 16, depth)?;
10790            Ok(())
10791        }
10792    }
10793
10794    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RoamConfirm {
10795        #[inline(always)]
10796        fn new_empty() -> Self {
10797            Self {
10798                selected_bssid: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
10799                status_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D),
10800                original_association_maintained: fidl::new_empty!(bool, D),
10801                target_bss_authenticated: fidl::new_empty!(bool, D),
10802                association_id: fidl::new_empty!(u16, D),
10803                association_ies: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
10804            }
10805        }
10806
10807        #[inline]
10808        unsafe fn decode(
10809            &mut self,
10810            decoder: &mut fidl::encoding::Decoder<'_, D>,
10811            offset: usize,
10812            _depth: fidl::encoding::Depth,
10813        ) -> fidl::Result<()> {
10814            decoder.debug_check_bounds::<Self>(offset);
10815            // Verify that padding bytes are zero.
10816            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
10817            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10818            let mask = 0xffffffff00000000u64;
10819            let maskedval = padval & mask;
10820            if maskedval != 0 {
10821                return Err(fidl::Error::NonZeroPadding {
10822                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
10823                });
10824            }
10825            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.selected_bssid, decoder, offset + 0, _depth)?;
10826            fidl::decode!(
10827                fidl_fuchsia_wlan_ieee80211__common::StatusCode,
10828                D,
10829                &mut self.status_code,
10830                decoder,
10831                offset + 6,
10832                _depth
10833            )?;
10834            fidl::decode!(
10835                bool,
10836                D,
10837                &mut self.original_association_maintained,
10838                decoder,
10839                offset + 8,
10840                _depth
10841            )?;
10842            fidl::decode!(
10843                bool,
10844                D,
10845                &mut self.target_bss_authenticated,
10846                decoder,
10847                offset + 9,
10848                _depth
10849            )?;
10850            fidl::decode!(u16, D, &mut self.association_id, decoder, offset + 10, _depth)?;
10851            fidl::decode!(
10852                fidl::encoding::UnboundedVector<u8>,
10853                D,
10854                &mut self.association_ies,
10855                decoder,
10856                offset + 16,
10857                _depth
10858            )?;
10859            Ok(())
10860        }
10861    }
10862
10863    impl fidl::encoding::ValueTypeMarker for RoamRequest {
10864        type Borrowed<'a> = &'a Self;
10865        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10866            value
10867        }
10868    }
10869
10870    unsafe impl fidl::encoding::TypeMarker for RoamRequest {
10871        type Owned = Self;
10872
10873        #[inline(always)]
10874        fn inline_align(_context: fidl::encoding::Context) -> usize {
10875            8
10876        }
10877
10878        #[inline(always)]
10879        fn inline_size(_context: fidl::encoding::Context) -> usize {
10880            48
10881        }
10882    }
10883
10884    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RoamRequest, D>
10885        for &RoamRequest
10886    {
10887        #[inline]
10888        unsafe fn encode(
10889            self,
10890            encoder: &mut fidl::encoding::Encoder<'_, D>,
10891            offset: usize,
10892            _depth: fidl::encoding::Depth,
10893        ) -> fidl::Result<()> {
10894            encoder.debug_check_bounds::<RoamRequest>(offset);
10895            // Delegate to tuple encoding.
10896            fidl::encoding::Encode::<RoamRequest, D>::encode(
10897                (
10898                    <fidl_fuchsia_wlan_ieee80211__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow(&self.selected_bss),
10899                ),
10900                encoder, offset, _depth
10901            )
10902        }
10903    }
10904    unsafe impl<
10905        D: fidl::encoding::ResourceDialect,
10906        T0: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::BssDescription, D>,
10907    > fidl::encoding::Encode<RoamRequest, D> for (T0,)
10908    {
10909        #[inline]
10910        unsafe fn encode(
10911            self,
10912            encoder: &mut fidl::encoding::Encoder<'_, D>,
10913            offset: usize,
10914            depth: fidl::encoding::Depth,
10915        ) -> fidl::Result<()> {
10916            encoder.debug_check_bounds::<RoamRequest>(offset);
10917            // Zero out padding regions. There's no need to apply masks
10918            // because the unmasked parts will be overwritten by fields.
10919            // Write the fields.
10920            self.0.encode(encoder, offset + 0, depth)?;
10921            Ok(())
10922        }
10923    }
10924
10925    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RoamRequest {
10926        #[inline(always)]
10927        fn new_empty() -> Self {
10928            Self {
10929                selected_bss: fidl::new_empty!(
10930                    fidl_fuchsia_wlan_ieee80211__common::BssDescription,
10931                    D
10932                ),
10933            }
10934        }
10935
10936        #[inline]
10937        unsafe fn decode(
10938            &mut self,
10939            decoder: &mut fidl::encoding::Decoder<'_, D>,
10940            offset: usize,
10941            _depth: fidl::encoding::Depth,
10942        ) -> fidl::Result<()> {
10943            decoder.debug_check_bounds::<Self>(offset);
10944            // Verify that padding bytes are zero.
10945            fidl::decode!(
10946                fidl_fuchsia_wlan_ieee80211__common::BssDescription,
10947                D,
10948                &mut self.selected_bss,
10949                decoder,
10950                offset + 0,
10951                _depth
10952            )?;
10953            Ok(())
10954        }
10955    }
10956
10957    impl fidl::encoding::ValueTypeMarker for RoamResultIndication {
10958        type Borrowed<'a> = &'a Self;
10959        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10960            value
10961        }
10962    }
10963
10964    unsafe impl fidl::encoding::TypeMarker for RoamResultIndication {
10965        type Owned = Self;
10966
10967        #[inline(always)]
10968        fn inline_align(_context: fidl::encoding::Context) -> usize {
10969            8
10970        }
10971
10972        #[inline(always)]
10973        fn inline_size(_context: fidl::encoding::Context) -> usize {
10974            32
10975        }
10976    }
10977
10978    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RoamResultIndication, D>
10979        for &RoamResultIndication
10980    {
10981        #[inline]
10982        unsafe fn encode(
10983            self,
10984            encoder: &mut fidl::encoding::Encoder<'_, D>,
10985            offset: usize,
10986            _depth: fidl::encoding::Depth,
10987        ) -> fidl::Result<()> {
10988            encoder.debug_check_bounds::<RoamResultIndication>(offset);
10989            // Delegate to tuple encoding.
10990            fidl::encoding::Encode::<RoamResultIndication, D>::encode(
10991                (
10992                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.selected_bssid),
10993                    <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow(&self.status_code),
10994                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.original_association_maintained),
10995                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.target_bss_authenticated),
10996                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.association_id),
10997                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.association_ies),
10998                ),
10999                encoder, offset, _depth
11000            )
11001        }
11002    }
11003    unsafe impl<
11004        D: fidl::encoding::ResourceDialect,
11005        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
11006        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>,
11007        T2: fidl::encoding::Encode<bool, D>,
11008        T3: fidl::encoding::Encode<bool, D>,
11009        T4: fidl::encoding::Encode<u16, D>,
11010        T5: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
11011    > fidl::encoding::Encode<RoamResultIndication, D> for (T0, T1, T2, T3, T4, T5)
11012    {
11013        #[inline]
11014        unsafe fn encode(
11015            self,
11016            encoder: &mut fidl::encoding::Encoder<'_, D>,
11017            offset: usize,
11018            depth: fidl::encoding::Depth,
11019        ) -> fidl::Result<()> {
11020            encoder.debug_check_bounds::<RoamResultIndication>(offset);
11021            // Zero out padding regions. There's no need to apply masks
11022            // because the unmasked parts will be overwritten by fields.
11023            unsafe {
11024                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11025                (ptr as *mut u64).write_unaligned(0);
11026            }
11027            // Write the fields.
11028            self.0.encode(encoder, offset + 0, depth)?;
11029            self.1.encode(encoder, offset + 6, depth)?;
11030            self.2.encode(encoder, offset + 8, depth)?;
11031            self.3.encode(encoder, offset + 9, depth)?;
11032            self.4.encode(encoder, offset + 10, depth)?;
11033            self.5.encode(encoder, offset + 16, depth)?;
11034            Ok(())
11035        }
11036    }
11037
11038    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RoamResultIndication {
11039        #[inline(always)]
11040        fn new_empty() -> Self {
11041            Self {
11042                selected_bssid: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
11043                status_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D),
11044                original_association_maintained: fidl::new_empty!(bool, D),
11045                target_bss_authenticated: fidl::new_empty!(bool, D),
11046                association_id: fidl::new_empty!(u16, D),
11047                association_ies: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
11048            }
11049        }
11050
11051        #[inline]
11052        unsafe fn decode(
11053            &mut self,
11054            decoder: &mut fidl::encoding::Decoder<'_, D>,
11055            offset: usize,
11056            _depth: fidl::encoding::Depth,
11057        ) -> fidl::Result<()> {
11058            decoder.debug_check_bounds::<Self>(offset);
11059            // Verify that padding bytes are zero.
11060            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
11061            let padval = unsafe { (ptr as *const u64).read_unaligned() };
11062            let mask = 0xffffffff00000000u64;
11063            let maskedval = padval & mask;
11064            if maskedval != 0 {
11065                return Err(fidl::Error::NonZeroPadding {
11066                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
11067                });
11068            }
11069            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.selected_bssid, decoder, offset + 0, _depth)?;
11070            fidl::decode!(
11071                fidl_fuchsia_wlan_ieee80211__common::StatusCode,
11072                D,
11073                &mut self.status_code,
11074                decoder,
11075                offset + 6,
11076                _depth
11077            )?;
11078            fidl::decode!(
11079                bool,
11080                D,
11081                &mut self.original_association_maintained,
11082                decoder,
11083                offset + 8,
11084                _depth
11085            )?;
11086            fidl::decode!(
11087                bool,
11088                D,
11089                &mut self.target_bss_authenticated,
11090                decoder,
11091                offset + 9,
11092                _depth
11093            )?;
11094            fidl::decode!(u16, D, &mut self.association_id, decoder, offset + 10, _depth)?;
11095            fidl::decode!(
11096                fidl::encoding::UnboundedVector<u8>,
11097                D,
11098                &mut self.association_ies,
11099                decoder,
11100                offset + 16,
11101                _depth
11102            )?;
11103            Ok(())
11104        }
11105    }
11106
11107    impl fidl::encoding::ValueTypeMarker for RoamStartIndication {
11108        type Borrowed<'a> = &'a Self;
11109        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11110            value
11111        }
11112    }
11113
11114    unsafe impl fidl::encoding::TypeMarker for RoamStartIndication {
11115        type Owned = Self;
11116
11117        #[inline(always)]
11118        fn inline_align(_context: fidl::encoding::Context) -> usize {
11119            8
11120        }
11121
11122        #[inline(always)]
11123        fn inline_size(_context: fidl::encoding::Context) -> usize {
11124            64
11125        }
11126    }
11127
11128    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RoamStartIndication, D>
11129        for &RoamStartIndication
11130    {
11131        #[inline]
11132        unsafe fn encode(
11133            self,
11134            encoder: &mut fidl::encoding::Encoder<'_, D>,
11135            offset: usize,
11136            _depth: fidl::encoding::Depth,
11137        ) -> fidl::Result<()> {
11138            encoder.debug_check_bounds::<RoamStartIndication>(offset);
11139            // Delegate to tuple encoding.
11140            fidl::encoding::Encode::<RoamStartIndication, D>::encode(
11141                (
11142                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.selected_bssid),
11143                    <fidl_fuchsia_wlan_ieee80211__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow(&self.selected_bss),
11144                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.original_association_maintained),
11145                ),
11146                encoder, offset, _depth
11147            )
11148        }
11149    }
11150    unsafe impl<
11151        D: fidl::encoding::ResourceDialect,
11152        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
11153        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::BssDescription, D>,
11154        T2: fidl::encoding::Encode<bool, D>,
11155    > fidl::encoding::Encode<RoamStartIndication, D> for (T0, T1, T2)
11156    {
11157        #[inline]
11158        unsafe fn encode(
11159            self,
11160            encoder: &mut fidl::encoding::Encoder<'_, D>,
11161            offset: usize,
11162            depth: fidl::encoding::Depth,
11163        ) -> fidl::Result<()> {
11164            encoder.debug_check_bounds::<RoamStartIndication>(offset);
11165            // Zero out padding regions. There's no need to apply masks
11166            // because the unmasked parts will be overwritten by fields.
11167            unsafe {
11168                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
11169                (ptr as *mut u64).write_unaligned(0);
11170            }
11171            unsafe {
11172                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(56);
11173                (ptr as *mut u64).write_unaligned(0);
11174            }
11175            // Write the fields.
11176            self.0.encode(encoder, offset + 0, depth)?;
11177            self.1.encode(encoder, offset + 8, depth)?;
11178            self.2.encode(encoder, offset + 56, depth)?;
11179            Ok(())
11180        }
11181    }
11182
11183    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RoamStartIndication {
11184        #[inline(always)]
11185        fn new_empty() -> Self {
11186            Self {
11187                selected_bssid: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
11188                selected_bss: fidl::new_empty!(
11189                    fidl_fuchsia_wlan_ieee80211__common::BssDescription,
11190                    D
11191                ),
11192                original_association_maintained: fidl::new_empty!(bool, D),
11193            }
11194        }
11195
11196        #[inline]
11197        unsafe fn decode(
11198            &mut self,
11199            decoder: &mut fidl::encoding::Decoder<'_, D>,
11200            offset: usize,
11201            _depth: fidl::encoding::Depth,
11202        ) -> fidl::Result<()> {
11203            decoder.debug_check_bounds::<Self>(offset);
11204            // Verify that padding bytes are zero.
11205            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
11206            let padval = unsafe { (ptr as *const u64).read_unaligned() };
11207            let mask = 0xffff000000000000u64;
11208            let maskedval = padval & mask;
11209            if maskedval != 0 {
11210                return Err(fidl::Error::NonZeroPadding {
11211                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
11212                });
11213            }
11214            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(56) };
11215            let padval = unsafe { (ptr as *const u64).read_unaligned() };
11216            let mask = 0xffffffffffffff00u64;
11217            let maskedval = padval & mask;
11218            if maskedval != 0 {
11219                return Err(fidl::Error::NonZeroPadding {
11220                    padding_start: offset + 56 + ((mask as u64).trailing_zeros() / 8) as usize,
11221                });
11222            }
11223            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.selected_bssid, decoder, offset + 0, _depth)?;
11224            fidl::decode!(
11225                fidl_fuchsia_wlan_ieee80211__common::BssDescription,
11226                D,
11227                &mut self.selected_bss,
11228                decoder,
11229                offset + 8,
11230                _depth
11231            )?;
11232            fidl::decode!(
11233                bool,
11234                D,
11235                &mut self.original_association_maintained,
11236                decoder,
11237                offset + 56,
11238                _depth
11239            )?;
11240            Ok(())
11241        }
11242    }
11243
11244    impl fidl::encoding::ValueTypeMarker for SaeFrame {
11245        type Borrowed<'a> = &'a Self;
11246        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11247            value
11248        }
11249    }
11250
11251    unsafe impl fidl::encoding::TypeMarker for SaeFrame {
11252        type Owned = Self;
11253
11254        #[inline(always)]
11255        fn inline_align(_context: fidl::encoding::Context) -> usize {
11256            8
11257        }
11258
11259        #[inline(always)]
11260        fn inline_size(_context: fidl::encoding::Context) -> usize {
11261            32
11262        }
11263    }
11264
11265    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SaeFrame, D> for &SaeFrame {
11266        #[inline]
11267        unsafe fn encode(
11268            self,
11269            encoder: &mut fidl::encoding::Encoder<'_, D>,
11270            offset: usize,
11271            _depth: fidl::encoding::Depth,
11272        ) -> fidl::Result<()> {
11273            encoder.debug_check_bounds::<SaeFrame>(offset);
11274            // Delegate to tuple encoding.
11275            fidl::encoding::Encode::<SaeFrame, D>::encode(
11276                (
11277                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
11278                    <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow(&self.status_code),
11279                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.seq_num),
11280                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.sae_fields),
11281                ),
11282                encoder, offset, _depth
11283            )
11284        }
11285    }
11286    unsafe impl<
11287        D: fidl::encoding::ResourceDialect,
11288        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
11289        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>,
11290        T2: fidl::encoding::Encode<u16, D>,
11291        T3: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
11292    > fidl::encoding::Encode<SaeFrame, D> for (T0, T1, T2, T3)
11293    {
11294        #[inline]
11295        unsafe fn encode(
11296            self,
11297            encoder: &mut fidl::encoding::Encoder<'_, D>,
11298            offset: usize,
11299            depth: fidl::encoding::Depth,
11300        ) -> fidl::Result<()> {
11301            encoder.debug_check_bounds::<SaeFrame>(offset);
11302            // Zero out padding regions. There's no need to apply masks
11303            // because the unmasked parts will be overwritten by fields.
11304            unsafe {
11305                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11306                (ptr as *mut u64).write_unaligned(0);
11307            }
11308            // Write the fields.
11309            self.0.encode(encoder, offset + 0, depth)?;
11310            self.1.encode(encoder, offset + 6, depth)?;
11311            self.2.encode(encoder, offset + 8, depth)?;
11312            self.3.encode(encoder, offset + 16, depth)?;
11313            Ok(())
11314        }
11315    }
11316
11317    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SaeFrame {
11318        #[inline(always)]
11319        fn new_empty() -> Self {
11320            Self {
11321                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
11322                status_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D),
11323                seq_num: fidl::new_empty!(u16, D),
11324                sae_fields: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
11325            }
11326        }
11327
11328        #[inline]
11329        unsafe fn decode(
11330            &mut self,
11331            decoder: &mut fidl::encoding::Decoder<'_, D>,
11332            offset: usize,
11333            _depth: fidl::encoding::Depth,
11334        ) -> fidl::Result<()> {
11335            decoder.debug_check_bounds::<Self>(offset);
11336            // Verify that padding bytes are zero.
11337            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
11338            let padval = unsafe { (ptr as *const u64).read_unaligned() };
11339            let mask = 0xffffffffffff0000u64;
11340            let maskedval = padval & mask;
11341            if maskedval != 0 {
11342                return Err(fidl::Error::NonZeroPadding {
11343                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
11344                });
11345            }
11346            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
11347            fidl::decode!(
11348                fidl_fuchsia_wlan_ieee80211__common::StatusCode,
11349                D,
11350                &mut self.status_code,
11351                decoder,
11352                offset + 6,
11353                _depth
11354            )?;
11355            fidl::decode!(u16, D, &mut self.seq_num, decoder, offset + 8, _depth)?;
11356            fidl::decode!(
11357                fidl::encoding::UnboundedVector<u8>,
11358                D,
11359                &mut self.sae_fields,
11360                decoder,
11361                offset + 16,
11362                _depth
11363            )?;
11364            Ok(())
11365        }
11366    }
11367
11368    impl fidl::encoding::ValueTypeMarker for SaeHandshakeIndication {
11369        type Borrowed<'a> = &'a Self;
11370        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11371            value
11372        }
11373    }
11374
11375    unsafe impl fidl::encoding::TypeMarker for SaeHandshakeIndication {
11376        type Owned = Self;
11377
11378        #[inline(always)]
11379        fn inline_align(_context: fidl::encoding::Context) -> usize {
11380            1
11381        }
11382
11383        #[inline(always)]
11384        fn inline_size(_context: fidl::encoding::Context) -> usize {
11385            6
11386        }
11387        #[inline(always)]
11388        fn encode_is_copy() -> bool {
11389            true
11390        }
11391
11392        #[inline(always)]
11393        fn decode_is_copy() -> bool {
11394            true
11395        }
11396    }
11397
11398    unsafe impl<D: fidl::encoding::ResourceDialect>
11399        fidl::encoding::Encode<SaeHandshakeIndication, D> for &SaeHandshakeIndication
11400    {
11401        #[inline]
11402        unsafe fn encode(
11403            self,
11404            encoder: &mut fidl::encoding::Encoder<'_, D>,
11405            offset: usize,
11406            _depth: fidl::encoding::Depth,
11407        ) -> fidl::Result<()> {
11408            encoder.debug_check_bounds::<SaeHandshakeIndication>(offset);
11409            unsafe {
11410                // Copy the object into the buffer.
11411                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
11412                (buf_ptr as *mut SaeHandshakeIndication)
11413                    .write_unaligned((self as *const SaeHandshakeIndication).read());
11414                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
11415                // done second because the memcpy will write garbage to these bytes.
11416            }
11417            Ok(())
11418        }
11419    }
11420    unsafe impl<
11421        D: fidl::encoding::ResourceDialect,
11422        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
11423    > fidl::encoding::Encode<SaeHandshakeIndication, D> for (T0,)
11424    {
11425        #[inline]
11426        unsafe fn encode(
11427            self,
11428            encoder: &mut fidl::encoding::Encoder<'_, D>,
11429            offset: usize,
11430            depth: fidl::encoding::Depth,
11431        ) -> fidl::Result<()> {
11432            encoder.debug_check_bounds::<SaeHandshakeIndication>(offset);
11433            // Zero out padding regions. There's no need to apply masks
11434            // because the unmasked parts will be overwritten by fields.
11435            // Write the fields.
11436            self.0.encode(encoder, offset + 0, depth)?;
11437            Ok(())
11438        }
11439    }
11440
11441    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11442        for SaeHandshakeIndication
11443    {
11444        #[inline(always)]
11445        fn new_empty() -> Self {
11446            Self { peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D) }
11447        }
11448
11449        #[inline]
11450        unsafe fn decode(
11451            &mut self,
11452            decoder: &mut fidl::encoding::Decoder<'_, D>,
11453            offset: usize,
11454            _depth: fidl::encoding::Depth,
11455        ) -> fidl::Result<()> {
11456            decoder.debug_check_bounds::<Self>(offset);
11457            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
11458            // Verify that padding bytes are zero.
11459            // Copy from the buffer into the object.
11460            unsafe {
11461                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 6);
11462            }
11463            Ok(())
11464        }
11465    }
11466
11467    impl fidl::encoding::ValueTypeMarker for SaeHandshakeResponse {
11468        type Borrowed<'a> = &'a Self;
11469        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11470            value
11471        }
11472    }
11473
11474    unsafe impl fidl::encoding::TypeMarker for SaeHandshakeResponse {
11475        type Owned = Self;
11476
11477        #[inline(always)]
11478        fn inline_align(_context: fidl::encoding::Context) -> usize {
11479            2
11480        }
11481
11482        #[inline(always)]
11483        fn inline_size(_context: fidl::encoding::Context) -> usize {
11484            8
11485        }
11486    }
11487
11488    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SaeHandshakeResponse, D>
11489        for &SaeHandshakeResponse
11490    {
11491        #[inline]
11492        unsafe fn encode(
11493            self,
11494            encoder: &mut fidl::encoding::Encoder<'_, D>,
11495            offset: usize,
11496            _depth: fidl::encoding::Depth,
11497        ) -> fidl::Result<()> {
11498            encoder.debug_check_bounds::<SaeHandshakeResponse>(offset);
11499            // Delegate to tuple encoding.
11500            fidl::encoding::Encode::<SaeHandshakeResponse, D>::encode(
11501                (
11502                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.peer_sta_address),
11503                    <fidl_fuchsia_wlan_ieee80211__common::StatusCode as fidl::encoding::ValueTypeMarker>::borrow(&self.status_code),
11504                ),
11505                encoder, offset, _depth
11506            )
11507        }
11508    }
11509    unsafe impl<
11510        D: fidl::encoding::ResourceDialect,
11511        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
11512        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::StatusCode, D>,
11513    > fidl::encoding::Encode<SaeHandshakeResponse, D> for (T0, T1)
11514    {
11515        #[inline]
11516        unsafe fn encode(
11517            self,
11518            encoder: &mut fidl::encoding::Encoder<'_, D>,
11519            offset: usize,
11520            depth: fidl::encoding::Depth,
11521        ) -> fidl::Result<()> {
11522            encoder.debug_check_bounds::<SaeHandshakeResponse>(offset);
11523            // Zero out padding regions. There's no need to apply masks
11524            // because the unmasked parts will be overwritten by fields.
11525            // Write the fields.
11526            self.0.encode(encoder, offset + 0, depth)?;
11527            self.1.encode(encoder, offset + 6, depth)?;
11528            Ok(())
11529        }
11530    }
11531
11532    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SaeHandshakeResponse {
11533        #[inline(always)]
11534        fn new_empty() -> Self {
11535            Self {
11536                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
11537                status_code: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::StatusCode, D),
11538            }
11539        }
11540
11541        #[inline]
11542        unsafe fn decode(
11543            &mut self,
11544            decoder: &mut fidl::encoding::Decoder<'_, D>,
11545            offset: usize,
11546            _depth: fidl::encoding::Depth,
11547        ) -> fidl::Result<()> {
11548            decoder.debug_check_bounds::<Self>(offset);
11549            // Verify that padding bytes are zero.
11550            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
11551            fidl::decode!(
11552                fidl_fuchsia_wlan_ieee80211__common::StatusCode,
11553                D,
11554                &mut self.status_code,
11555                decoder,
11556                offset + 6,
11557                _depth
11558            )?;
11559            Ok(())
11560        }
11561    }
11562
11563    impl fidl::encoding::ValueTypeMarker for ScanEnd {
11564        type Borrowed<'a> = &'a Self;
11565        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11566            value
11567        }
11568    }
11569
11570    unsafe impl fidl::encoding::TypeMarker for ScanEnd {
11571        type Owned = Self;
11572
11573        #[inline(always)]
11574        fn inline_align(_context: fidl::encoding::Context) -> usize {
11575            8
11576        }
11577
11578        #[inline(always)]
11579        fn inline_size(_context: fidl::encoding::Context) -> usize {
11580            16
11581        }
11582    }
11583
11584    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanEnd, D> for &ScanEnd {
11585        #[inline]
11586        unsafe fn encode(
11587            self,
11588            encoder: &mut fidl::encoding::Encoder<'_, D>,
11589            offset: usize,
11590            _depth: fidl::encoding::Depth,
11591        ) -> fidl::Result<()> {
11592            encoder.debug_check_bounds::<ScanEnd>(offset);
11593            // Delegate to tuple encoding.
11594            fidl::encoding::Encode::<ScanEnd, D>::encode(
11595                (
11596                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.txn_id),
11597                    <ScanResultCode as fidl::encoding::ValueTypeMarker>::borrow(&self.code),
11598                ),
11599                encoder,
11600                offset,
11601                _depth,
11602            )
11603        }
11604    }
11605    unsafe impl<
11606        D: fidl::encoding::ResourceDialect,
11607        T0: fidl::encoding::Encode<u64, D>,
11608        T1: fidl::encoding::Encode<ScanResultCode, D>,
11609    > fidl::encoding::Encode<ScanEnd, D> for (T0, T1)
11610    {
11611        #[inline]
11612        unsafe fn encode(
11613            self,
11614            encoder: &mut fidl::encoding::Encoder<'_, D>,
11615            offset: usize,
11616            depth: fidl::encoding::Depth,
11617        ) -> fidl::Result<()> {
11618            encoder.debug_check_bounds::<ScanEnd>(offset);
11619            // Zero out padding regions. There's no need to apply masks
11620            // because the unmasked parts will be overwritten by fields.
11621            unsafe {
11622                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11623                (ptr as *mut u64).write_unaligned(0);
11624            }
11625            // Write the fields.
11626            self.0.encode(encoder, offset + 0, depth)?;
11627            self.1.encode(encoder, offset + 8, depth)?;
11628            Ok(())
11629        }
11630    }
11631
11632    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanEnd {
11633        #[inline(always)]
11634        fn new_empty() -> Self {
11635            Self { txn_id: fidl::new_empty!(u64, D), code: fidl::new_empty!(ScanResultCode, D) }
11636        }
11637
11638        #[inline]
11639        unsafe fn decode(
11640            &mut self,
11641            decoder: &mut fidl::encoding::Decoder<'_, D>,
11642            offset: usize,
11643            _depth: fidl::encoding::Depth,
11644        ) -> fidl::Result<()> {
11645            decoder.debug_check_bounds::<Self>(offset);
11646            // Verify that padding bytes are zero.
11647            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
11648            let padval = unsafe { (ptr as *const u64).read_unaligned() };
11649            let mask = 0xffffffff00000000u64;
11650            let maskedval = padval & mask;
11651            if maskedval != 0 {
11652                return Err(fidl::Error::NonZeroPadding {
11653                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
11654                });
11655            }
11656            fidl::decode!(u64, D, &mut self.txn_id, decoder, offset + 0, _depth)?;
11657            fidl::decode!(ScanResultCode, D, &mut self.code, decoder, offset + 8, _depth)?;
11658            Ok(())
11659        }
11660    }
11661
11662    impl fidl::encoding::ValueTypeMarker for ScanRequest {
11663        type Borrowed<'a> = &'a Self;
11664        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11665            value
11666        }
11667    }
11668
11669    unsafe impl fidl::encoding::TypeMarker for ScanRequest {
11670        type Owned = Self;
11671
11672        #[inline(always)]
11673        fn inline_align(_context: fidl::encoding::Context) -> usize {
11674            8
11675        }
11676
11677        #[inline(always)]
11678        fn inline_size(_context: fidl::encoding::Context) -> usize {
11679            64
11680        }
11681    }
11682
11683    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanRequest, D>
11684        for &ScanRequest
11685    {
11686        #[inline]
11687        unsafe fn encode(
11688            self,
11689            encoder: &mut fidl::encoding::Encoder<'_, D>,
11690            offset: usize,
11691            _depth: fidl::encoding::Depth,
11692        ) -> fidl::Result<()> {
11693            encoder.debug_check_bounds::<ScanRequest>(offset);
11694            // Delegate to tuple encoding.
11695            fidl::encoding::Encode::<ScanRequest, D>::encode(
11696                (
11697                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.txn_id),
11698                    <ScanTypes as fidl::encoding::ValueTypeMarker>::borrow(&self.scan_type),
11699                    <fidl::encoding::Vector<u8, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.channel_list),
11700                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>> as fidl::encoding::ValueTypeMarker>::borrow(&self.ssid_list),
11701                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.probe_delay),
11702                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.min_channel_time),
11703                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.max_channel_time),
11704                ),
11705                encoder, offset, _depth
11706            )
11707        }
11708    }
11709    unsafe impl<
11710        D: fidl::encoding::ResourceDialect,
11711        T0: fidl::encoding::Encode<u64, D>,
11712        T1: fidl::encoding::Encode<ScanTypes, D>,
11713        T2: fidl::encoding::Encode<fidl::encoding::Vector<u8, 256>, D>,
11714        T3: fidl::encoding::Encode<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>, D>,
11715        T4: fidl::encoding::Encode<u32, D>,
11716        T5: fidl::encoding::Encode<u32, D>,
11717        T6: fidl::encoding::Encode<u32, D>,
11718    > fidl::encoding::Encode<ScanRequest, D> for (T0, T1, T2, T3, T4, T5, T6)
11719    {
11720        #[inline]
11721        unsafe fn encode(
11722            self,
11723            encoder: &mut fidl::encoding::Encoder<'_, D>,
11724            offset: usize,
11725            depth: fidl::encoding::Depth,
11726        ) -> fidl::Result<()> {
11727            encoder.debug_check_bounds::<ScanRequest>(offset);
11728            // Zero out padding regions. There's no need to apply masks
11729            // because the unmasked parts will be overwritten by fields.
11730            unsafe {
11731                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
11732                (ptr as *mut u64).write_unaligned(0);
11733            }
11734            unsafe {
11735                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(56);
11736                (ptr as *mut u64).write_unaligned(0);
11737            }
11738            // Write the fields.
11739            self.0.encode(encoder, offset + 0, depth)?;
11740            self.1.encode(encoder, offset + 8, depth)?;
11741            self.2.encode(encoder, offset + 16, depth)?;
11742            self.3.encode(encoder, offset + 32, depth)?;
11743            self.4.encode(encoder, offset + 48, depth)?;
11744            self.5.encode(encoder, offset + 52, depth)?;
11745            self.6.encode(encoder, offset + 56, depth)?;
11746            Ok(())
11747        }
11748    }
11749
11750    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanRequest {
11751        #[inline(always)]
11752        fn new_empty() -> Self {
11753            Self {
11754                txn_id: fidl::new_empty!(u64, D),
11755                scan_type: fidl::new_empty!(ScanTypes, D),
11756                channel_list: fidl::new_empty!(fidl::encoding::Vector<u8, 256>, D),
11757                ssid_list: fidl::new_empty!(
11758                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>,
11759                    D
11760                ),
11761                probe_delay: fidl::new_empty!(u32, D),
11762                min_channel_time: fidl::new_empty!(u32, D),
11763                max_channel_time: fidl::new_empty!(u32, D),
11764            }
11765        }
11766
11767        #[inline]
11768        unsafe fn decode(
11769            &mut self,
11770            decoder: &mut fidl::encoding::Decoder<'_, D>,
11771            offset: usize,
11772            _depth: fidl::encoding::Depth,
11773        ) -> fidl::Result<()> {
11774            decoder.debug_check_bounds::<Self>(offset);
11775            // Verify that padding bytes are zero.
11776            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
11777            let padval = unsafe { (ptr as *const u64).read_unaligned() };
11778            let mask = 0xffffffff00000000u64;
11779            let maskedval = padval & mask;
11780            if maskedval != 0 {
11781                return Err(fidl::Error::NonZeroPadding {
11782                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
11783                });
11784            }
11785            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(56) };
11786            let padval = unsafe { (ptr as *const u64).read_unaligned() };
11787            let mask = 0xffffffff00000000u64;
11788            let maskedval = padval & mask;
11789            if maskedval != 0 {
11790                return Err(fidl::Error::NonZeroPadding {
11791                    padding_start: offset + 56 + ((mask as u64).trailing_zeros() / 8) as usize,
11792                });
11793            }
11794            fidl::decode!(u64, D, &mut self.txn_id, decoder, offset + 0, _depth)?;
11795            fidl::decode!(ScanTypes, D, &mut self.scan_type, decoder, offset + 8, _depth)?;
11796            fidl::decode!(fidl::encoding::Vector<u8, 256>, D, &mut self.channel_list, decoder, offset + 16, _depth)?;
11797            fidl::decode!(
11798                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 32>>,
11799                D,
11800                &mut self.ssid_list,
11801                decoder,
11802                offset + 32,
11803                _depth
11804            )?;
11805            fidl::decode!(u32, D, &mut self.probe_delay, decoder, offset + 48, _depth)?;
11806            fidl::decode!(u32, D, &mut self.min_channel_time, decoder, offset + 52, _depth)?;
11807            fidl::decode!(u32, D, &mut self.max_channel_time, decoder, offset + 56, _depth)?;
11808            Ok(())
11809        }
11810    }
11811
11812    impl fidl::encoding::ValueTypeMarker for ScanResult {
11813        type Borrowed<'a> = &'a Self;
11814        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11815            value
11816        }
11817    }
11818
11819    unsafe impl fidl::encoding::TypeMarker for ScanResult {
11820        type Owned = Self;
11821
11822        #[inline(always)]
11823        fn inline_align(_context: fidl::encoding::Context) -> usize {
11824            8
11825        }
11826
11827        #[inline(always)]
11828        fn inline_size(_context: fidl::encoding::Context) -> usize {
11829            64
11830        }
11831    }
11832
11833    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanResult, D>
11834        for &ScanResult
11835    {
11836        #[inline]
11837        unsafe fn encode(
11838            self,
11839            encoder: &mut fidl::encoding::Encoder<'_, D>,
11840            offset: usize,
11841            _depth: fidl::encoding::Depth,
11842        ) -> fidl::Result<()> {
11843            encoder.debug_check_bounds::<ScanResult>(offset);
11844            // Delegate to tuple encoding.
11845            fidl::encoding::Encode::<ScanResult, D>::encode(
11846                (
11847                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.txn_id),
11848                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timestamp_nanos),
11849                    <fidl_fuchsia_wlan_ieee80211__common::BssDescription as fidl::encoding::ValueTypeMarker>::borrow(&self.bss),
11850                ),
11851                encoder, offset, _depth
11852            )
11853        }
11854    }
11855    unsafe impl<
11856        D: fidl::encoding::ResourceDialect,
11857        T0: fidl::encoding::Encode<u64, D>,
11858        T1: fidl::encoding::Encode<i64, D>,
11859        T2: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::BssDescription, D>,
11860    > fidl::encoding::Encode<ScanResult, D> for (T0, T1, T2)
11861    {
11862        #[inline]
11863        unsafe fn encode(
11864            self,
11865            encoder: &mut fidl::encoding::Encoder<'_, D>,
11866            offset: usize,
11867            depth: fidl::encoding::Depth,
11868        ) -> fidl::Result<()> {
11869            encoder.debug_check_bounds::<ScanResult>(offset);
11870            // Zero out padding regions. There's no need to apply masks
11871            // because the unmasked parts will be overwritten by fields.
11872            // Write the fields.
11873            self.0.encode(encoder, offset + 0, depth)?;
11874            self.1.encode(encoder, offset + 8, depth)?;
11875            self.2.encode(encoder, offset + 16, depth)?;
11876            Ok(())
11877        }
11878    }
11879
11880    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanResult {
11881        #[inline(always)]
11882        fn new_empty() -> Self {
11883            Self {
11884                txn_id: fidl::new_empty!(u64, D),
11885                timestamp_nanos: fidl::new_empty!(i64, D),
11886                bss: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::BssDescription, D),
11887            }
11888        }
11889
11890        #[inline]
11891        unsafe fn decode(
11892            &mut self,
11893            decoder: &mut fidl::encoding::Decoder<'_, D>,
11894            offset: usize,
11895            _depth: fidl::encoding::Depth,
11896        ) -> fidl::Result<()> {
11897            decoder.debug_check_bounds::<Self>(offset);
11898            // Verify that padding bytes are zero.
11899            fidl::decode!(u64, D, &mut self.txn_id, decoder, offset + 0, _depth)?;
11900            fidl::decode!(i64, D, &mut self.timestamp_nanos, decoder, offset + 8, _depth)?;
11901            fidl::decode!(
11902                fidl_fuchsia_wlan_ieee80211__common::BssDescription,
11903                D,
11904                &mut self.bss,
11905                decoder,
11906                offset + 16,
11907                _depth
11908            )?;
11909            Ok(())
11910        }
11911    }
11912
11913    impl fidl::encoding::ValueTypeMarker for SetControlledPortRequest {
11914        type Borrowed<'a> = &'a Self;
11915        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11916            value
11917        }
11918    }
11919
11920    unsafe impl fidl::encoding::TypeMarker for SetControlledPortRequest {
11921        type Owned = Self;
11922
11923        #[inline(always)]
11924        fn inline_align(_context: fidl::encoding::Context) -> usize {
11925            4
11926        }
11927
11928        #[inline(always)]
11929        fn inline_size(_context: fidl::encoding::Context) -> usize {
11930            12
11931        }
11932    }
11933
11934    unsafe impl<D: fidl::encoding::ResourceDialect>
11935        fidl::encoding::Encode<SetControlledPortRequest, D> for &SetControlledPortRequest
11936    {
11937        #[inline]
11938        unsafe fn encode(
11939            self,
11940            encoder: &mut fidl::encoding::Encoder<'_, D>,
11941            offset: usize,
11942            _depth: fidl::encoding::Depth,
11943        ) -> fidl::Result<()> {
11944            encoder.debug_check_bounds::<SetControlledPortRequest>(offset);
11945            // Delegate to tuple encoding.
11946            fidl::encoding::Encode::<SetControlledPortRequest, D>::encode(
11947                (
11948                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(
11949                        &self.peer_sta_address,
11950                    ),
11951                    <ControlledPortState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
11952                ),
11953                encoder,
11954                offset,
11955                _depth,
11956            )
11957        }
11958    }
11959    unsafe impl<
11960        D: fidl::encoding::ResourceDialect,
11961        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
11962        T1: fidl::encoding::Encode<ControlledPortState, D>,
11963    > fidl::encoding::Encode<SetControlledPortRequest, D> for (T0, T1)
11964    {
11965        #[inline]
11966        unsafe fn encode(
11967            self,
11968            encoder: &mut fidl::encoding::Encoder<'_, D>,
11969            offset: usize,
11970            depth: fidl::encoding::Depth,
11971        ) -> fidl::Result<()> {
11972            encoder.debug_check_bounds::<SetControlledPortRequest>(offset);
11973            // Zero out padding regions. There's no need to apply masks
11974            // because the unmasked parts will be overwritten by fields.
11975            unsafe {
11976                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(4);
11977                (ptr as *mut u32).write_unaligned(0);
11978            }
11979            // Write the fields.
11980            self.0.encode(encoder, offset + 0, depth)?;
11981            self.1.encode(encoder, offset + 8, depth)?;
11982            Ok(())
11983        }
11984    }
11985
11986    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11987        for SetControlledPortRequest
11988    {
11989        #[inline(always)]
11990        fn new_empty() -> Self {
11991            Self {
11992                peer_sta_address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
11993                state: fidl::new_empty!(ControlledPortState, D),
11994            }
11995        }
11996
11997        #[inline]
11998        unsafe fn decode(
11999            &mut self,
12000            decoder: &mut fidl::encoding::Decoder<'_, D>,
12001            offset: usize,
12002            _depth: fidl::encoding::Depth,
12003        ) -> fidl::Result<()> {
12004            decoder.debug_check_bounds::<Self>(offset);
12005            // Verify that padding bytes are zero.
12006            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(4) };
12007            let padval = unsafe { (ptr as *const u32).read_unaligned() };
12008            let mask = 0xffff0000u32;
12009            let maskedval = padval & mask;
12010            if maskedval != 0 {
12011                return Err(fidl::Error::NonZeroPadding {
12012                    padding_start: offset + 4 + ((mask as u64).trailing_zeros() / 8) as usize,
12013                });
12014            }
12015            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.peer_sta_address, decoder, offset + 0, _depth)?;
12016            fidl::decode!(ControlledPortState, D, &mut self.state, decoder, offset + 8, _depth)?;
12017            Ok(())
12018        }
12019    }
12020
12021    impl fidl::encoding::ValueTypeMarker for SetKeyDescriptor {
12022        type Borrowed<'a> = &'a Self;
12023        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12024            value
12025        }
12026    }
12027
12028    unsafe impl fidl::encoding::TypeMarker for SetKeyDescriptor {
12029        type Owned = Self;
12030
12031        #[inline(always)]
12032        fn inline_align(_context: fidl::encoding::Context) -> usize {
12033            8
12034        }
12035
12036        #[inline(always)]
12037        fn inline_size(_context: fidl::encoding::Context) -> usize {
12038            48
12039        }
12040    }
12041
12042    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SetKeyDescriptor, D>
12043        for &SetKeyDescriptor
12044    {
12045        #[inline]
12046        unsafe fn encode(
12047            self,
12048            encoder: &mut fidl::encoding::Encoder<'_, D>,
12049            offset: usize,
12050            _depth: fidl::encoding::Depth,
12051        ) -> fidl::Result<()> {
12052            encoder.debug_check_bounds::<SetKeyDescriptor>(offset);
12053            // Delegate to tuple encoding.
12054            fidl::encoding::Encode::<SetKeyDescriptor, D>::encode(
12055                (
12056                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
12057                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.key_id),
12058                    <KeyType as fidl::encoding::ValueTypeMarker>::borrow(&self.key_type),
12059                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
12060                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.rsc),
12061                    <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.cipher_suite_oui),
12062                    <fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType as fidl::encoding::ValueTypeMarker>::borrow(&self.cipher_suite_type),
12063                ),
12064                encoder, offset, _depth
12065            )
12066        }
12067    }
12068    unsafe impl<
12069        D: fidl::encoding::ResourceDialect,
12070        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
12071        T1: fidl::encoding::Encode<u16, D>,
12072        T2: fidl::encoding::Encode<KeyType, D>,
12073        T3: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
12074        T4: fidl::encoding::Encode<u64, D>,
12075        T5: fidl::encoding::Encode<fidl::encoding::Array<u8, 3>, D>,
12076        T6: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType, D>,
12077    > fidl::encoding::Encode<SetKeyDescriptor, D> for (T0, T1, T2, T3, T4, T5, T6)
12078    {
12079        #[inline]
12080        unsafe fn encode(
12081            self,
12082            encoder: &mut fidl::encoding::Encoder<'_, D>,
12083            offset: usize,
12084            depth: fidl::encoding::Depth,
12085        ) -> fidl::Result<()> {
12086            encoder.debug_check_bounds::<SetKeyDescriptor>(offset);
12087            // Zero out padding regions. There's no need to apply masks
12088            // because the unmasked parts will be overwritten by fields.
12089            unsafe {
12090                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
12091                (ptr as *mut u64).write_unaligned(0);
12092            }
12093            unsafe {
12094                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
12095                (ptr as *mut u64).write_unaligned(0);
12096            }
12097            unsafe {
12098                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
12099                (ptr as *mut u64).write_unaligned(0);
12100            }
12101            // Write the fields.
12102            self.0.encode(encoder, offset + 0, depth)?;
12103            self.1.encode(encoder, offset + 16, depth)?;
12104            self.2.encode(encoder, offset + 20, depth)?;
12105            self.3.encode(encoder, offset + 24, depth)?;
12106            self.4.encode(encoder, offset + 32, depth)?;
12107            self.5.encode(encoder, offset + 40, depth)?;
12108            self.6.encode(encoder, offset + 44, depth)?;
12109            Ok(())
12110        }
12111    }
12112
12113    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SetKeyDescriptor {
12114        #[inline(always)]
12115        fn new_empty() -> Self {
12116            Self {
12117                key: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
12118                key_id: fidl::new_empty!(u16, D),
12119                key_type: fidl::new_empty!(KeyType, D),
12120                address: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
12121                rsc: fidl::new_empty!(u64, D),
12122                cipher_suite_oui: fidl::new_empty!(fidl::encoding::Array<u8, 3>, D),
12123                cipher_suite_type: fidl::new_empty!(
12124                    fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType,
12125                    D
12126                ),
12127            }
12128        }
12129
12130        #[inline]
12131        unsafe fn decode(
12132            &mut self,
12133            decoder: &mut fidl::encoding::Decoder<'_, D>,
12134            offset: usize,
12135            _depth: fidl::encoding::Depth,
12136        ) -> fidl::Result<()> {
12137            decoder.debug_check_bounds::<Self>(offset);
12138            // Verify that padding bytes are zero.
12139            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
12140            let padval = unsafe { (ptr as *const u64).read_unaligned() };
12141            let mask = 0xffff0000u64;
12142            let maskedval = padval & mask;
12143            if maskedval != 0 {
12144                return Err(fidl::Error::NonZeroPadding {
12145                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
12146                });
12147            }
12148            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
12149            let padval = unsafe { (ptr as *const u64).read_unaligned() };
12150            let mask = 0xffff000000000000u64;
12151            let maskedval = padval & mask;
12152            if maskedval != 0 {
12153                return Err(fidl::Error::NonZeroPadding {
12154                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
12155                });
12156            }
12157            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
12158            let padval = unsafe { (ptr as *const u64).read_unaligned() };
12159            let mask = 0xff000000u64;
12160            let maskedval = padval & mask;
12161            if maskedval != 0 {
12162                return Err(fidl::Error::NonZeroPadding {
12163                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
12164                });
12165            }
12166            fidl::decode!(
12167                fidl::encoding::UnboundedVector<u8>,
12168                D,
12169                &mut self.key,
12170                decoder,
12171                offset + 0,
12172                _depth
12173            )?;
12174            fidl::decode!(u16, D, &mut self.key_id, decoder, offset + 16, _depth)?;
12175            fidl::decode!(KeyType, D, &mut self.key_type, decoder, offset + 20, _depth)?;
12176            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.address, decoder, offset + 24, _depth)?;
12177            fidl::decode!(u64, D, &mut self.rsc, decoder, offset + 32, _depth)?;
12178            fidl::decode!(fidl::encoding::Array<u8, 3>, D, &mut self.cipher_suite_oui, decoder, offset + 40, _depth)?;
12179            fidl::decode!(
12180                fidl_fuchsia_wlan_ieee80211__common::CipherSuiteType,
12181                D,
12182                &mut self.cipher_suite_type,
12183                decoder,
12184                offset + 44,
12185                _depth
12186            )?;
12187            Ok(())
12188        }
12189    }
12190
12191    impl fidl::encoding::ValueTypeMarker for SetKeyResult {
12192        type Borrowed<'a> = &'a Self;
12193        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12194            value
12195        }
12196    }
12197
12198    unsafe impl fidl::encoding::TypeMarker for SetKeyResult {
12199        type Owned = Self;
12200
12201        #[inline(always)]
12202        fn inline_align(_context: fidl::encoding::Context) -> usize {
12203            4
12204        }
12205
12206        #[inline(always)]
12207        fn inline_size(_context: fidl::encoding::Context) -> usize {
12208            8
12209        }
12210    }
12211
12212    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SetKeyResult, D>
12213        for &SetKeyResult
12214    {
12215        #[inline]
12216        unsafe fn encode(
12217            self,
12218            encoder: &mut fidl::encoding::Encoder<'_, D>,
12219            offset: usize,
12220            _depth: fidl::encoding::Depth,
12221        ) -> fidl::Result<()> {
12222            encoder.debug_check_bounds::<SetKeyResult>(offset);
12223            unsafe {
12224                // Copy the object into the buffer.
12225                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
12226                (buf_ptr as *mut SetKeyResult)
12227                    .write_unaligned((self as *const SetKeyResult).read());
12228                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
12229                // done second because the memcpy will write garbage to these bytes.
12230                let padding_ptr = buf_ptr.offset(0) as *mut u32;
12231                let padding_mask = 0xffff0000u32;
12232                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
12233            }
12234            Ok(())
12235        }
12236    }
12237    unsafe impl<
12238        D: fidl::encoding::ResourceDialect,
12239        T0: fidl::encoding::Encode<u16, D>,
12240        T1: fidl::encoding::Encode<i32, D>,
12241    > fidl::encoding::Encode<SetKeyResult, D> for (T0, T1)
12242    {
12243        #[inline]
12244        unsafe fn encode(
12245            self,
12246            encoder: &mut fidl::encoding::Encoder<'_, D>,
12247            offset: usize,
12248            depth: fidl::encoding::Depth,
12249        ) -> fidl::Result<()> {
12250            encoder.debug_check_bounds::<SetKeyResult>(offset);
12251            // Zero out padding regions. There's no need to apply masks
12252            // because the unmasked parts will be overwritten by fields.
12253            unsafe {
12254                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
12255                (ptr as *mut u32).write_unaligned(0);
12256            }
12257            // Write the fields.
12258            self.0.encode(encoder, offset + 0, depth)?;
12259            self.1.encode(encoder, offset + 4, depth)?;
12260            Ok(())
12261        }
12262    }
12263
12264    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SetKeyResult {
12265        #[inline(always)]
12266        fn new_empty() -> Self {
12267            Self { key_id: fidl::new_empty!(u16, D), status: fidl::new_empty!(i32, D) }
12268        }
12269
12270        #[inline]
12271        unsafe fn decode(
12272            &mut self,
12273            decoder: &mut fidl::encoding::Decoder<'_, D>,
12274            offset: usize,
12275            _depth: fidl::encoding::Depth,
12276        ) -> fidl::Result<()> {
12277            decoder.debug_check_bounds::<Self>(offset);
12278            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
12279            // Verify that padding bytes are zero.
12280            let ptr = unsafe { buf_ptr.offset(0) };
12281            let padval = unsafe { (ptr as *const u32).read_unaligned() };
12282            let mask = 0xffff0000u32;
12283            let maskedval = padval & mask;
12284            if maskedval != 0 {
12285                return Err(fidl::Error::NonZeroPadding {
12286                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
12287                });
12288            }
12289            // Copy from the buffer into the object.
12290            unsafe {
12291                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
12292            }
12293            Ok(())
12294        }
12295    }
12296
12297    impl fidl::encoding::ValueTypeMarker for SetKeysConfirm {
12298        type Borrowed<'a> = &'a Self;
12299        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12300            value
12301        }
12302    }
12303
12304    unsafe impl fidl::encoding::TypeMarker for SetKeysConfirm {
12305        type Owned = Self;
12306
12307        #[inline(always)]
12308        fn inline_align(_context: fidl::encoding::Context) -> usize {
12309            8
12310        }
12311
12312        #[inline(always)]
12313        fn inline_size(_context: fidl::encoding::Context) -> usize {
12314            16
12315        }
12316    }
12317
12318    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SetKeysConfirm, D>
12319        for &SetKeysConfirm
12320    {
12321        #[inline]
12322        unsafe fn encode(
12323            self,
12324            encoder: &mut fidl::encoding::Encoder<'_, D>,
12325            offset: usize,
12326            _depth: fidl::encoding::Depth,
12327        ) -> fidl::Result<()> {
12328            encoder.debug_check_bounds::<SetKeysConfirm>(offset);
12329            // Delegate to tuple encoding.
12330            fidl::encoding::Encode::<SetKeysConfirm, D>::encode(
12331                (
12332                    <fidl::encoding::UnboundedVector<SetKeyResult> as fidl::encoding::ValueTypeMarker>::borrow(&self.results),
12333                ),
12334                encoder, offset, _depth
12335            )
12336        }
12337    }
12338    unsafe impl<
12339        D: fidl::encoding::ResourceDialect,
12340        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<SetKeyResult>, D>,
12341    > fidl::encoding::Encode<SetKeysConfirm, D> for (T0,)
12342    {
12343        #[inline]
12344        unsafe fn encode(
12345            self,
12346            encoder: &mut fidl::encoding::Encoder<'_, D>,
12347            offset: usize,
12348            depth: fidl::encoding::Depth,
12349        ) -> fidl::Result<()> {
12350            encoder.debug_check_bounds::<SetKeysConfirm>(offset);
12351            // Zero out padding regions. There's no need to apply masks
12352            // because the unmasked parts will be overwritten by fields.
12353            // Write the fields.
12354            self.0.encode(encoder, offset + 0, depth)?;
12355            Ok(())
12356        }
12357    }
12358
12359    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SetKeysConfirm {
12360        #[inline(always)]
12361        fn new_empty() -> Self {
12362            Self { results: fidl::new_empty!(fidl::encoding::UnboundedVector<SetKeyResult>, D) }
12363        }
12364
12365        #[inline]
12366        unsafe fn decode(
12367            &mut self,
12368            decoder: &mut fidl::encoding::Decoder<'_, D>,
12369            offset: usize,
12370            _depth: fidl::encoding::Depth,
12371        ) -> fidl::Result<()> {
12372            decoder.debug_check_bounds::<Self>(offset);
12373            // Verify that padding bytes are zero.
12374            fidl::decode!(
12375                fidl::encoding::UnboundedVector<SetKeyResult>,
12376                D,
12377                &mut self.results,
12378                decoder,
12379                offset + 0,
12380                _depth
12381            )?;
12382            Ok(())
12383        }
12384    }
12385
12386    impl fidl::encoding::ValueTypeMarker for SetKeysRequest {
12387        type Borrowed<'a> = &'a Self;
12388        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12389            value
12390        }
12391    }
12392
12393    unsafe impl fidl::encoding::TypeMarker for SetKeysRequest {
12394        type Owned = Self;
12395
12396        #[inline(always)]
12397        fn inline_align(_context: fidl::encoding::Context) -> usize {
12398            8
12399        }
12400
12401        #[inline(always)]
12402        fn inline_size(_context: fidl::encoding::Context) -> usize {
12403            16
12404        }
12405    }
12406
12407    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SetKeysRequest, D>
12408        for &SetKeysRequest
12409    {
12410        #[inline]
12411        unsafe fn encode(
12412            self,
12413            encoder: &mut fidl::encoding::Encoder<'_, D>,
12414            offset: usize,
12415            _depth: fidl::encoding::Depth,
12416        ) -> fidl::Result<()> {
12417            encoder.debug_check_bounds::<SetKeysRequest>(offset);
12418            // Delegate to tuple encoding.
12419            fidl::encoding::Encode::<SetKeysRequest, D>::encode(
12420                (
12421                    <fidl::encoding::UnboundedVector<SetKeyDescriptor> as fidl::encoding::ValueTypeMarker>::borrow(&self.keylist),
12422                ),
12423                encoder, offset, _depth
12424            )
12425        }
12426    }
12427    unsafe impl<
12428        D: fidl::encoding::ResourceDialect,
12429        T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<SetKeyDescriptor>, D>,
12430    > fidl::encoding::Encode<SetKeysRequest, D> for (T0,)
12431    {
12432        #[inline]
12433        unsafe fn encode(
12434            self,
12435            encoder: &mut fidl::encoding::Encoder<'_, D>,
12436            offset: usize,
12437            depth: fidl::encoding::Depth,
12438        ) -> fidl::Result<()> {
12439            encoder.debug_check_bounds::<SetKeysRequest>(offset);
12440            // Zero out padding regions. There's no need to apply masks
12441            // because the unmasked parts will be overwritten by fields.
12442            // Write the fields.
12443            self.0.encode(encoder, offset + 0, depth)?;
12444            Ok(())
12445        }
12446    }
12447
12448    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SetKeysRequest {
12449        #[inline(always)]
12450        fn new_empty() -> Self {
12451            Self { keylist: fidl::new_empty!(fidl::encoding::UnboundedVector<SetKeyDescriptor>, D) }
12452        }
12453
12454        #[inline]
12455        unsafe fn decode(
12456            &mut self,
12457            decoder: &mut fidl::encoding::Decoder<'_, D>,
12458            offset: usize,
12459            _depth: fidl::encoding::Depth,
12460        ) -> fidl::Result<()> {
12461            decoder.debug_check_bounds::<Self>(offset);
12462            // Verify that padding bytes are zero.
12463            fidl::decode!(
12464                fidl::encoding::UnboundedVector<SetKeyDescriptor>,
12465                D,
12466                &mut self.keylist,
12467                decoder,
12468                offset + 0,
12469                _depth
12470            )?;
12471            Ok(())
12472        }
12473    }
12474
12475    impl fidl::encoding::ValueTypeMarker for StartCaptureFramesRequest {
12476        type Borrowed<'a> = &'a Self;
12477        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12478            value
12479        }
12480    }
12481
12482    unsafe impl fidl::encoding::TypeMarker for StartCaptureFramesRequest {
12483        type Owned = Self;
12484
12485        #[inline(always)]
12486        fn inline_align(_context: fidl::encoding::Context) -> usize {
12487            4
12488        }
12489
12490        #[inline(always)]
12491        fn inline_size(_context: fidl::encoding::Context) -> usize {
12492            4
12493        }
12494    }
12495
12496    unsafe impl<D: fidl::encoding::ResourceDialect>
12497        fidl::encoding::Encode<StartCaptureFramesRequest, D> for &StartCaptureFramesRequest
12498    {
12499        #[inline]
12500        unsafe fn encode(
12501            self,
12502            encoder: &mut fidl::encoding::Encoder<'_, D>,
12503            offset: usize,
12504            _depth: fidl::encoding::Depth,
12505        ) -> fidl::Result<()> {
12506            encoder.debug_check_bounds::<StartCaptureFramesRequest>(offset);
12507            // Delegate to tuple encoding.
12508            fidl::encoding::Encode::<StartCaptureFramesRequest, D>::encode(
12509                (<MgmtFrameCaptureFlags as fidl::encoding::ValueTypeMarker>::borrow(
12510                    &self.mgmt_frame_flags,
12511                ),),
12512                encoder,
12513                offset,
12514                _depth,
12515            )
12516        }
12517    }
12518    unsafe impl<
12519        D: fidl::encoding::ResourceDialect,
12520        T0: fidl::encoding::Encode<MgmtFrameCaptureFlags, D>,
12521    > fidl::encoding::Encode<StartCaptureFramesRequest, D> for (T0,)
12522    {
12523        #[inline]
12524        unsafe fn encode(
12525            self,
12526            encoder: &mut fidl::encoding::Encoder<'_, D>,
12527            offset: usize,
12528            depth: fidl::encoding::Depth,
12529        ) -> fidl::Result<()> {
12530            encoder.debug_check_bounds::<StartCaptureFramesRequest>(offset);
12531            // Zero out padding regions. There's no need to apply masks
12532            // because the unmasked parts will be overwritten by fields.
12533            // Write the fields.
12534            self.0.encode(encoder, offset + 0, depth)?;
12535            Ok(())
12536        }
12537    }
12538
12539    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12540        for StartCaptureFramesRequest
12541    {
12542        #[inline(always)]
12543        fn new_empty() -> Self {
12544            Self { mgmt_frame_flags: fidl::new_empty!(MgmtFrameCaptureFlags, D) }
12545        }
12546
12547        #[inline]
12548        unsafe fn decode(
12549            &mut self,
12550            decoder: &mut fidl::encoding::Decoder<'_, D>,
12551            offset: usize,
12552            _depth: fidl::encoding::Depth,
12553        ) -> fidl::Result<()> {
12554            decoder.debug_check_bounds::<Self>(offset);
12555            // Verify that padding bytes are zero.
12556            fidl::decode!(
12557                MgmtFrameCaptureFlags,
12558                D,
12559                &mut self.mgmt_frame_flags,
12560                decoder,
12561                offset + 0,
12562                _depth
12563            )?;
12564            Ok(())
12565        }
12566    }
12567
12568    impl fidl::encoding::ValueTypeMarker for StartCaptureFramesResponse {
12569        type Borrowed<'a> = &'a Self;
12570        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12571            value
12572        }
12573    }
12574
12575    unsafe impl fidl::encoding::TypeMarker for StartCaptureFramesResponse {
12576        type Owned = Self;
12577
12578        #[inline(always)]
12579        fn inline_align(_context: fidl::encoding::Context) -> usize {
12580            4
12581        }
12582
12583        #[inline(always)]
12584        fn inline_size(_context: fidl::encoding::Context) -> usize {
12585            8
12586        }
12587    }
12588
12589    unsafe impl<D: fidl::encoding::ResourceDialect>
12590        fidl::encoding::Encode<StartCaptureFramesResponse, D> for &StartCaptureFramesResponse
12591    {
12592        #[inline]
12593        unsafe fn encode(
12594            self,
12595            encoder: &mut fidl::encoding::Encoder<'_, D>,
12596            offset: usize,
12597            _depth: fidl::encoding::Depth,
12598        ) -> fidl::Result<()> {
12599            encoder.debug_check_bounds::<StartCaptureFramesResponse>(offset);
12600            // Delegate to tuple encoding.
12601            fidl::encoding::Encode::<StartCaptureFramesResponse, D>::encode(
12602                (
12603                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
12604                    <MgmtFrameCaptureFlags as fidl::encoding::ValueTypeMarker>::borrow(
12605                        &self.supported_mgmt_frames,
12606                    ),
12607                ),
12608                encoder,
12609                offset,
12610                _depth,
12611            )
12612        }
12613    }
12614    unsafe impl<
12615        D: fidl::encoding::ResourceDialect,
12616        T0: fidl::encoding::Encode<i32, D>,
12617        T1: fidl::encoding::Encode<MgmtFrameCaptureFlags, D>,
12618    > fidl::encoding::Encode<StartCaptureFramesResponse, D> for (T0, T1)
12619    {
12620        #[inline]
12621        unsafe fn encode(
12622            self,
12623            encoder: &mut fidl::encoding::Encoder<'_, D>,
12624            offset: usize,
12625            depth: fidl::encoding::Depth,
12626        ) -> fidl::Result<()> {
12627            encoder.debug_check_bounds::<StartCaptureFramesResponse>(offset);
12628            // Zero out padding regions. There's no need to apply masks
12629            // because the unmasked parts will be overwritten by fields.
12630            // Write the fields.
12631            self.0.encode(encoder, offset + 0, depth)?;
12632            self.1.encode(encoder, offset + 4, depth)?;
12633            Ok(())
12634        }
12635    }
12636
12637    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12638        for StartCaptureFramesResponse
12639    {
12640        #[inline(always)]
12641        fn new_empty() -> Self {
12642            Self {
12643                status: fidl::new_empty!(i32, D),
12644                supported_mgmt_frames: fidl::new_empty!(MgmtFrameCaptureFlags, D),
12645            }
12646        }
12647
12648        #[inline]
12649        unsafe fn decode(
12650            &mut self,
12651            decoder: &mut fidl::encoding::Decoder<'_, D>,
12652            offset: usize,
12653            _depth: fidl::encoding::Depth,
12654        ) -> fidl::Result<()> {
12655            decoder.debug_check_bounds::<Self>(offset);
12656            // Verify that padding bytes are zero.
12657            fidl::decode!(i32, D, &mut self.status, decoder, offset + 0, _depth)?;
12658            fidl::decode!(
12659                MgmtFrameCaptureFlags,
12660                D,
12661                &mut self.supported_mgmt_frames,
12662                decoder,
12663                offset + 4,
12664                _depth
12665            )?;
12666            Ok(())
12667        }
12668    }
12669
12670    impl fidl::encoding::ValueTypeMarker for StartConfirm {
12671        type Borrowed<'a> = &'a Self;
12672        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12673            value
12674        }
12675    }
12676
12677    unsafe impl fidl::encoding::TypeMarker for StartConfirm {
12678        type Owned = Self;
12679
12680        #[inline(always)]
12681        fn inline_align(_context: fidl::encoding::Context) -> usize {
12682            4
12683        }
12684
12685        #[inline(always)]
12686        fn inline_size(_context: fidl::encoding::Context) -> usize {
12687            4
12688        }
12689    }
12690
12691    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StartConfirm, D>
12692        for &StartConfirm
12693    {
12694        #[inline]
12695        unsafe fn encode(
12696            self,
12697            encoder: &mut fidl::encoding::Encoder<'_, D>,
12698            offset: usize,
12699            _depth: fidl::encoding::Depth,
12700        ) -> fidl::Result<()> {
12701            encoder.debug_check_bounds::<StartConfirm>(offset);
12702            // Delegate to tuple encoding.
12703            fidl::encoding::Encode::<StartConfirm, D>::encode(
12704                (<StartResultCode as fidl::encoding::ValueTypeMarker>::borrow(&self.result_code),),
12705                encoder,
12706                offset,
12707                _depth,
12708            )
12709        }
12710    }
12711    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StartResultCode, D>>
12712        fidl::encoding::Encode<StartConfirm, D> for (T0,)
12713    {
12714        #[inline]
12715        unsafe fn encode(
12716            self,
12717            encoder: &mut fidl::encoding::Encoder<'_, D>,
12718            offset: usize,
12719            depth: fidl::encoding::Depth,
12720        ) -> fidl::Result<()> {
12721            encoder.debug_check_bounds::<StartConfirm>(offset);
12722            // Zero out padding regions. There's no need to apply masks
12723            // because the unmasked parts will be overwritten by fields.
12724            // Write the fields.
12725            self.0.encode(encoder, offset + 0, depth)?;
12726            Ok(())
12727        }
12728    }
12729
12730    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartConfirm {
12731        #[inline(always)]
12732        fn new_empty() -> Self {
12733            Self { result_code: fidl::new_empty!(StartResultCode, D) }
12734        }
12735
12736        #[inline]
12737        unsafe fn decode(
12738            &mut self,
12739            decoder: &mut fidl::encoding::Decoder<'_, D>,
12740            offset: usize,
12741            _depth: fidl::encoding::Depth,
12742        ) -> fidl::Result<()> {
12743            decoder.debug_check_bounds::<Self>(offset);
12744            // Verify that padding bytes are zero.
12745            fidl::decode!(StartResultCode, D, &mut self.result_code, decoder, offset + 0, _depth)?;
12746            Ok(())
12747        }
12748    }
12749
12750    impl fidl::encoding::ValueTypeMarker for StartRequest {
12751        type Borrowed<'a> = &'a Self;
12752        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12753            value
12754        }
12755    }
12756
12757    unsafe impl fidl::encoding::TypeMarker for StartRequest {
12758        type Owned = Self;
12759
12760        #[inline(always)]
12761        fn inline_align(_context: fidl::encoding::Context) -> usize {
12762            8
12763        }
12764
12765        #[inline(always)]
12766        fn inline_size(_context: fidl::encoding::Context) -> usize {
12767            96
12768        }
12769    }
12770
12771    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StartRequest, D>
12772        for &StartRequest
12773    {
12774        #[inline]
12775        unsafe fn encode(
12776            self,
12777            encoder: &mut fidl::encoding::Encoder<'_, D>,
12778            offset: usize,
12779            _depth: fidl::encoding::Depth,
12780        ) -> fidl::Result<()> {
12781            encoder.debug_check_bounds::<StartRequest>(offset);
12782            // Delegate to tuple encoding.
12783            fidl::encoding::Encode::<StartRequest, D>::encode(
12784                (
12785                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.ssid),
12786                    <fidl_fuchsia_wlan_ieee80211__common::BssType as fidl::encoding::ValueTypeMarker>::borrow(&self.bss_type),
12787                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.beacon_period),
12788                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.dtim_period),
12789                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.channel),
12790                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.capability_info),
12791                    <fidl::encoding::Vector<u8, 14> as fidl::encoding::ValueTypeMarker>::borrow(&self.rates),
12792                    <Country as fidl::encoding::ValueTypeMarker>::borrow(&self.country),
12793                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.mesh_id),
12794                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>> as fidl::encoding::ValueTypeMarker>::borrow(&self.rsne),
12795                    <fidl_fuchsia_wlan_ieee80211__common::WlanPhyType as fidl::encoding::ValueTypeMarker>::borrow(&self.phy),
12796                    <fidl_fuchsia_wlan_ieee80211__common::ChannelBandwidth as fidl::encoding::ValueTypeMarker>::borrow(&self.channel_bandwidth),
12797                ),
12798                encoder, offset, _depth
12799            )
12800        }
12801    }
12802    unsafe impl<
12803        D: fidl::encoding::ResourceDialect,
12804        T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 32>, D>,
12805        T1: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::BssType, D>,
12806        T2: fidl::encoding::Encode<u16, D>,
12807        T3: fidl::encoding::Encode<u8, D>,
12808        T4: fidl::encoding::Encode<u8, D>,
12809        T5: fidl::encoding::Encode<u16, D>,
12810        T6: fidl::encoding::Encode<fidl::encoding::Vector<u8, 14>, D>,
12811        T7: fidl::encoding::Encode<Country, D>,
12812        T8: fidl::encoding::Encode<fidl::encoding::Vector<u8, 32>, D>,
12813        T9: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>>, D>,
12814        T10: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::WlanPhyType, D>,
12815        T11: fidl::encoding::Encode<fidl_fuchsia_wlan_ieee80211__common::ChannelBandwidth, D>,
12816    > fidl::encoding::Encode<StartRequest, D>
12817        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
12818    {
12819        #[inline]
12820        unsafe fn encode(
12821            self,
12822            encoder: &mut fidl::encoding::Encoder<'_, D>,
12823            offset: usize,
12824            depth: fidl::encoding::Depth,
12825        ) -> fidl::Result<()> {
12826            encoder.debug_check_bounds::<StartRequest>(offset);
12827            // Zero out padding regions. There's no need to apply masks
12828            // because the unmasked parts will be overwritten by fields.
12829            unsafe {
12830                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
12831                (ptr as *mut u64).write_unaligned(0);
12832            }
12833            unsafe {
12834                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
12835                (ptr as *mut u64).write_unaligned(0);
12836            }
12837            // Write the fields.
12838            self.0.encode(encoder, offset + 0, depth)?;
12839            self.1.encode(encoder, offset + 16, depth)?;
12840            self.2.encode(encoder, offset + 20, depth)?;
12841            self.3.encode(encoder, offset + 22, depth)?;
12842            self.4.encode(encoder, offset + 23, depth)?;
12843            self.5.encode(encoder, offset + 24, depth)?;
12844            self.6.encode(encoder, offset + 32, depth)?;
12845            self.7.encode(encoder, offset + 48, depth)?;
12846            self.8.encode(encoder, offset + 56, depth)?;
12847            self.9.encode(encoder, offset + 72, depth)?;
12848            self.10.encode(encoder, offset + 88, depth)?;
12849            self.11.encode(encoder, offset + 92, depth)?;
12850            Ok(())
12851        }
12852    }
12853
12854    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartRequest {
12855        #[inline(always)]
12856        fn new_empty() -> Self {
12857            Self {
12858                ssid: fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D),
12859                bss_type: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::BssType, D),
12860                beacon_period: fidl::new_empty!(u16, D),
12861                dtim_period: fidl::new_empty!(u8, D),
12862                channel: fidl::new_empty!(u8, D),
12863                capability_info: fidl::new_empty!(u16, D),
12864                rates: fidl::new_empty!(fidl::encoding::Vector<u8, 14>, D),
12865                country: fidl::new_empty!(Country, D),
12866                mesh_id: fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D),
12867                rsne: fidl::new_empty!(
12868                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>>,
12869                    D
12870                ),
12871                phy: fidl::new_empty!(fidl_fuchsia_wlan_ieee80211__common::WlanPhyType, D),
12872                channel_bandwidth: fidl::new_empty!(
12873                    fidl_fuchsia_wlan_ieee80211__common::ChannelBandwidth,
12874                    D
12875                ),
12876            }
12877        }
12878
12879        #[inline]
12880        unsafe fn decode(
12881            &mut self,
12882            decoder: &mut fidl::encoding::Decoder<'_, D>,
12883            offset: usize,
12884            _depth: fidl::encoding::Depth,
12885        ) -> fidl::Result<()> {
12886            decoder.debug_check_bounds::<Self>(offset);
12887            // Verify that padding bytes are zero.
12888            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
12889            let padval = unsafe { (ptr as *const u64).read_unaligned() };
12890            let mask = 0xffffffffffff0000u64;
12891            let maskedval = padval & mask;
12892            if maskedval != 0 {
12893                return Err(fidl::Error::NonZeroPadding {
12894                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
12895                });
12896            }
12897            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
12898            let padval = unsafe { (ptr as *const u64).read_unaligned() };
12899            let mask = 0xffffffffff000000u64;
12900            let maskedval = padval & mask;
12901            if maskedval != 0 {
12902                return Err(fidl::Error::NonZeroPadding {
12903                    padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
12904                });
12905            }
12906            fidl::decode!(fidl::encoding::Vector<u8, 32>, D, &mut self.ssid, decoder, offset + 0, _depth)?;
12907            fidl::decode!(
12908                fidl_fuchsia_wlan_ieee80211__common::BssType,
12909                D,
12910                &mut self.bss_type,
12911                decoder,
12912                offset + 16,
12913                _depth
12914            )?;
12915            fidl::decode!(u16, D, &mut self.beacon_period, decoder, offset + 20, _depth)?;
12916            fidl::decode!(u8, D, &mut self.dtim_period, decoder, offset + 22, _depth)?;
12917            fidl::decode!(u8, D, &mut self.channel, decoder, offset + 23, _depth)?;
12918            fidl::decode!(u16, D, &mut self.capability_info, decoder, offset + 24, _depth)?;
12919            fidl::decode!(fidl::encoding::Vector<u8, 14>, D, &mut self.rates, decoder, offset + 32, _depth)?;
12920            fidl::decode!(Country, D, &mut self.country, decoder, offset + 48, _depth)?;
12921            fidl::decode!(fidl::encoding::Vector<u8, 32>, D, &mut self.mesh_id, decoder, offset + 56, _depth)?;
12922            fidl::decode!(
12923                fidl::encoding::Optional<fidl::encoding::Vector<u8, 257>>,
12924                D,
12925                &mut self.rsne,
12926                decoder,
12927                offset + 72,
12928                _depth
12929            )?;
12930            fidl::decode!(
12931                fidl_fuchsia_wlan_ieee80211__common::WlanPhyType,
12932                D,
12933                &mut self.phy,
12934                decoder,
12935                offset + 88,
12936                _depth
12937            )?;
12938            fidl::decode!(
12939                fidl_fuchsia_wlan_ieee80211__common::ChannelBandwidth,
12940                D,
12941                &mut self.channel_bandwidth,
12942                decoder,
12943                offset + 92,
12944                _depth
12945            )?;
12946            Ok(())
12947        }
12948    }
12949
12950    impl fidl::encoding::ValueTypeMarker for StopConfirm {
12951        type Borrowed<'a> = &'a Self;
12952        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12953            value
12954        }
12955    }
12956
12957    unsafe impl fidl::encoding::TypeMarker for StopConfirm {
12958        type Owned = Self;
12959
12960        #[inline(always)]
12961        fn inline_align(_context: fidl::encoding::Context) -> usize {
12962            4
12963        }
12964
12965        #[inline(always)]
12966        fn inline_size(_context: fidl::encoding::Context) -> usize {
12967            4
12968        }
12969    }
12970
12971    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StopConfirm, D>
12972        for &StopConfirm
12973    {
12974        #[inline]
12975        unsafe fn encode(
12976            self,
12977            encoder: &mut fidl::encoding::Encoder<'_, D>,
12978            offset: usize,
12979            _depth: fidl::encoding::Depth,
12980        ) -> fidl::Result<()> {
12981            encoder.debug_check_bounds::<StopConfirm>(offset);
12982            // Delegate to tuple encoding.
12983            fidl::encoding::Encode::<StopConfirm, D>::encode(
12984                (<StopResultCode as fidl::encoding::ValueTypeMarker>::borrow(&self.result_code),),
12985                encoder,
12986                offset,
12987                _depth,
12988            )
12989        }
12990    }
12991    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<StopResultCode, D>>
12992        fidl::encoding::Encode<StopConfirm, D> for (T0,)
12993    {
12994        #[inline]
12995        unsafe fn encode(
12996            self,
12997            encoder: &mut fidl::encoding::Encoder<'_, D>,
12998            offset: usize,
12999            depth: fidl::encoding::Depth,
13000        ) -> fidl::Result<()> {
13001            encoder.debug_check_bounds::<StopConfirm>(offset);
13002            // Zero out padding regions. There's no need to apply masks
13003            // because the unmasked parts will be overwritten by fields.
13004            // Write the fields.
13005            self.0.encode(encoder, offset + 0, depth)?;
13006            Ok(())
13007        }
13008    }
13009
13010    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopConfirm {
13011        #[inline(always)]
13012        fn new_empty() -> Self {
13013            Self { result_code: fidl::new_empty!(StopResultCode, D) }
13014        }
13015
13016        #[inline]
13017        unsafe fn decode(
13018            &mut self,
13019            decoder: &mut fidl::encoding::Decoder<'_, D>,
13020            offset: usize,
13021            _depth: fidl::encoding::Depth,
13022        ) -> fidl::Result<()> {
13023            decoder.debug_check_bounds::<Self>(offset);
13024            // Verify that padding bytes are zero.
13025            fidl::decode!(StopResultCode, D, &mut self.result_code, decoder, offset + 0, _depth)?;
13026            Ok(())
13027        }
13028    }
13029
13030    impl fidl::encoding::ValueTypeMarker for StopRequest {
13031        type Borrowed<'a> = &'a Self;
13032        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13033            value
13034        }
13035    }
13036
13037    unsafe impl fidl::encoding::TypeMarker for StopRequest {
13038        type Owned = Self;
13039
13040        #[inline(always)]
13041        fn inline_align(_context: fidl::encoding::Context) -> usize {
13042            8
13043        }
13044
13045        #[inline(always)]
13046        fn inline_size(_context: fidl::encoding::Context) -> usize {
13047            16
13048        }
13049    }
13050
13051    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StopRequest, D>
13052        for &StopRequest
13053    {
13054        #[inline]
13055        unsafe fn encode(
13056            self,
13057            encoder: &mut fidl::encoding::Encoder<'_, D>,
13058            offset: usize,
13059            _depth: fidl::encoding::Depth,
13060        ) -> fidl::Result<()> {
13061            encoder.debug_check_bounds::<StopRequest>(offset);
13062            // Delegate to tuple encoding.
13063            fidl::encoding::Encode::<StopRequest, D>::encode(
13064                (<fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow(
13065                    &self.ssid,
13066                ),),
13067                encoder,
13068                offset,
13069                _depth,
13070            )
13071        }
13072    }
13073    unsafe impl<
13074        D: fidl::encoding::ResourceDialect,
13075        T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 32>, D>,
13076    > fidl::encoding::Encode<StopRequest, D> for (T0,)
13077    {
13078        #[inline]
13079        unsafe fn encode(
13080            self,
13081            encoder: &mut fidl::encoding::Encoder<'_, D>,
13082            offset: usize,
13083            depth: fidl::encoding::Depth,
13084        ) -> fidl::Result<()> {
13085            encoder.debug_check_bounds::<StopRequest>(offset);
13086            // Zero out padding regions. There's no need to apply masks
13087            // because the unmasked parts will be overwritten by fields.
13088            // Write the fields.
13089            self.0.encode(encoder, offset + 0, depth)?;
13090            Ok(())
13091        }
13092    }
13093
13094    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopRequest {
13095        #[inline(always)]
13096        fn new_empty() -> Self {
13097            Self { ssid: fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D) }
13098        }
13099
13100        #[inline]
13101        unsafe fn decode(
13102            &mut self,
13103            decoder: &mut fidl::encoding::Decoder<'_, D>,
13104            offset: usize,
13105            _depth: fidl::encoding::Depth,
13106        ) -> fidl::Result<()> {
13107            decoder.debug_check_bounds::<Self>(offset);
13108            // Verify that padding bytes are zero.
13109            fidl::decode!(fidl::encoding::Vector<u8, 32>, D, &mut self.ssid, decoder, offset + 0, _depth)?;
13110            Ok(())
13111        }
13112    }
13113
13114    impl fidl::encoding::ValueTypeMarker for WmmParameter {
13115        type Borrowed<'a> = &'a Self;
13116        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13117            value
13118        }
13119    }
13120
13121    unsafe impl fidl::encoding::TypeMarker for WmmParameter {
13122        type Owned = Self;
13123
13124        #[inline(always)]
13125        fn inline_align(_context: fidl::encoding::Context) -> usize {
13126            1
13127        }
13128
13129        #[inline(always)]
13130        fn inline_size(_context: fidl::encoding::Context) -> usize {
13131            18
13132        }
13133        #[inline(always)]
13134        fn encode_is_copy() -> bool {
13135            true
13136        }
13137
13138        #[inline(always)]
13139        fn decode_is_copy() -> bool {
13140            true
13141        }
13142    }
13143
13144    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WmmParameter, D>
13145        for &WmmParameter
13146    {
13147        #[inline]
13148        unsafe fn encode(
13149            self,
13150            encoder: &mut fidl::encoding::Encoder<'_, D>,
13151            offset: usize,
13152            _depth: fidl::encoding::Depth,
13153        ) -> fidl::Result<()> {
13154            encoder.debug_check_bounds::<WmmParameter>(offset);
13155            unsafe {
13156                // Copy the object into the buffer.
13157                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
13158                (buf_ptr as *mut WmmParameter)
13159                    .write_unaligned((self as *const WmmParameter).read());
13160                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
13161                // done second because the memcpy will write garbage to these bytes.
13162            }
13163            Ok(())
13164        }
13165    }
13166    unsafe impl<
13167        D: fidl::encoding::ResourceDialect,
13168        T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 18>, D>,
13169    > fidl::encoding::Encode<WmmParameter, D> for (T0,)
13170    {
13171        #[inline]
13172        unsafe fn encode(
13173            self,
13174            encoder: &mut fidl::encoding::Encoder<'_, D>,
13175            offset: usize,
13176            depth: fidl::encoding::Depth,
13177        ) -> fidl::Result<()> {
13178            encoder.debug_check_bounds::<WmmParameter>(offset);
13179            // Zero out padding regions. There's no need to apply masks
13180            // because the unmasked parts will be overwritten by fields.
13181            // Write the fields.
13182            self.0.encode(encoder, offset + 0, depth)?;
13183            Ok(())
13184        }
13185    }
13186
13187    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WmmParameter {
13188        #[inline(always)]
13189        fn new_empty() -> Self {
13190            Self { bytes: fidl::new_empty!(fidl::encoding::Array<u8, 18>, D) }
13191        }
13192
13193        #[inline]
13194        unsafe fn decode(
13195            &mut self,
13196            decoder: &mut fidl::encoding::Decoder<'_, D>,
13197            offset: usize,
13198            _depth: fidl::encoding::Depth,
13199        ) -> fidl::Result<()> {
13200            decoder.debug_check_bounds::<Self>(offset);
13201            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
13202            // Verify that padding bytes are zero.
13203            // Copy from the buffer into the object.
13204            unsafe {
13205                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 18);
13206            }
13207            Ok(())
13208        }
13209    }
13210
13211    impl fidl::encoding::ValueTypeMarker for GetIfaceHistogramStatsResponse {
13212        type Borrowed<'a> = &'a Self;
13213        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13214            value
13215        }
13216    }
13217
13218    unsafe impl fidl::encoding::TypeMarker for GetIfaceHistogramStatsResponse {
13219        type Owned = Self;
13220
13221        #[inline(always)]
13222        fn inline_align(_context: fidl::encoding::Context) -> usize {
13223            8
13224        }
13225
13226        #[inline(always)]
13227        fn inline_size(_context: fidl::encoding::Context) -> usize {
13228            16
13229        }
13230    }
13231
13232    unsafe impl<D: fidl::encoding::ResourceDialect>
13233        fidl::encoding::Encode<GetIfaceHistogramStatsResponse, D>
13234        for &GetIfaceHistogramStatsResponse
13235    {
13236        #[inline]
13237        unsafe fn encode(
13238            self,
13239            encoder: &mut fidl::encoding::Encoder<'_, D>,
13240            offset: usize,
13241            _depth: fidl::encoding::Depth,
13242        ) -> fidl::Result<()> {
13243            encoder.debug_check_bounds::<GetIfaceHistogramStatsResponse>(offset);
13244            encoder.write_num::<u64>(self.ordinal(), offset);
13245            match self {
13246            GetIfaceHistogramStatsResponse::Stats(ref val) => {
13247                fidl::encoding::encode_in_envelope::<fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D>(
13248                    <fidl_fuchsia_wlan_stats__common::IfaceHistogramStats as fidl::encoding::ValueTypeMarker>::borrow(val),
13249                    encoder, offset + 8, _depth
13250                )
13251            }
13252            GetIfaceHistogramStatsResponse::ErrorStatus(ref val) => {
13253                fidl::encoding::encode_in_envelope::<i32, D>(
13254                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
13255                    encoder, offset + 8, _depth
13256                )
13257            }
13258        }
13259        }
13260    }
13261
13262    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
13263        for GetIfaceHistogramStatsResponse
13264    {
13265        #[inline(always)]
13266        fn new_empty() -> Self {
13267            Self::Stats(fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D))
13268        }
13269
13270        #[inline]
13271        unsafe fn decode(
13272            &mut self,
13273            decoder: &mut fidl::encoding::Decoder<'_, D>,
13274            offset: usize,
13275            mut depth: fidl::encoding::Depth,
13276        ) -> fidl::Result<()> {
13277            decoder.debug_check_bounds::<Self>(offset);
13278            #[allow(unused_variables)]
13279            let next_out_of_line = decoder.next_out_of_line();
13280            let handles_before = decoder.remaining_handles();
13281            let (ordinal, inlined, num_bytes, num_handles) =
13282                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
13283
13284            let member_inline_size = match ordinal {
13285            1 => <fidl_fuchsia_wlan_stats__common::IfaceHistogramStats as fidl::encoding::TypeMarker>::inline_size(decoder.context),
13286            2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
13287            _ => return Err(fidl::Error::UnknownUnionTag),
13288        };
13289
13290            if inlined != (member_inline_size <= 4) {
13291                return Err(fidl::Error::InvalidInlineBitInEnvelope);
13292            }
13293            let _inner_offset;
13294            if inlined {
13295                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
13296                _inner_offset = offset + 8;
13297            } else {
13298                depth.increment()?;
13299                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13300            }
13301            match ordinal {
13302                1 => {
13303                    #[allow(irrefutable_let_patterns)]
13304                    if let GetIfaceHistogramStatsResponse::Stats(_) = self {
13305                        // Do nothing, read the value into the object
13306                    } else {
13307                        // Initialize `self` to the right variant
13308                        *self = GetIfaceHistogramStatsResponse::Stats(fidl::new_empty!(
13309                            fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
13310                            D
13311                        ));
13312                    }
13313                    #[allow(irrefutable_let_patterns)]
13314                    if let GetIfaceHistogramStatsResponse::Stats(ref mut val) = self {
13315                        fidl::decode!(
13316                            fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
13317                            D,
13318                            val,
13319                            decoder,
13320                            _inner_offset,
13321                            depth
13322                        )?;
13323                    } else {
13324                        unreachable!()
13325                    }
13326                }
13327                2 => {
13328                    #[allow(irrefutable_let_patterns)]
13329                    if let GetIfaceHistogramStatsResponse::ErrorStatus(_) = self {
13330                        // Do nothing, read the value into the object
13331                    } else {
13332                        // Initialize `self` to the right variant
13333                        *self =
13334                            GetIfaceHistogramStatsResponse::ErrorStatus(fidl::new_empty!(i32, D));
13335                    }
13336                    #[allow(irrefutable_let_patterns)]
13337                    if let GetIfaceHistogramStatsResponse::ErrorStatus(ref mut val) = self {
13338                        fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
13339                    } else {
13340                        unreachable!()
13341                    }
13342                }
13343                ordinal => panic!("unexpected ordinal {:?}", ordinal),
13344            }
13345            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
13346                return Err(fidl::Error::InvalidNumBytesInEnvelope);
13347            }
13348            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13349                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13350            }
13351            Ok(())
13352        }
13353    }
13354
13355    impl fidl::encoding::ValueTypeMarker for GetIfaceStatsResponse {
13356        type Borrowed<'a> = &'a Self;
13357        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13358            value
13359        }
13360    }
13361
13362    unsafe impl fidl::encoding::TypeMarker for GetIfaceStatsResponse {
13363        type Owned = Self;
13364
13365        #[inline(always)]
13366        fn inline_align(_context: fidl::encoding::Context) -> usize {
13367            8
13368        }
13369
13370        #[inline(always)]
13371        fn inline_size(_context: fidl::encoding::Context) -> usize {
13372            16
13373        }
13374    }
13375
13376    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<GetIfaceStatsResponse, D>
13377        for &GetIfaceStatsResponse
13378    {
13379        #[inline]
13380        unsafe fn encode(
13381            self,
13382            encoder: &mut fidl::encoding::Encoder<'_, D>,
13383            offset: usize,
13384            _depth: fidl::encoding::Depth,
13385        ) -> fidl::Result<()> {
13386            encoder.debug_check_bounds::<GetIfaceStatsResponse>(offset);
13387            encoder.write_num::<u64>(self.ordinal(), offset);
13388            match self {
13389            GetIfaceStatsResponse::Stats(ref val) => {
13390                fidl::encoding::encode_in_envelope::<fidl_fuchsia_wlan_stats__common::IfaceStats, D>(
13391                    <fidl_fuchsia_wlan_stats__common::IfaceStats as fidl::encoding::ValueTypeMarker>::borrow(val),
13392                    encoder, offset + 8, _depth
13393                )
13394            }
13395            GetIfaceStatsResponse::ErrorStatus(ref val) => {
13396                fidl::encoding::encode_in_envelope::<i32, D>(
13397                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
13398                    encoder, offset + 8, _depth
13399                )
13400            }
13401        }
13402        }
13403    }
13404
13405    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetIfaceStatsResponse {
13406        #[inline(always)]
13407        fn new_empty() -> Self {
13408            Self::Stats(fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceStats, D))
13409        }
13410
13411        #[inline]
13412        unsafe fn decode(
13413            &mut self,
13414            decoder: &mut fidl::encoding::Decoder<'_, D>,
13415            offset: usize,
13416            mut depth: fidl::encoding::Depth,
13417        ) -> fidl::Result<()> {
13418            decoder.debug_check_bounds::<Self>(offset);
13419            #[allow(unused_variables)]
13420            let next_out_of_line = decoder.next_out_of_line();
13421            let handles_before = decoder.remaining_handles();
13422            let (ordinal, inlined, num_bytes, num_handles) =
13423                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
13424
13425            let member_inline_size = match ordinal {
13426            1 => <fidl_fuchsia_wlan_stats__common::IfaceStats as fidl::encoding::TypeMarker>::inline_size(decoder.context),
13427            2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
13428            _ => return Err(fidl::Error::UnknownUnionTag),
13429        };
13430
13431            if inlined != (member_inline_size <= 4) {
13432                return Err(fidl::Error::InvalidInlineBitInEnvelope);
13433            }
13434            let _inner_offset;
13435            if inlined {
13436                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
13437                _inner_offset = offset + 8;
13438            } else {
13439                depth.increment()?;
13440                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13441            }
13442            match ordinal {
13443                1 => {
13444                    #[allow(irrefutable_let_patterns)]
13445                    if let GetIfaceStatsResponse::Stats(_) = self {
13446                        // Do nothing, read the value into the object
13447                    } else {
13448                        // Initialize `self` to the right variant
13449                        *self = GetIfaceStatsResponse::Stats(fidl::new_empty!(
13450                            fidl_fuchsia_wlan_stats__common::IfaceStats,
13451                            D
13452                        ));
13453                    }
13454                    #[allow(irrefutable_let_patterns)]
13455                    if let GetIfaceStatsResponse::Stats(ref mut val) = self {
13456                        fidl::decode!(
13457                            fidl_fuchsia_wlan_stats__common::IfaceStats,
13458                            D,
13459                            val,
13460                            decoder,
13461                            _inner_offset,
13462                            depth
13463                        )?;
13464                    } else {
13465                        unreachable!()
13466                    }
13467                }
13468                2 => {
13469                    #[allow(irrefutable_let_patterns)]
13470                    if let GetIfaceStatsResponse::ErrorStatus(_) = self {
13471                        // Do nothing, read the value into the object
13472                    } else {
13473                        // Initialize `self` to the right variant
13474                        *self = GetIfaceStatsResponse::ErrorStatus(fidl::new_empty!(i32, D));
13475                    }
13476                    #[allow(irrefutable_let_patterns)]
13477                    if let GetIfaceStatsResponse::ErrorStatus(ref mut val) = self {
13478                        fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
13479                    } else {
13480                        unreachable!()
13481                    }
13482                }
13483                ordinal => panic!("unexpected ordinal {:?}", ordinal),
13484            }
13485            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
13486                return Err(fidl::Error::InvalidNumBytesInEnvelope);
13487            }
13488            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13489                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13490            }
13491            Ok(())
13492        }
13493    }
13494}
fidl_fuchsia_wlan_mlme__common/fidl_fuchsia_wlan_mlme__common.rs

fidl_fuchsia_wlan_mlme__common/
fidl_fuchsia_wlan_mlme__common.rs
