fidl_fuchsia_wlan_fullmac/
fidl_fuchsia_wlan_fullmac.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::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_wlan_fullmac_common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Default, PartialEq)]
15pub struct WlanFullmacImplInitRequest {
16    /// The WlanFullmacImplifc client end.
17    /// Required.
18    pub ifc: Option<fidl::endpoints::ClientEnd<WlanFullmacImplIfcMarker>>,
19    #[doc(hidden)]
20    pub __source_breaking: fidl::marker::SourceBreaking,
21}
22
23impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
24    for WlanFullmacImplInitRequest
25{
26}
27
28#[derive(Debug, Default, PartialEq)]
29pub struct WlanFullmacImplInitResponse {
30    /// The SME server end channel.
31    /// Required.
32    pub sme_channel: Option<fidl::Channel>,
33    #[doc(hidden)]
34    pub __source_breaking: fidl::marker::SourceBreaking,
35}
36
37impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
38    for WlanFullmacImplInitResponse
39{
40}
41
42#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
43pub struct WlanFullmacImpl_Marker;
44
45impl fidl::endpoints::ProtocolMarker for WlanFullmacImpl_Marker {
46    type Proxy = WlanFullmacImpl_Proxy;
47    type RequestStream = WlanFullmacImpl_RequestStream;
48    #[cfg(target_os = "fuchsia")]
49    type SynchronousProxy = WlanFullmacImpl_SynchronousProxy;
50
51    const DEBUG_NAME: &'static str = "fuchsia.wlan.fullmac.WlanFullmacImpl";
52}
53impl fidl::endpoints::DiscoverableProtocolMarker for WlanFullmacImpl_Marker {}
54pub type WlanFullmacImplInitResult = Result<WlanFullmacImplInitResponse, i32>;
55pub type WlanFullmacImplQueryResult = Result<WlanFullmacImplQueryResponse, i32>;
56pub type WlanFullmacImplQueryMacSublayerSupportResult =
57    Result<fidl_fuchsia_wlan_common::MacSublayerSupport, i32>;
58pub type WlanFullmacImplQuerySecuritySupportResult =
59    Result<fidl_fuchsia_wlan_common::SecuritySupport, i32>;
60pub type WlanFullmacImplQuerySpectrumManagementSupportResult =
61    Result<fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>;
62pub type WlanFullmacImplQueryTelemetrySupportResult =
63    Result<fidl_fuchsia_wlan_stats::TelemetrySupport, i32>;
64pub type WlanFullmacImplGetIfaceCounterStatsResult =
65    Result<fidl_fuchsia_wlan_stats::IfaceCounterStats, i32>;
66pub type WlanFullmacImplGetIfaceHistogramStatsResult =
67    Result<fidl_fuchsia_wlan_stats::IfaceHistogramStats, i32>;
68
69pub trait WlanFullmacImpl_ProxyInterface: Send + Sync {
70    type InitResponseFut: std::future::Future<Output = Result<WlanFullmacImplInitResult, fidl::Error>>
71        + Send;
72    fn r#init(&self, payload: WlanFullmacImplInitRequest) -> Self::InitResponseFut;
73    type QueryResponseFut: std::future::Future<Output = Result<WlanFullmacImplQueryResult, fidl::Error>>
74        + Send;
75    fn r#query(&self) -> Self::QueryResponseFut;
76    type QueryMacSublayerSupportResponseFut: std::future::Future<
77            Output = Result<WlanFullmacImplQueryMacSublayerSupportResult, fidl::Error>,
78        > + Send;
79    fn r#query_mac_sublayer_support(&self) -> Self::QueryMacSublayerSupportResponseFut;
80    type QuerySecuritySupportResponseFut: std::future::Future<Output = Result<WlanFullmacImplQuerySecuritySupportResult, fidl::Error>>
81        + Send;
82    fn r#query_security_support(&self) -> Self::QuerySecuritySupportResponseFut;
83    type QuerySpectrumManagementSupportResponseFut: std::future::Future<
84            Output = Result<WlanFullmacImplQuerySpectrumManagementSupportResult, fidl::Error>,
85        > + Send;
86    fn r#query_spectrum_management_support(
87        &self,
88    ) -> Self::QuerySpectrumManagementSupportResponseFut;
89    type QueryTelemetrySupportResponseFut: std::future::Future<
90            Output = Result<WlanFullmacImplQueryTelemetrySupportResult, fidl::Error>,
91        > + Send;
92    fn r#query_telemetry_support(&self) -> Self::QueryTelemetrySupportResponseFut;
93    type StartScanResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
94    fn r#start_scan(&self, payload: &WlanFullmacImplStartScanRequest)
95        -> Self::StartScanResponseFut;
96    type ConnectResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
97    fn r#connect(&self, payload: &WlanFullmacImplConnectRequest) -> Self::ConnectResponseFut;
98    type ReconnectResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
99    fn r#reconnect(&self, payload: &WlanFullmacImplReconnectRequest) -> Self::ReconnectResponseFut;
100    type RoamResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
101    fn r#roam(&self, payload: &WlanFullmacImplRoamRequest) -> Self::RoamResponseFut;
102    type AuthRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
103    fn r#auth_resp(&self, payload: &WlanFullmacImplAuthRespRequest) -> Self::AuthRespResponseFut;
104    type DeauthResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
105    fn r#deauth(&self, payload: &WlanFullmacImplDeauthRequest) -> Self::DeauthResponseFut;
106    type AssocRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
107    fn r#assoc_resp(&self, payload: &WlanFullmacImplAssocRespRequest)
108        -> Self::AssocRespResponseFut;
109    type DisassocResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
110    fn r#disassoc(&self, payload: &WlanFullmacImplDisassocRequest) -> Self::DisassocResponseFut;
111    type StartBssResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
112    fn r#start_bss(&self, payload: &WlanFullmacImplStartBssRequest) -> Self::StartBssResponseFut;
113    type StopBssResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
114    fn r#stop_bss(&self, payload: &WlanFullmacImplStopBssRequest) -> Self::StopBssResponseFut;
115    type SetKeysResponseFut: std::future::Future<Output = Result<WlanFullmacSetKeysResp, fidl::Error>>
116        + Send;
117    fn r#set_keys(&self, payload: &WlanFullmacImplSetKeysRequest) -> Self::SetKeysResponseFut;
118    type EapolTxResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
119    fn r#eapol_tx(&self, payload: &WlanFullmacImplEapolTxRequest) -> Self::EapolTxResponseFut;
120    type GetIfaceCounterStatsResponseFut: std::future::Future<Output = Result<WlanFullmacImplGetIfaceCounterStatsResult, fidl::Error>>
121        + Send;
122    fn r#get_iface_counter_stats(&self) -> Self::GetIfaceCounterStatsResponseFut;
123    type GetIfaceHistogramStatsResponseFut: std::future::Future<
124            Output = Result<WlanFullmacImplGetIfaceHistogramStatsResult, fidl::Error>,
125        > + Send;
126    fn r#get_iface_histogram_stats(&self) -> Self::GetIfaceHistogramStatsResponseFut;
127    type SaeHandshakeRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
128    fn r#sae_handshake_resp(
129        &self,
130        payload: &WlanFullmacImplSaeHandshakeRespRequest,
131    ) -> Self::SaeHandshakeRespResponseFut;
132    type SaeFrameTxResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
133    fn r#sae_frame_tx(&self, frame: &SaeFrame) -> Self::SaeFrameTxResponseFut;
134    type WmmStatusReqResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
135    fn r#wmm_status_req(&self) -> Self::WmmStatusReqResponseFut;
136    type OnLinkStateChangedResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
137    fn r#on_link_state_changed(
138        &self,
139        payload: &WlanFullmacImplOnLinkStateChangedRequest,
140    ) -> Self::OnLinkStateChangedResponseFut;
141}
142#[derive(Debug)]
143#[cfg(target_os = "fuchsia")]
144pub struct WlanFullmacImpl_SynchronousProxy {
145    client: fidl::client::sync::Client,
146}
147
148#[cfg(target_os = "fuchsia")]
149impl fidl::endpoints::SynchronousProxy for WlanFullmacImpl_SynchronousProxy {
150    type Proxy = WlanFullmacImpl_Proxy;
151    type Protocol = WlanFullmacImpl_Marker;
152
153    fn from_channel(inner: fidl::Channel) -> Self {
154        Self::new(inner)
155    }
156
157    fn into_channel(self) -> fidl::Channel {
158        self.client.into_channel()
159    }
160
161    fn as_channel(&self) -> &fidl::Channel {
162        self.client.as_channel()
163    }
164}
165
166#[cfg(target_os = "fuchsia")]
167impl WlanFullmacImpl_SynchronousProxy {
168    pub fn new(channel: fidl::Channel) -> Self {
169        let protocol_name = <WlanFullmacImpl_Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
170        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
171    }
172
173    pub fn into_channel(self) -> fidl::Channel {
174        self.client.into_channel()
175    }
176
177    /// Waits until an event arrives and returns it. It is safe for other
178    /// threads to make concurrent requests while waiting for an event.
179    pub fn wait_for_event(
180        &self,
181        deadline: zx::MonotonicInstant,
182    ) -> Result<WlanFullmacImpl_Event, fidl::Error> {
183        WlanFullmacImpl_Event::decode(self.client.wait_for_event(deadline)?)
184    }
185
186    /// Initialize the FullMAC driver. This is the first request that the platform will make to the
187    /// FullMAC driver.
188    ///
189    /// On initialization, MLME provides the client end to the WlanFullmacImplIfc protocol. The
190    /// driver must return the SME server end channel, which is used internally by the platform.
191    /// Typically, the SME server end channel is given to the FullMAC driver by
192    /// fuchsia.wlan.phyimpl/WlanPhyImpl.CreateIface.
193    ///
194    /// If `Init` completes successfully, the platform will begin making other WlanFullmacImpl
195    /// requests to the FullMAC driver, and the FullMAC driver is free to make WlanFullmacImplIfc
196    /// requests to the platform. The platform may continue making WlanFullmacImpl requests until
197    /// the WlanFullmacImpl server unbinds.
198    ///
199    /// Common errors include:
200    ///   - `ZX_ERR_ALREADY_BOUND`: `Init` was already called on this FullMAC driver.
201    pub fn r#init(
202        &self,
203        mut payload: WlanFullmacImplInitRequest,
204        ___deadline: zx::MonotonicInstant,
205    ) -> Result<WlanFullmacImplInitResult, fidl::Error> {
206        let _response = self.client.send_query::<
207            WlanFullmacImplInitRequest,
208            fidl::encoding::ResultType<WlanFullmacImplInitResponse, i32>,
209        >(
210            &mut payload,
211            0x593dfb6cb3f0f1aa,
212            fidl::encoding::DynamicFlags::empty(),
213            ___deadline,
214        )?;
215        Ok(_response.map(|x| x))
216    }
217
218    /// Returns high-level information describing the state of the FullMAC driver.
219    /// This is safe to call even before the call to WlanFullmacImpl::Start.
220    pub fn r#query(
221        &self,
222        ___deadline: zx::MonotonicInstant,
223    ) -> Result<WlanFullmacImplQueryResult, fidl::Error> {
224        let _response = self.client.send_query::<
225            fidl::encoding::EmptyPayload,
226            fidl::encoding::ResultType<WlanFullmacImplQueryResponse, i32>,
227        >(
228            (),
229            0x28ac65f9da3941d4,
230            fidl::encoding::DynamicFlags::empty(),
231            ___deadline,
232        )?;
233        Ok(_response.map(|x| x))
234    }
235
236    pub fn r#query_mac_sublayer_support(
237        &self,
238        ___deadline: zx::MonotonicInstant,
239    ) -> Result<WlanFullmacImplQueryMacSublayerSupportResult, fidl::Error> {
240        let _response =
241            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
242                WlanFullmacImplQueryMacSublayerSupportResponse,
243                i32,
244            >>(
245                (),
246                0x2f09187eb87d9bad,
247                fidl::encoding::DynamicFlags::empty(),
248                ___deadline,
249            )?;
250        Ok(_response.map(|x| x.resp))
251    }
252
253    pub fn r#query_security_support(
254        &self,
255        ___deadline: zx::MonotonicInstant,
256    ) -> Result<WlanFullmacImplQuerySecuritySupportResult, fidl::Error> {
257        let _response =
258            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
259                WlanFullmacImplQuerySecuritySupportResponse,
260                i32,
261            >>(
262                (),
263                0x11cf3fa6eeb93f84,
264                fidl::encoding::DynamicFlags::empty(),
265                ___deadline,
266            )?;
267        Ok(_response.map(|x| x.resp))
268    }
269
270    pub fn r#query_spectrum_management_support(
271        &self,
272        ___deadline: zx::MonotonicInstant,
273    ) -> Result<WlanFullmacImplQuerySpectrumManagementSupportResult, fidl::Error> {
274        let _response = self
275            .client
276            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
277                WlanFullmacImplQuerySpectrumManagementSupportResponse,
278                i32,
279            >>(
280                (), 0x22ae7551d855b83a, fidl::encoding::DynamicFlags::empty(), ___deadline
281            )?;
282        Ok(_response.map(|x| x.resp))
283    }
284
285    pub fn r#query_telemetry_support(
286        &self,
287        ___deadline: zx::MonotonicInstant,
288    ) -> Result<WlanFullmacImplQueryTelemetrySupportResult, fidl::Error> {
289        let _response =
290            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
291                WlanFullmacImplQueryTelemetrySupportResponse,
292                i32,
293            >>(
294                (),
295                0x4561479ca560827f,
296                fidl::encoding::DynamicFlags::empty(),
297                ___deadline,
298            )?;
299        Ok(_response.map(|x| x.resp))
300    }
301
302    pub fn r#start_scan(
303        &self,
304        mut payload: &WlanFullmacImplStartScanRequest,
305        ___deadline: zx::MonotonicInstant,
306    ) -> Result<(), fidl::Error> {
307        let _response = self
308            .client
309            .send_query::<WlanFullmacImplStartScanRequest, fidl::encoding::EmptyPayload>(
310                payload,
311                0x26c17bf595aa161c,
312                fidl::encoding::DynamicFlags::empty(),
313                ___deadline,
314            )?;
315        Ok(_response)
316    }
317
318    pub fn r#connect(
319        &self,
320        mut payload: &WlanFullmacImplConnectRequest,
321        ___deadline: zx::MonotonicInstant,
322    ) -> Result<(), fidl::Error> {
323        let _response =
324            self.client.send_query::<WlanFullmacImplConnectRequest, fidl::encoding::EmptyPayload>(
325                payload,
326                0x19eb0322efb07a76,
327                fidl::encoding::DynamicFlags::empty(),
328                ___deadline,
329            )?;
330        Ok(_response)
331    }
332
333    pub fn r#reconnect(
334        &self,
335        mut payload: &WlanFullmacImplReconnectRequest,
336        ___deadline: zx::MonotonicInstant,
337    ) -> Result<(), fidl::Error> {
338        let _response = self
339            .client
340            .send_query::<WlanFullmacImplReconnectRequest, fidl::encoding::EmptyPayload>(
341                payload,
342                0x474084c4ef19ee71,
343                fidl::encoding::DynamicFlags::empty(),
344                ___deadline,
345            )?;
346        Ok(_response)
347    }
348
349    /// Initiate a roam attempt, which moves association to a different BSS within the ESS.
350    pub fn r#roam(
351        &self,
352        mut payload: &WlanFullmacImplRoamRequest,
353        ___deadline: zx::MonotonicInstant,
354    ) -> Result<(), fidl::Error> {
355        let _response =
356            self.client.send_query::<WlanFullmacImplRoamRequest, fidl::encoding::EmptyPayload>(
357                payload,
358                0x1e35dcc98b124b64,
359                fidl::encoding::DynamicFlags::empty(),
360                ___deadline,
361            )?;
362        Ok(_response)
363    }
364
365    pub fn r#auth_resp(
366        &self,
367        mut payload: &WlanFullmacImplAuthRespRequest,
368        ___deadline: zx::MonotonicInstant,
369    ) -> Result<(), fidl::Error> {
370        let _response = self
371            .client
372            .send_query::<WlanFullmacImplAuthRespRequest, fidl::encoding::EmptyPayload>(
373                payload,
374                0x5f7ea24b44a4aaeb,
375                fidl::encoding::DynamicFlags::empty(),
376                ___deadline,
377            )?;
378        Ok(_response)
379    }
380
381    pub fn r#deauth(
382        &self,
383        mut payload: &WlanFullmacImplDeauthRequest,
384        ___deadline: zx::MonotonicInstant,
385    ) -> Result<(), fidl::Error> {
386        let _response =
387            self.client.send_query::<WlanFullmacImplDeauthRequest, fidl::encoding::EmptyPayload>(
388                payload,
389                0x112786eccbf12f37,
390                fidl::encoding::DynamicFlags::empty(),
391                ___deadline,
392            )?;
393        Ok(_response)
394    }
395
396    pub fn r#assoc_resp(
397        &self,
398        mut payload: &WlanFullmacImplAssocRespRequest,
399        ___deadline: zx::MonotonicInstant,
400    ) -> Result<(), fidl::Error> {
401        let _response = self
402            .client
403            .send_query::<WlanFullmacImplAssocRespRequest, fidl::encoding::EmptyPayload>(
404                payload,
405                0x5022ce6b8eefec2f,
406                fidl::encoding::DynamicFlags::empty(),
407                ___deadline,
408            )?;
409        Ok(_response)
410    }
411
412    pub fn r#disassoc(
413        &self,
414        mut payload: &WlanFullmacImplDisassocRequest,
415        ___deadline: zx::MonotonicInstant,
416    ) -> Result<(), fidl::Error> {
417        let _response = self
418            .client
419            .send_query::<WlanFullmacImplDisassocRequest, fidl::encoding::EmptyPayload>(
420                payload,
421                0x9c0fc4e8de53e01,
422                fidl::encoding::DynamicFlags::empty(),
423                ___deadline,
424            )?;
425        Ok(_response)
426    }
427
428    pub fn r#start_bss(
429        &self,
430        mut payload: &WlanFullmacImplStartBssRequest,
431        ___deadline: zx::MonotonicInstant,
432    ) -> Result<(), fidl::Error> {
433        let _response = self
434            .client
435            .send_query::<WlanFullmacImplStartBssRequest, fidl::encoding::EmptyPayload>(
436                payload,
437                0x6922644d6b1d341d,
438                fidl::encoding::DynamicFlags::empty(),
439                ___deadline,
440            )?;
441        Ok(_response)
442    }
443
444    pub fn r#stop_bss(
445        &self,
446        mut payload: &WlanFullmacImplStopBssRequest,
447        ___deadline: zx::MonotonicInstant,
448    ) -> Result<(), fidl::Error> {
449        let _response =
450            self.client.send_query::<WlanFullmacImplStopBssRequest, fidl::encoding::EmptyPayload>(
451                payload,
452                0x5aeb9b72e7575268,
453                fidl::encoding::DynamicFlags::empty(),
454                ___deadline,
455            )?;
456        Ok(_response)
457    }
458
459    /// Sets security keys for a connection. This is typically called after a successful key
460    /// exchange.
461    ///
462    /// Note that the platform assumes that the driver will automatically delete keys on a
463    /// disconnect or key rotation.
464    pub fn r#set_keys(
465        &self,
466        mut payload: &WlanFullmacImplSetKeysRequest,
467        ___deadline: zx::MonotonicInstant,
468    ) -> Result<WlanFullmacSetKeysResp, fidl::Error> {
469        let _response = self
470            .client
471            .send_query::<WlanFullmacImplSetKeysRequest, WlanFullmacImplSetKeysResponse>(
472                payload,
473                0x20f46b1e039f0985,
474                fidl::encoding::DynamicFlags::empty(),
475                ___deadline,
476            )?;
477        Ok(_response.resp)
478    }
479
480    pub fn r#eapol_tx(
481        &self,
482        mut payload: &WlanFullmacImplEapolTxRequest,
483        ___deadline: zx::MonotonicInstant,
484    ) -> Result<(), fidl::Error> {
485        let _response =
486            self.client.send_query::<WlanFullmacImplEapolTxRequest, fidl::encoding::EmptyPayload>(
487                payload,
488                0x529a2d90fd4c8177,
489                fidl::encoding::DynamicFlags::empty(),
490                ___deadline,
491            )?;
492        Ok(_response)
493    }
494
495    pub fn r#get_iface_counter_stats(
496        &self,
497        ___deadline: zx::MonotonicInstant,
498    ) -> Result<WlanFullmacImplGetIfaceCounterStatsResult, fidl::Error> {
499        let _response =
500            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
501                WlanFullmacImplGetIfaceCounterStatsResponse,
502                i32,
503            >>(
504                (),
505                0x6b640d6c69c99225,
506                fidl::encoding::DynamicFlags::empty(),
507                ___deadline,
508            )?;
509        Ok(_response.map(|x| x.stats))
510    }
511
512    pub fn r#get_iface_histogram_stats(
513        &self,
514        ___deadline: zx::MonotonicInstant,
515    ) -> Result<WlanFullmacImplGetIfaceHistogramStatsResult, fidl::Error> {
516        let _response =
517            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
518                WlanFullmacImplGetIfaceHistogramStatsResponse,
519                i32,
520            >>(
521                (),
522                0x503d586f30ccf2cd,
523                fidl::encoding::DynamicFlags::empty(),
524                ___deadline,
525            )?;
526        Ok(_response.map(|x| x.stats))
527    }
528
529    /// Informs the driver of the result of an SAE handshake.
530    pub fn r#sae_handshake_resp(
531        &self,
532        mut payload: &WlanFullmacImplSaeHandshakeRespRequest,
533        ___deadline: zx::MonotonicInstant,
534    ) -> Result<(), fidl::Error> {
535        let _response = self
536            .client
537            .send_query::<WlanFullmacImplSaeHandshakeRespRequest, fidl::encoding::EmptyPayload>(
538                payload,
539                0x72cd3a31ae5a54f6,
540                fidl::encoding::DynamicFlags::empty(),
541                ___deadline,
542            )?;
543        Ok(_response)
544    }
545
546    /// Transmit an SAE authentication frame.
547    pub fn r#sae_frame_tx(
548        &self,
549        mut frame: &SaeFrame,
550        ___deadline: zx::MonotonicInstant,
551    ) -> Result<(), fidl::Error> {
552        let _response = self
553            .client
554            .send_query::<WlanFullmacImplSaeFrameTxRequest, fidl::encoding::EmptyPayload>(
555                (frame,),
556                0x4715ad5dc5a6340f,
557                fidl::encoding::DynamicFlags::empty(),
558                ___deadline,
559            )?;
560        Ok(_response)
561    }
562
563    pub fn r#wmm_status_req(&self, ___deadline: zx::MonotonicInstant) -> Result<(), fidl::Error> {
564        let _response =
565            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::EmptyPayload>(
566                (),
567                0x635ecef3beb7a059,
568                fidl::encoding::DynamicFlags::empty(),
569                ___deadline,
570            )?;
571        Ok(_response)
572    }
573
574    pub fn r#on_link_state_changed(
575        &self,
576        mut payload: &WlanFullmacImplOnLinkStateChangedRequest,
577        ___deadline: zx::MonotonicInstant,
578    ) -> Result<(), fidl::Error> {
579        let _response = self
580            .client
581            .send_query::<WlanFullmacImplOnLinkStateChangedRequest, fidl::encoding::EmptyPayload>(
582                payload,
583                0x4d896e5b68e488d7,
584                fidl::encoding::DynamicFlags::empty(),
585                ___deadline,
586            )?;
587        Ok(_response)
588    }
589}
590
591#[derive(Debug, Clone)]
592pub struct WlanFullmacImpl_Proxy {
593    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
594}
595
596impl fidl::endpoints::Proxy for WlanFullmacImpl_Proxy {
597    type Protocol = WlanFullmacImpl_Marker;
598
599    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
600        Self::new(inner)
601    }
602
603    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
604        self.client.into_channel().map_err(|client| Self { client })
605    }
606
607    fn as_channel(&self) -> &::fidl::AsyncChannel {
608        self.client.as_channel()
609    }
610}
611
612impl WlanFullmacImpl_Proxy {
613    /// Create a new Proxy for fuchsia.wlan.fullmac/WlanFullmacImpl.
614    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
615        let protocol_name = <WlanFullmacImpl_Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
616        Self { client: fidl::client::Client::new(channel, protocol_name) }
617    }
618
619    /// Get a Stream of events from the remote end of the protocol.
620    ///
621    /// # Panics
622    ///
623    /// Panics if the event stream was already taken.
624    pub fn take_event_stream(&self) -> WlanFullmacImpl_EventStream {
625        WlanFullmacImpl_EventStream { event_receiver: self.client.take_event_receiver() }
626    }
627
628    /// Initialize the FullMAC driver. This is the first request that the platform will make to the
629    /// FullMAC driver.
630    ///
631    /// On initialization, MLME provides the client end to the WlanFullmacImplIfc protocol. The
632    /// driver must return the SME server end channel, which is used internally by the platform.
633    /// Typically, the SME server end channel is given to the FullMAC driver by
634    /// fuchsia.wlan.phyimpl/WlanPhyImpl.CreateIface.
635    ///
636    /// If `Init` completes successfully, the platform will begin making other WlanFullmacImpl
637    /// requests to the FullMAC driver, and the FullMAC driver is free to make WlanFullmacImplIfc
638    /// requests to the platform. The platform may continue making WlanFullmacImpl requests until
639    /// the WlanFullmacImpl server unbinds.
640    ///
641    /// Common errors include:
642    ///   - `ZX_ERR_ALREADY_BOUND`: `Init` was already called on this FullMAC driver.
643    pub fn r#init(
644        &self,
645        mut payload: WlanFullmacImplInitRequest,
646    ) -> fidl::client::QueryResponseFut<
647        WlanFullmacImplInitResult,
648        fidl::encoding::DefaultFuchsiaResourceDialect,
649    > {
650        WlanFullmacImpl_ProxyInterface::r#init(self, payload)
651    }
652
653    /// Returns high-level information describing the state of the FullMAC driver.
654    /// This is safe to call even before the call to WlanFullmacImpl::Start.
655    pub fn r#query(
656        &self,
657    ) -> fidl::client::QueryResponseFut<
658        WlanFullmacImplQueryResult,
659        fidl::encoding::DefaultFuchsiaResourceDialect,
660    > {
661        WlanFullmacImpl_ProxyInterface::r#query(self)
662    }
663
664    pub fn r#query_mac_sublayer_support(
665        &self,
666    ) -> fidl::client::QueryResponseFut<
667        WlanFullmacImplQueryMacSublayerSupportResult,
668        fidl::encoding::DefaultFuchsiaResourceDialect,
669    > {
670        WlanFullmacImpl_ProxyInterface::r#query_mac_sublayer_support(self)
671    }
672
673    pub fn r#query_security_support(
674        &self,
675    ) -> fidl::client::QueryResponseFut<
676        WlanFullmacImplQuerySecuritySupportResult,
677        fidl::encoding::DefaultFuchsiaResourceDialect,
678    > {
679        WlanFullmacImpl_ProxyInterface::r#query_security_support(self)
680    }
681
682    pub fn r#query_spectrum_management_support(
683        &self,
684    ) -> fidl::client::QueryResponseFut<
685        WlanFullmacImplQuerySpectrumManagementSupportResult,
686        fidl::encoding::DefaultFuchsiaResourceDialect,
687    > {
688        WlanFullmacImpl_ProxyInterface::r#query_spectrum_management_support(self)
689    }
690
691    pub fn r#query_telemetry_support(
692        &self,
693    ) -> fidl::client::QueryResponseFut<
694        WlanFullmacImplQueryTelemetrySupportResult,
695        fidl::encoding::DefaultFuchsiaResourceDialect,
696    > {
697        WlanFullmacImpl_ProxyInterface::r#query_telemetry_support(self)
698    }
699
700    pub fn r#start_scan(
701        &self,
702        mut payload: &WlanFullmacImplStartScanRequest,
703    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
704        WlanFullmacImpl_ProxyInterface::r#start_scan(self, payload)
705    }
706
707    pub fn r#connect(
708        &self,
709        mut payload: &WlanFullmacImplConnectRequest,
710    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
711        WlanFullmacImpl_ProxyInterface::r#connect(self, payload)
712    }
713
714    pub fn r#reconnect(
715        &self,
716        mut payload: &WlanFullmacImplReconnectRequest,
717    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
718        WlanFullmacImpl_ProxyInterface::r#reconnect(self, payload)
719    }
720
721    /// Initiate a roam attempt, which moves association to a different BSS within the ESS.
722    pub fn r#roam(
723        &self,
724        mut payload: &WlanFullmacImplRoamRequest,
725    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
726        WlanFullmacImpl_ProxyInterface::r#roam(self, payload)
727    }
728
729    pub fn r#auth_resp(
730        &self,
731        mut payload: &WlanFullmacImplAuthRespRequest,
732    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
733        WlanFullmacImpl_ProxyInterface::r#auth_resp(self, payload)
734    }
735
736    pub fn r#deauth(
737        &self,
738        mut payload: &WlanFullmacImplDeauthRequest,
739    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
740        WlanFullmacImpl_ProxyInterface::r#deauth(self, payload)
741    }
742
743    pub fn r#assoc_resp(
744        &self,
745        mut payload: &WlanFullmacImplAssocRespRequest,
746    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
747        WlanFullmacImpl_ProxyInterface::r#assoc_resp(self, payload)
748    }
749
750    pub fn r#disassoc(
751        &self,
752        mut payload: &WlanFullmacImplDisassocRequest,
753    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
754        WlanFullmacImpl_ProxyInterface::r#disassoc(self, payload)
755    }
756
757    pub fn r#start_bss(
758        &self,
759        mut payload: &WlanFullmacImplStartBssRequest,
760    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
761        WlanFullmacImpl_ProxyInterface::r#start_bss(self, payload)
762    }
763
764    pub fn r#stop_bss(
765        &self,
766        mut payload: &WlanFullmacImplStopBssRequest,
767    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
768        WlanFullmacImpl_ProxyInterface::r#stop_bss(self, payload)
769    }
770
771    /// Sets security keys for a connection. This is typically called after a successful key
772    /// exchange.
773    ///
774    /// Note that the platform assumes that the driver will automatically delete keys on a
775    /// disconnect or key rotation.
776    pub fn r#set_keys(
777        &self,
778        mut payload: &WlanFullmacImplSetKeysRequest,
779    ) -> fidl::client::QueryResponseFut<
780        WlanFullmacSetKeysResp,
781        fidl::encoding::DefaultFuchsiaResourceDialect,
782    > {
783        WlanFullmacImpl_ProxyInterface::r#set_keys(self, payload)
784    }
785
786    pub fn r#eapol_tx(
787        &self,
788        mut payload: &WlanFullmacImplEapolTxRequest,
789    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
790        WlanFullmacImpl_ProxyInterface::r#eapol_tx(self, payload)
791    }
792
793    pub fn r#get_iface_counter_stats(
794        &self,
795    ) -> fidl::client::QueryResponseFut<
796        WlanFullmacImplGetIfaceCounterStatsResult,
797        fidl::encoding::DefaultFuchsiaResourceDialect,
798    > {
799        WlanFullmacImpl_ProxyInterface::r#get_iface_counter_stats(self)
800    }
801
802    pub fn r#get_iface_histogram_stats(
803        &self,
804    ) -> fidl::client::QueryResponseFut<
805        WlanFullmacImplGetIfaceHistogramStatsResult,
806        fidl::encoding::DefaultFuchsiaResourceDialect,
807    > {
808        WlanFullmacImpl_ProxyInterface::r#get_iface_histogram_stats(self)
809    }
810
811    /// Informs the driver of the result of an SAE handshake.
812    pub fn r#sae_handshake_resp(
813        &self,
814        mut payload: &WlanFullmacImplSaeHandshakeRespRequest,
815    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
816        WlanFullmacImpl_ProxyInterface::r#sae_handshake_resp(self, payload)
817    }
818
819    /// Transmit an SAE authentication frame.
820    pub fn r#sae_frame_tx(
821        &self,
822        mut frame: &SaeFrame,
823    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
824        WlanFullmacImpl_ProxyInterface::r#sae_frame_tx(self, frame)
825    }
826
827    pub fn r#wmm_status_req(
828        &self,
829    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
830        WlanFullmacImpl_ProxyInterface::r#wmm_status_req(self)
831    }
832
833    pub fn r#on_link_state_changed(
834        &self,
835        mut payload: &WlanFullmacImplOnLinkStateChangedRequest,
836    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
837        WlanFullmacImpl_ProxyInterface::r#on_link_state_changed(self, payload)
838    }
839}
840
841impl WlanFullmacImpl_ProxyInterface for WlanFullmacImpl_Proxy {
842    type InitResponseFut = fidl::client::QueryResponseFut<
843        WlanFullmacImplInitResult,
844        fidl::encoding::DefaultFuchsiaResourceDialect,
845    >;
846    fn r#init(&self, mut payload: WlanFullmacImplInitRequest) -> Self::InitResponseFut {
847        fn _decode(
848            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
849        ) -> Result<WlanFullmacImplInitResult, fidl::Error> {
850            let _response = fidl::client::decode_transaction_body::<
851                fidl::encoding::ResultType<WlanFullmacImplInitResponse, i32>,
852                fidl::encoding::DefaultFuchsiaResourceDialect,
853                0x593dfb6cb3f0f1aa,
854            >(_buf?)?;
855            Ok(_response.map(|x| x))
856        }
857        self.client.send_query_and_decode::<WlanFullmacImplInitRequest, WlanFullmacImplInitResult>(
858            &mut payload,
859            0x593dfb6cb3f0f1aa,
860            fidl::encoding::DynamicFlags::empty(),
861            _decode,
862        )
863    }
864
865    type QueryResponseFut = fidl::client::QueryResponseFut<
866        WlanFullmacImplQueryResult,
867        fidl::encoding::DefaultFuchsiaResourceDialect,
868    >;
869    fn r#query(&self) -> Self::QueryResponseFut {
870        fn _decode(
871            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
872        ) -> Result<WlanFullmacImplQueryResult, fidl::Error> {
873            let _response = fidl::client::decode_transaction_body::<
874                fidl::encoding::ResultType<WlanFullmacImplQueryResponse, i32>,
875                fidl::encoding::DefaultFuchsiaResourceDialect,
876                0x28ac65f9da3941d4,
877            >(_buf?)?;
878            Ok(_response.map(|x| x))
879        }
880        self.client
881            .send_query_and_decode::<fidl::encoding::EmptyPayload, WlanFullmacImplQueryResult>(
882                (),
883                0x28ac65f9da3941d4,
884                fidl::encoding::DynamicFlags::empty(),
885                _decode,
886            )
887    }
888
889    type QueryMacSublayerSupportResponseFut = fidl::client::QueryResponseFut<
890        WlanFullmacImplQueryMacSublayerSupportResult,
891        fidl::encoding::DefaultFuchsiaResourceDialect,
892    >;
893    fn r#query_mac_sublayer_support(&self) -> Self::QueryMacSublayerSupportResponseFut {
894        fn _decode(
895            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
896        ) -> Result<WlanFullmacImplQueryMacSublayerSupportResult, fidl::Error> {
897            let _response = fidl::client::decode_transaction_body::<
898                fidl::encoding::ResultType<WlanFullmacImplQueryMacSublayerSupportResponse, i32>,
899                fidl::encoding::DefaultFuchsiaResourceDialect,
900                0x2f09187eb87d9bad,
901            >(_buf?)?;
902            Ok(_response.map(|x| x.resp))
903        }
904        self.client.send_query_and_decode::<
905            fidl::encoding::EmptyPayload,
906            WlanFullmacImplQueryMacSublayerSupportResult,
907        >(
908            (),
909            0x2f09187eb87d9bad,
910            fidl::encoding::DynamicFlags::empty(),
911            _decode,
912        )
913    }
914
915    type QuerySecuritySupportResponseFut = fidl::client::QueryResponseFut<
916        WlanFullmacImplQuerySecuritySupportResult,
917        fidl::encoding::DefaultFuchsiaResourceDialect,
918    >;
919    fn r#query_security_support(&self) -> Self::QuerySecuritySupportResponseFut {
920        fn _decode(
921            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
922        ) -> Result<WlanFullmacImplQuerySecuritySupportResult, fidl::Error> {
923            let _response = fidl::client::decode_transaction_body::<
924                fidl::encoding::ResultType<WlanFullmacImplQuerySecuritySupportResponse, i32>,
925                fidl::encoding::DefaultFuchsiaResourceDialect,
926                0x11cf3fa6eeb93f84,
927            >(_buf?)?;
928            Ok(_response.map(|x| x.resp))
929        }
930        self.client.send_query_and_decode::<
931            fidl::encoding::EmptyPayload,
932            WlanFullmacImplQuerySecuritySupportResult,
933        >(
934            (),
935            0x11cf3fa6eeb93f84,
936            fidl::encoding::DynamicFlags::empty(),
937            _decode,
938        )
939    }
940
941    type QuerySpectrumManagementSupportResponseFut = fidl::client::QueryResponseFut<
942        WlanFullmacImplQuerySpectrumManagementSupportResult,
943        fidl::encoding::DefaultFuchsiaResourceDialect,
944    >;
945    fn r#query_spectrum_management_support(
946        &self,
947    ) -> Self::QuerySpectrumManagementSupportResponseFut {
948        fn _decode(
949            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
950        ) -> Result<WlanFullmacImplQuerySpectrumManagementSupportResult, fidl::Error> {
951            let _response = fidl::client::decode_transaction_body::<
952                fidl::encoding::ResultType<
953                    WlanFullmacImplQuerySpectrumManagementSupportResponse,
954                    i32,
955                >,
956                fidl::encoding::DefaultFuchsiaResourceDialect,
957                0x22ae7551d855b83a,
958            >(_buf?)?;
959            Ok(_response.map(|x| x.resp))
960        }
961        self.client.send_query_and_decode::<
962            fidl::encoding::EmptyPayload,
963            WlanFullmacImplQuerySpectrumManagementSupportResult,
964        >(
965            (),
966            0x22ae7551d855b83a,
967            fidl::encoding::DynamicFlags::empty(),
968            _decode,
969        )
970    }
971
972    type QueryTelemetrySupportResponseFut = fidl::client::QueryResponseFut<
973        WlanFullmacImplQueryTelemetrySupportResult,
974        fidl::encoding::DefaultFuchsiaResourceDialect,
975    >;
976    fn r#query_telemetry_support(&self) -> Self::QueryTelemetrySupportResponseFut {
977        fn _decode(
978            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
979        ) -> Result<WlanFullmacImplQueryTelemetrySupportResult, fidl::Error> {
980            let _response = fidl::client::decode_transaction_body::<
981                fidl::encoding::ResultType<WlanFullmacImplQueryTelemetrySupportResponse, i32>,
982                fidl::encoding::DefaultFuchsiaResourceDialect,
983                0x4561479ca560827f,
984            >(_buf?)?;
985            Ok(_response.map(|x| x.resp))
986        }
987        self.client.send_query_and_decode::<
988            fidl::encoding::EmptyPayload,
989            WlanFullmacImplQueryTelemetrySupportResult,
990        >(
991            (),
992            0x4561479ca560827f,
993            fidl::encoding::DynamicFlags::empty(),
994            _decode,
995        )
996    }
997
998    type StartScanResponseFut =
999        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1000    fn r#start_scan(
1001        &self,
1002        mut payload: &WlanFullmacImplStartScanRequest,
1003    ) -> Self::StartScanResponseFut {
1004        fn _decode(
1005            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1006        ) -> Result<(), fidl::Error> {
1007            let _response = fidl::client::decode_transaction_body::<
1008                fidl::encoding::EmptyPayload,
1009                fidl::encoding::DefaultFuchsiaResourceDialect,
1010                0x26c17bf595aa161c,
1011            >(_buf?)?;
1012            Ok(_response)
1013        }
1014        self.client.send_query_and_decode::<WlanFullmacImplStartScanRequest, ()>(
1015            payload,
1016            0x26c17bf595aa161c,
1017            fidl::encoding::DynamicFlags::empty(),
1018            _decode,
1019        )
1020    }
1021
1022    type ConnectResponseFut =
1023        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1024    fn r#connect(&self, mut payload: &WlanFullmacImplConnectRequest) -> Self::ConnectResponseFut {
1025        fn _decode(
1026            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1027        ) -> Result<(), fidl::Error> {
1028            let _response = fidl::client::decode_transaction_body::<
1029                fidl::encoding::EmptyPayload,
1030                fidl::encoding::DefaultFuchsiaResourceDialect,
1031                0x19eb0322efb07a76,
1032            >(_buf?)?;
1033            Ok(_response)
1034        }
1035        self.client.send_query_and_decode::<WlanFullmacImplConnectRequest, ()>(
1036            payload,
1037            0x19eb0322efb07a76,
1038            fidl::encoding::DynamicFlags::empty(),
1039            _decode,
1040        )
1041    }
1042
1043    type ReconnectResponseFut =
1044        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1045    fn r#reconnect(
1046        &self,
1047        mut payload: &WlanFullmacImplReconnectRequest,
1048    ) -> Self::ReconnectResponseFut {
1049        fn _decode(
1050            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1051        ) -> Result<(), fidl::Error> {
1052            let _response = fidl::client::decode_transaction_body::<
1053                fidl::encoding::EmptyPayload,
1054                fidl::encoding::DefaultFuchsiaResourceDialect,
1055                0x474084c4ef19ee71,
1056            >(_buf?)?;
1057            Ok(_response)
1058        }
1059        self.client.send_query_and_decode::<WlanFullmacImplReconnectRequest, ()>(
1060            payload,
1061            0x474084c4ef19ee71,
1062            fidl::encoding::DynamicFlags::empty(),
1063            _decode,
1064        )
1065    }
1066
1067    type RoamResponseFut =
1068        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1069    fn r#roam(&self, mut payload: &WlanFullmacImplRoamRequest) -> Self::RoamResponseFut {
1070        fn _decode(
1071            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1072        ) -> Result<(), fidl::Error> {
1073            let _response = fidl::client::decode_transaction_body::<
1074                fidl::encoding::EmptyPayload,
1075                fidl::encoding::DefaultFuchsiaResourceDialect,
1076                0x1e35dcc98b124b64,
1077            >(_buf?)?;
1078            Ok(_response)
1079        }
1080        self.client.send_query_and_decode::<WlanFullmacImplRoamRequest, ()>(
1081            payload,
1082            0x1e35dcc98b124b64,
1083            fidl::encoding::DynamicFlags::empty(),
1084            _decode,
1085        )
1086    }
1087
1088    type AuthRespResponseFut =
1089        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1090    fn r#auth_resp(
1091        &self,
1092        mut payload: &WlanFullmacImplAuthRespRequest,
1093    ) -> Self::AuthRespResponseFut {
1094        fn _decode(
1095            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1096        ) -> Result<(), fidl::Error> {
1097            let _response = fidl::client::decode_transaction_body::<
1098                fidl::encoding::EmptyPayload,
1099                fidl::encoding::DefaultFuchsiaResourceDialect,
1100                0x5f7ea24b44a4aaeb,
1101            >(_buf?)?;
1102            Ok(_response)
1103        }
1104        self.client.send_query_and_decode::<WlanFullmacImplAuthRespRequest, ()>(
1105            payload,
1106            0x5f7ea24b44a4aaeb,
1107            fidl::encoding::DynamicFlags::empty(),
1108            _decode,
1109        )
1110    }
1111
1112    type DeauthResponseFut =
1113        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1114    fn r#deauth(&self, mut payload: &WlanFullmacImplDeauthRequest) -> Self::DeauthResponseFut {
1115        fn _decode(
1116            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1117        ) -> Result<(), fidl::Error> {
1118            let _response = fidl::client::decode_transaction_body::<
1119                fidl::encoding::EmptyPayload,
1120                fidl::encoding::DefaultFuchsiaResourceDialect,
1121                0x112786eccbf12f37,
1122            >(_buf?)?;
1123            Ok(_response)
1124        }
1125        self.client.send_query_and_decode::<WlanFullmacImplDeauthRequest, ()>(
1126            payload,
1127            0x112786eccbf12f37,
1128            fidl::encoding::DynamicFlags::empty(),
1129            _decode,
1130        )
1131    }
1132
1133    type AssocRespResponseFut =
1134        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1135    fn r#assoc_resp(
1136        &self,
1137        mut payload: &WlanFullmacImplAssocRespRequest,
1138    ) -> Self::AssocRespResponseFut {
1139        fn _decode(
1140            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1141        ) -> Result<(), fidl::Error> {
1142            let _response = fidl::client::decode_transaction_body::<
1143                fidl::encoding::EmptyPayload,
1144                fidl::encoding::DefaultFuchsiaResourceDialect,
1145                0x5022ce6b8eefec2f,
1146            >(_buf?)?;
1147            Ok(_response)
1148        }
1149        self.client.send_query_and_decode::<WlanFullmacImplAssocRespRequest, ()>(
1150            payload,
1151            0x5022ce6b8eefec2f,
1152            fidl::encoding::DynamicFlags::empty(),
1153            _decode,
1154        )
1155    }
1156
1157    type DisassocResponseFut =
1158        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1159    fn r#disassoc(
1160        &self,
1161        mut payload: &WlanFullmacImplDisassocRequest,
1162    ) -> Self::DisassocResponseFut {
1163        fn _decode(
1164            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1165        ) -> Result<(), fidl::Error> {
1166            let _response = fidl::client::decode_transaction_body::<
1167                fidl::encoding::EmptyPayload,
1168                fidl::encoding::DefaultFuchsiaResourceDialect,
1169                0x9c0fc4e8de53e01,
1170            >(_buf?)?;
1171            Ok(_response)
1172        }
1173        self.client.send_query_and_decode::<WlanFullmacImplDisassocRequest, ()>(
1174            payload,
1175            0x9c0fc4e8de53e01,
1176            fidl::encoding::DynamicFlags::empty(),
1177            _decode,
1178        )
1179    }
1180
1181    type StartBssResponseFut =
1182        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1183    fn r#start_bss(
1184        &self,
1185        mut payload: &WlanFullmacImplStartBssRequest,
1186    ) -> Self::StartBssResponseFut {
1187        fn _decode(
1188            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1189        ) -> Result<(), fidl::Error> {
1190            let _response = fidl::client::decode_transaction_body::<
1191                fidl::encoding::EmptyPayload,
1192                fidl::encoding::DefaultFuchsiaResourceDialect,
1193                0x6922644d6b1d341d,
1194            >(_buf?)?;
1195            Ok(_response)
1196        }
1197        self.client.send_query_and_decode::<WlanFullmacImplStartBssRequest, ()>(
1198            payload,
1199            0x6922644d6b1d341d,
1200            fidl::encoding::DynamicFlags::empty(),
1201            _decode,
1202        )
1203    }
1204
1205    type StopBssResponseFut =
1206        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1207    fn r#stop_bss(&self, mut payload: &WlanFullmacImplStopBssRequest) -> Self::StopBssResponseFut {
1208        fn _decode(
1209            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1210        ) -> Result<(), fidl::Error> {
1211            let _response = fidl::client::decode_transaction_body::<
1212                fidl::encoding::EmptyPayload,
1213                fidl::encoding::DefaultFuchsiaResourceDialect,
1214                0x5aeb9b72e7575268,
1215            >(_buf?)?;
1216            Ok(_response)
1217        }
1218        self.client.send_query_and_decode::<WlanFullmacImplStopBssRequest, ()>(
1219            payload,
1220            0x5aeb9b72e7575268,
1221            fidl::encoding::DynamicFlags::empty(),
1222            _decode,
1223        )
1224    }
1225
1226    type SetKeysResponseFut = fidl::client::QueryResponseFut<
1227        WlanFullmacSetKeysResp,
1228        fidl::encoding::DefaultFuchsiaResourceDialect,
1229    >;
1230    fn r#set_keys(&self, mut payload: &WlanFullmacImplSetKeysRequest) -> Self::SetKeysResponseFut {
1231        fn _decode(
1232            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1233        ) -> Result<WlanFullmacSetKeysResp, fidl::Error> {
1234            let _response = fidl::client::decode_transaction_body::<
1235                WlanFullmacImplSetKeysResponse,
1236                fidl::encoding::DefaultFuchsiaResourceDialect,
1237                0x20f46b1e039f0985,
1238            >(_buf?)?;
1239            Ok(_response.resp)
1240        }
1241        self.client.send_query_and_decode::<WlanFullmacImplSetKeysRequest, WlanFullmacSetKeysResp>(
1242            payload,
1243            0x20f46b1e039f0985,
1244            fidl::encoding::DynamicFlags::empty(),
1245            _decode,
1246        )
1247    }
1248
1249    type EapolTxResponseFut =
1250        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1251    fn r#eapol_tx(&self, mut payload: &WlanFullmacImplEapolTxRequest) -> Self::EapolTxResponseFut {
1252        fn _decode(
1253            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1254        ) -> Result<(), fidl::Error> {
1255            let _response = fidl::client::decode_transaction_body::<
1256                fidl::encoding::EmptyPayload,
1257                fidl::encoding::DefaultFuchsiaResourceDialect,
1258                0x529a2d90fd4c8177,
1259            >(_buf?)?;
1260            Ok(_response)
1261        }
1262        self.client.send_query_and_decode::<WlanFullmacImplEapolTxRequest, ()>(
1263            payload,
1264            0x529a2d90fd4c8177,
1265            fidl::encoding::DynamicFlags::empty(),
1266            _decode,
1267        )
1268    }
1269
1270    type GetIfaceCounterStatsResponseFut = fidl::client::QueryResponseFut<
1271        WlanFullmacImplGetIfaceCounterStatsResult,
1272        fidl::encoding::DefaultFuchsiaResourceDialect,
1273    >;
1274    fn r#get_iface_counter_stats(&self) -> Self::GetIfaceCounterStatsResponseFut {
1275        fn _decode(
1276            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1277        ) -> Result<WlanFullmacImplGetIfaceCounterStatsResult, fidl::Error> {
1278            let _response = fidl::client::decode_transaction_body::<
1279                fidl::encoding::ResultType<WlanFullmacImplGetIfaceCounterStatsResponse, i32>,
1280                fidl::encoding::DefaultFuchsiaResourceDialect,
1281                0x6b640d6c69c99225,
1282            >(_buf?)?;
1283            Ok(_response.map(|x| x.stats))
1284        }
1285        self.client.send_query_and_decode::<
1286            fidl::encoding::EmptyPayload,
1287            WlanFullmacImplGetIfaceCounterStatsResult,
1288        >(
1289            (),
1290            0x6b640d6c69c99225,
1291            fidl::encoding::DynamicFlags::empty(),
1292            _decode,
1293        )
1294    }
1295
1296    type GetIfaceHistogramStatsResponseFut = fidl::client::QueryResponseFut<
1297        WlanFullmacImplGetIfaceHistogramStatsResult,
1298        fidl::encoding::DefaultFuchsiaResourceDialect,
1299    >;
1300    fn r#get_iface_histogram_stats(&self) -> Self::GetIfaceHistogramStatsResponseFut {
1301        fn _decode(
1302            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1303        ) -> Result<WlanFullmacImplGetIfaceHistogramStatsResult, fidl::Error> {
1304            let _response = fidl::client::decode_transaction_body::<
1305                fidl::encoding::ResultType<WlanFullmacImplGetIfaceHistogramStatsResponse, i32>,
1306                fidl::encoding::DefaultFuchsiaResourceDialect,
1307                0x503d586f30ccf2cd,
1308            >(_buf?)?;
1309            Ok(_response.map(|x| x.stats))
1310        }
1311        self.client.send_query_and_decode::<
1312            fidl::encoding::EmptyPayload,
1313            WlanFullmacImplGetIfaceHistogramStatsResult,
1314        >(
1315            (),
1316            0x503d586f30ccf2cd,
1317            fidl::encoding::DynamicFlags::empty(),
1318            _decode,
1319        )
1320    }
1321
1322    type SaeHandshakeRespResponseFut =
1323        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1324    fn r#sae_handshake_resp(
1325        &self,
1326        mut payload: &WlanFullmacImplSaeHandshakeRespRequest,
1327    ) -> Self::SaeHandshakeRespResponseFut {
1328        fn _decode(
1329            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1330        ) -> Result<(), fidl::Error> {
1331            let _response = fidl::client::decode_transaction_body::<
1332                fidl::encoding::EmptyPayload,
1333                fidl::encoding::DefaultFuchsiaResourceDialect,
1334                0x72cd3a31ae5a54f6,
1335            >(_buf?)?;
1336            Ok(_response)
1337        }
1338        self.client.send_query_and_decode::<WlanFullmacImplSaeHandshakeRespRequest, ()>(
1339            payload,
1340            0x72cd3a31ae5a54f6,
1341            fidl::encoding::DynamicFlags::empty(),
1342            _decode,
1343        )
1344    }
1345
1346    type SaeFrameTxResponseFut =
1347        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1348    fn r#sae_frame_tx(&self, mut frame: &SaeFrame) -> Self::SaeFrameTxResponseFut {
1349        fn _decode(
1350            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1351        ) -> Result<(), fidl::Error> {
1352            let _response = fidl::client::decode_transaction_body::<
1353                fidl::encoding::EmptyPayload,
1354                fidl::encoding::DefaultFuchsiaResourceDialect,
1355                0x4715ad5dc5a6340f,
1356            >(_buf?)?;
1357            Ok(_response)
1358        }
1359        self.client.send_query_and_decode::<WlanFullmacImplSaeFrameTxRequest, ()>(
1360            (frame,),
1361            0x4715ad5dc5a6340f,
1362            fidl::encoding::DynamicFlags::empty(),
1363            _decode,
1364        )
1365    }
1366
1367    type WmmStatusReqResponseFut =
1368        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1369    fn r#wmm_status_req(&self) -> Self::WmmStatusReqResponseFut {
1370        fn _decode(
1371            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1372        ) -> Result<(), fidl::Error> {
1373            let _response = fidl::client::decode_transaction_body::<
1374                fidl::encoding::EmptyPayload,
1375                fidl::encoding::DefaultFuchsiaResourceDialect,
1376                0x635ecef3beb7a059,
1377            >(_buf?)?;
1378            Ok(_response)
1379        }
1380        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, ()>(
1381            (),
1382            0x635ecef3beb7a059,
1383            fidl::encoding::DynamicFlags::empty(),
1384            _decode,
1385        )
1386    }
1387
1388    type OnLinkStateChangedResponseFut =
1389        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
1390    fn r#on_link_state_changed(
1391        &self,
1392        mut payload: &WlanFullmacImplOnLinkStateChangedRequest,
1393    ) -> Self::OnLinkStateChangedResponseFut {
1394        fn _decode(
1395            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1396        ) -> Result<(), fidl::Error> {
1397            let _response = fidl::client::decode_transaction_body::<
1398                fidl::encoding::EmptyPayload,
1399                fidl::encoding::DefaultFuchsiaResourceDialect,
1400                0x4d896e5b68e488d7,
1401            >(_buf?)?;
1402            Ok(_response)
1403        }
1404        self.client.send_query_and_decode::<WlanFullmacImplOnLinkStateChangedRequest, ()>(
1405            payload,
1406            0x4d896e5b68e488d7,
1407            fidl::encoding::DynamicFlags::empty(),
1408            _decode,
1409        )
1410    }
1411}
1412
1413pub struct WlanFullmacImpl_EventStream {
1414    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1415}
1416
1417impl std::marker::Unpin for WlanFullmacImpl_EventStream {}
1418
1419impl futures::stream::FusedStream for WlanFullmacImpl_EventStream {
1420    fn is_terminated(&self) -> bool {
1421        self.event_receiver.is_terminated()
1422    }
1423}
1424
1425impl futures::Stream for WlanFullmacImpl_EventStream {
1426    type Item = Result<WlanFullmacImpl_Event, fidl::Error>;
1427
1428    fn poll_next(
1429        mut self: std::pin::Pin<&mut Self>,
1430        cx: &mut std::task::Context<'_>,
1431    ) -> std::task::Poll<Option<Self::Item>> {
1432        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1433            &mut self.event_receiver,
1434            cx
1435        )?) {
1436            Some(buf) => std::task::Poll::Ready(Some(WlanFullmacImpl_Event::decode(buf))),
1437            None => std::task::Poll::Ready(None),
1438        }
1439    }
1440}
1441
1442#[derive(Debug)]
1443pub enum WlanFullmacImpl_Event {}
1444
1445impl WlanFullmacImpl_Event {
1446    /// Decodes a message buffer as a [`WlanFullmacImpl_Event`].
1447    fn decode(
1448        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1449    ) -> Result<WlanFullmacImpl_Event, fidl::Error> {
1450        let (bytes, _handles) = buf.split_mut();
1451        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1452        debug_assert_eq!(tx_header.tx_id, 0);
1453        match tx_header.ordinal {
1454            _ => Err(fidl::Error::UnknownOrdinal {
1455                ordinal: tx_header.ordinal,
1456                protocol_name:
1457                    <WlanFullmacImpl_Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1458            }),
1459        }
1460    }
1461}
1462
1463/// A Stream of incoming requests for fuchsia.wlan.fullmac/WlanFullmacImpl.
1464pub struct WlanFullmacImpl_RequestStream {
1465    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1466    is_terminated: bool,
1467}
1468
1469impl std::marker::Unpin for WlanFullmacImpl_RequestStream {}
1470
1471impl futures::stream::FusedStream for WlanFullmacImpl_RequestStream {
1472    fn is_terminated(&self) -> bool {
1473        self.is_terminated
1474    }
1475}
1476
1477impl fidl::endpoints::RequestStream for WlanFullmacImpl_RequestStream {
1478    type Protocol = WlanFullmacImpl_Marker;
1479    type ControlHandle = WlanFullmacImpl_ControlHandle;
1480
1481    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1482        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1483    }
1484
1485    fn control_handle(&self) -> Self::ControlHandle {
1486        WlanFullmacImpl_ControlHandle { inner: self.inner.clone() }
1487    }
1488
1489    fn into_inner(
1490        self,
1491    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1492    {
1493        (self.inner, self.is_terminated)
1494    }
1495
1496    fn from_inner(
1497        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1498        is_terminated: bool,
1499    ) -> Self {
1500        Self { inner, is_terminated }
1501    }
1502}
1503
1504impl futures::Stream for WlanFullmacImpl_RequestStream {
1505    type Item = Result<WlanFullmacImpl_Request, fidl::Error>;
1506
1507    fn poll_next(
1508        mut self: std::pin::Pin<&mut Self>,
1509        cx: &mut std::task::Context<'_>,
1510    ) -> std::task::Poll<Option<Self::Item>> {
1511        let this = &mut *self;
1512        if this.inner.check_shutdown(cx) {
1513            this.is_terminated = true;
1514            return std::task::Poll::Ready(None);
1515        }
1516        if this.is_terminated {
1517            panic!("polled WlanFullmacImpl_RequestStream after completion");
1518        }
1519        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1520            |bytes, handles| {
1521                match this.inner.channel().read_etc(cx, bytes, handles) {
1522                    std::task::Poll::Ready(Ok(())) => {}
1523                    std::task::Poll::Pending => return std::task::Poll::Pending,
1524                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1525                        this.is_terminated = true;
1526                        return std::task::Poll::Ready(None);
1527                    }
1528                    std::task::Poll::Ready(Err(e)) => {
1529                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1530                            e.into(),
1531                        ))))
1532                    }
1533                }
1534
1535                // A message has been received from the channel
1536                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1537
1538                std::task::Poll::Ready(Some(match header.ordinal {
1539                    0x593dfb6cb3f0f1aa => {
1540                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1541                        let mut req = fidl::new_empty!(
1542                            WlanFullmacImplInitRequest,
1543                            fidl::encoding::DefaultFuchsiaResourceDialect
1544                        );
1545                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplInitRequest>(&header, _body_bytes, handles, &mut req)?;
1546                        let control_handle =
1547                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1548                        Ok(WlanFullmacImpl_Request::Init {
1549                            payload: req,
1550                            responder: WlanFullmacImpl_InitResponder {
1551                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1552                                tx_id: header.tx_id,
1553                            },
1554                        })
1555                    }
1556                    0x28ac65f9da3941d4 => {
1557                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1558                        let mut req = fidl::new_empty!(
1559                            fidl::encoding::EmptyPayload,
1560                            fidl::encoding::DefaultFuchsiaResourceDialect
1561                        );
1562                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1563                        let control_handle =
1564                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1565                        Ok(WlanFullmacImpl_Request::Query {
1566                            responder: WlanFullmacImpl_QueryResponder {
1567                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1568                                tx_id: header.tx_id,
1569                            },
1570                        })
1571                    }
1572                    0x2f09187eb87d9bad => {
1573                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1574                        let mut req = fidl::new_empty!(
1575                            fidl::encoding::EmptyPayload,
1576                            fidl::encoding::DefaultFuchsiaResourceDialect
1577                        );
1578                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1579                        let control_handle =
1580                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1581                        Ok(WlanFullmacImpl_Request::QueryMacSublayerSupport {
1582                            responder: WlanFullmacImpl_QueryMacSublayerSupportResponder {
1583                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1584                                tx_id: header.tx_id,
1585                            },
1586                        })
1587                    }
1588                    0x11cf3fa6eeb93f84 => {
1589                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1590                        let mut req = fidl::new_empty!(
1591                            fidl::encoding::EmptyPayload,
1592                            fidl::encoding::DefaultFuchsiaResourceDialect
1593                        );
1594                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1595                        let control_handle =
1596                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1597                        Ok(WlanFullmacImpl_Request::QuerySecuritySupport {
1598                            responder: WlanFullmacImpl_QuerySecuritySupportResponder {
1599                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1600                                tx_id: header.tx_id,
1601                            },
1602                        })
1603                    }
1604                    0x22ae7551d855b83a => {
1605                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1606                        let mut req = fidl::new_empty!(
1607                            fidl::encoding::EmptyPayload,
1608                            fidl::encoding::DefaultFuchsiaResourceDialect
1609                        );
1610                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1611                        let control_handle =
1612                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1613                        Ok(WlanFullmacImpl_Request::QuerySpectrumManagementSupport {
1614                            responder: WlanFullmacImpl_QuerySpectrumManagementSupportResponder {
1615                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1616                                tx_id: header.tx_id,
1617                            },
1618                        })
1619                    }
1620                    0x4561479ca560827f => {
1621                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1622                        let mut req = fidl::new_empty!(
1623                            fidl::encoding::EmptyPayload,
1624                            fidl::encoding::DefaultFuchsiaResourceDialect
1625                        );
1626                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1627                        let control_handle =
1628                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1629                        Ok(WlanFullmacImpl_Request::QueryTelemetrySupport {
1630                            responder: WlanFullmacImpl_QueryTelemetrySupportResponder {
1631                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1632                                tx_id: header.tx_id,
1633                            },
1634                        })
1635                    }
1636                    0x26c17bf595aa161c => {
1637                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1638                        let mut req = fidl::new_empty!(
1639                            WlanFullmacImplStartScanRequest,
1640                            fidl::encoding::DefaultFuchsiaResourceDialect
1641                        );
1642                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplStartScanRequest>(&header, _body_bytes, handles, &mut req)?;
1643                        let control_handle =
1644                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1645                        Ok(WlanFullmacImpl_Request::StartScan {
1646                            payload: req,
1647                            responder: WlanFullmacImpl_StartScanResponder {
1648                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1649                                tx_id: header.tx_id,
1650                            },
1651                        })
1652                    }
1653                    0x19eb0322efb07a76 => {
1654                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1655                        let mut req = fidl::new_empty!(
1656                            WlanFullmacImplConnectRequest,
1657                            fidl::encoding::DefaultFuchsiaResourceDialect
1658                        );
1659                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplConnectRequest>(&header, _body_bytes, handles, &mut req)?;
1660                        let control_handle =
1661                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1662                        Ok(WlanFullmacImpl_Request::Connect {
1663                            payload: req,
1664                            responder: WlanFullmacImpl_ConnectResponder {
1665                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1666                                tx_id: header.tx_id,
1667                            },
1668                        })
1669                    }
1670                    0x474084c4ef19ee71 => {
1671                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1672                        let mut req = fidl::new_empty!(
1673                            WlanFullmacImplReconnectRequest,
1674                            fidl::encoding::DefaultFuchsiaResourceDialect
1675                        );
1676                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplReconnectRequest>(&header, _body_bytes, handles, &mut req)?;
1677                        let control_handle =
1678                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1679                        Ok(WlanFullmacImpl_Request::Reconnect {
1680                            payload: req,
1681                            responder: WlanFullmacImpl_ReconnectResponder {
1682                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1683                                tx_id: header.tx_id,
1684                            },
1685                        })
1686                    }
1687                    0x1e35dcc98b124b64 => {
1688                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1689                        let mut req = fidl::new_empty!(
1690                            WlanFullmacImplRoamRequest,
1691                            fidl::encoding::DefaultFuchsiaResourceDialect
1692                        );
1693                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplRoamRequest>(&header, _body_bytes, handles, &mut req)?;
1694                        let control_handle =
1695                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1696                        Ok(WlanFullmacImpl_Request::Roam {
1697                            payload: req,
1698                            responder: WlanFullmacImpl_RoamResponder {
1699                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1700                                tx_id: header.tx_id,
1701                            },
1702                        })
1703                    }
1704                    0x5f7ea24b44a4aaeb => {
1705                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1706                        let mut req = fidl::new_empty!(
1707                            WlanFullmacImplAuthRespRequest,
1708                            fidl::encoding::DefaultFuchsiaResourceDialect
1709                        );
1710                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplAuthRespRequest>(&header, _body_bytes, handles, &mut req)?;
1711                        let control_handle =
1712                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1713                        Ok(WlanFullmacImpl_Request::AuthResp {
1714                            payload: req,
1715                            responder: WlanFullmacImpl_AuthRespResponder {
1716                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1717                                tx_id: header.tx_id,
1718                            },
1719                        })
1720                    }
1721                    0x112786eccbf12f37 => {
1722                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1723                        let mut req = fidl::new_empty!(
1724                            WlanFullmacImplDeauthRequest,
1725                            fidl::encoding::DefaultFuchsiaResourceDialect
1726                        );
1727                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplDeauthRequest>(&header, _body_bytes, handles, &mut req)?;
1728                        let control_handle =
1729                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1730                        Ok(WlanFullmacImpl_Request::Deauth {
1731                            payload: req,
1732                            responder: WlanFullmacImpl_DeauthResponder {
1733                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1734                                tx_id: header.tx_id,
1735                            },
1736                        })
1737                    }
1738                    0x5022ce6b8eefec2f => {
1739                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1740                        let mut req = fidl::new_empty!(
1741                            WlanFullmacImplAssocRespRequest,
1742                            fidl::encoding::DefaultFuchsiaResourceDialect
1743                        );
1744                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplAssocRespRequest>(&header, _body_bytes, handles, &mut req)?;
1745                        let control_handle =
1746                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1747                        Ok(WlanFullmacImpl_Request::AssocResp {
1748                            payload: req,
1749                            responder: WlanFullmacImpl_AssocRespResponder {
1750                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1751                                tx_id: header.tx_id,
1752                            },
1753                        })
1754                    }
1755                    0x9c0fc4e8de53e01 => {
1756                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1757                        let mut req = fidl::new_empty!(
1758                            WlanFullmacImplDisassocRequest,
1759                            fidl::encoding::DefaultFuchsiaResourceDialect
1760                        );
1761                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplDisassocRequest>(&header, _body_bytes, handles, &mut req)?;
1762                        let control_handle =
1763                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1764                        Ok(WlanFullmacImpl_Request::Disassoc {
1765                            payload: req,
1766                            responder: WlanFullmacImpl_DisassocResponder {
1767                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1768                                tx_id: header.tx_id,
1769                            },
1770                        })
1771                    }
1772                    0x6922644d6b1d341d => {
1773                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1774                        let mut req = fidl::new_empty!(
1775                            WlanFullmacImplStartBssRequest,
1776                            fidl::encoding::DefaultFuchsiaResourceDialect
1777                        );
1778                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplStartBssRequest>(&header, _body_bytes, handles, &mut req)?;
1779                        let control_handle =
1780                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1781                        Ok(WlanFullmacImpl_Request::StartBss {
1782                            payload: req,
1783                            responder: WlanFullmacImpl_StartBssResponder {
1784                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1785                                tx_id: header.tx_id,
1786                            },
1787                        })
1788                    }
1789                    0x5aeb9b72e7575268 => {
1790                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1791                        let mut req = fidl::new_empty!(
1792                            WlanFullmacImplStopBssRequest,
1793                            fidl::encoding::DefaultFuchsiaResourceDialect
1794                        );
1795                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplStopBssRequest>(&header, _body_bytes, handles, &mut req)?;
1796                        let control_handle =
1797                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1798                        Ok(WlanFullmacImpl_Request::StopBss {
1799                            payload: req,
1800                            responder: WlanFullmacImpl_StopBssResponder {
1801                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1802                                tx_id: header.tx_id,
1803                            },
1804                        })
1805                    }
1806                    0x20f46b1e039f0985 => {
1807                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1808                        let mut req = fidl::new_empty!(
1809                            WlanFullmacImplSetKeysRequest,
1810                            fidl::encoding::DefaultFuchsiaResourceDialect
1811                        );
1812                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplSetKeysRequest>(&header, _body_bytes, handles, &mut req)?;
1813                        let control_handle =
1814                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1815                        Ok(WlanFullmacImpl_Request::SetKeys {
1816                            payload: req,
1817                            responder: WlanFullmacImpl_SetKeysResponder {
1818                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1819                                tx_id: header.tx_id,
1820                            },
1821                        })
1822                    }
1823                    0x529a2d90fd4c8177 => {
1824                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1825                        let mut req = fidl::new_empty!(
1826                            WlanFullmacImplEapolTxRequest,
1827                            fidl::encoding::DefaultFuchsiaResourceDialect
1828                        );
1829                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplEapolTxRequest>(&header, _body_bytes, handles, &mut req)?;
1830                        let control_handle =
1831                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1832                        Ok(WlanFullmacImpl_Request::EapolTx {
1833                            payload: req,
1834                            responder: WlanFullmacImpl_EapolTxResponder {
1835                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1836                                tx_id: header.tx_id,
1837                            },
1838                        })
1839                    }
1840                    0x6b640d6c69c99225 => {
1841                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1842                        let mut req = fidl::new_empty!(
1843                            fidl::encoding::EmptyPayload,
1844                            fidl::encoding::DefaultFuchsiaResourceDialect
1845                        );
1846                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1847                        let control_handle =
1848                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1849                        Ok(WlanFullmacImpl_Request::GetIfaceCounterStats {
1850                            responder: WlanFullmacImpl_GetIfaceCounterStatsResponder {
1851                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1852                                tx_id: header.tx_id,
1853                            },
1854                        })
1855                    }
1856                    0x503d586f30ccf2cd => {
1857                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1858                        let mut req = fidl::new_empty!(
1859                            fidl::encoding::EmptyPayload,
1860                            fidl::encoding::DefaultFuchsiaResourceDialect
1861                        );
1862                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1863                        let control_handle =
1864                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1865                        Ok(WlanFullmacImpl_Request::GetIfaceHistogramStats {
1866                            responder: WlanFullmacImpl_GetIfaceHistogramStatsResponder {
1867                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1868                                tx_id: header.tx_id,
1869                            },
1870                        })
1871                    }
1872                    0x72cd3a31ae5a54f6 => {
1873                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1874                        let mut req = fidl::new_empty!(
1875                            WlanFullmacImplSaeHandshakeRespRequest,
1876                            fidl::encoding::DefaultFuchsiaResourceDialect
1877                        );
1878                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplSaeHandshakeRespRequest>(&header, _body_bytes, handles, &mut req)?;
1879                        let control_handle =
1880                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1881                        Ok(WlanFullmacImpl_Request::SaeHandshakeResp {
1882                            payload: req,
1883                            responder: WlanFullmacImpl_SaeHandshakeRespResponder {
1884                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1885                                tx_id: header.tx_id,
1886                            },
1887                        })
1888                    }
1889                    0x4715ad5dc5a6340f => {
1890                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1891                        let mut req = fidl::new_empty!(
1892                            WlanFullmacImplSaeFrameTxRequest,
1893                            fidl::encoding::DefaultFuchsiaResourceDialect
1894                        );
1895                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplSaeFrameTxRequest>(&header, _body_bytes, handles, &mut req)?;
1896                        let control_handle =
1897                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1898                        Ok(WlanFullmacImpl_Request::SaeFrameTx {
1899                            frame: req.frame,
1900
1901                            responder: WlanFullmacImpl_SaeFrameTxResponder {
1902                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1903                                tx_id: header.tx_id,
1904                            },
1905                        })
1906                    }
1907                    0x635ecef3beb7a059 => {
1908                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1909                        let mut req = fidl::new_empty!(
1910                            fidl::encoding::EmptyPayload,
1911                            fidl::encoding::DefaultFuchsiaResourceDialect
1912                        );
1913                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
1914                        let control_handle =
1915                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1916                        Ok(WlanFullmacImpl_Request::WmmStatusReq {
1917                            responder: WlanFullmacImpl_WmmStatusReqResponder {
1918                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1919                                tx_id: header.tx_id,
1920                            },
1921                        })
1922                    }
1923                    0x4d896e5b68e488d7 => {
1924                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1925                        let mut req = fidl::new_empty!(
1926                            WlanFullmacImplOnLinkStateChangedRequest,
1927                            fidl::encoding::DefaultFuchsiaResourceDialect
1928                        );
1929                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplOnLinkStateChangedRequest>(&header, _body_bytes, handles, &mut req)?;
1930                        let control_handle =
1931                            WlanFullmacImpl_ControlHandle { inner: this.inner.clone() };
1932                        Ok(WlanFullmacImpl_Request::OnLinkStateChanged {
1933                            payload: req,
1934                            responder: WlanFullmacImpl_OnLinkStateChangedResponder {
1935                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1936                                tx_id: header.tx_id,
1937                            },
1938                        })
1939                    }
1940                    _ => Err(fidl::Error::UnknownOrdinal {
1941                        ordinal: header.ordinal,
1942                        protocol_name:
1943                            <WlanFullmacImpl_Marker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1944                    }),
1945                }))
1946            },
1947        )
1948    }
1949}
1950
1951/// Protocol definition for communication from the platform to the fullmac
1952/// vendor driver.
1953#[derive(Debug)]
1954pub enum WlanFullmacImpl_Request {
1955    /// Initialize the FullMAC driver. This is the first request that the platform will make to the
1956    /// FullMAC driver.
1957    ///
1958    /// On initialization, MLME provides the client end to the WlanFullmacImplIfc protocol. The
1959    /// driver must return the SME server end channel, which is used internally by the platform.
1960    /// Typically, the SME server end channel is given to the FullMAC driver by
1961    /// fuchsia.wlan.phyimpl/WlanPhyImpl.CreateIface.
1962    ///
1963    /// If `Init` completes successfully, the platform will begin making other WlanFullmacImpl
1964    /// requests to the FullMAC driver, and the FullMAC driver is free to make WlanFullmacImplIfc
1965    /// requests to the platform. The platform may continue making WlanFullmacImpl requests until
1966    /// the WlanFullmacImpl server unbinds.
1967    ///
1968    /// Common errors include:
1969    ///   - `ZX_ERR_ALREADY_BOUND`: `Init` was already called on this FullMAC driver.
1970    Init {
1971        payload: WlanFullmacImplInitRequest,
1972        responder: WlanFullmacImpl_InitResponder,
1973    },
1974    /// Returns high-level information describing the state of the FullMAC driver.
1975    /// This is safe to call even before the call to WlanFullmacImpl::Start.
1976    Query {
1977        responder: WlanFullmacImpl_QueryResponder,
1978    },
1979    QueryMacSublayerSupport {
1980        responder: WlanFullmacImpl_QueryMacSublayerSupportResponder,
1981    },
1982    QuerySecuritySupport {
1983        responder: WlanFullmacImpl_QuerySecuritySupportResponder,
1984    },
1985    QuerySpectrumManagementSupport {
1986        responder: WlanFullmacImpl_QuerySpectrumManagementSupportResponder,
1987    },
1988    QueryTelemetrySupport {
1989        responder: WlanFullmacImpl_QueryTelemetrySupportResponder,
1990    },
1991    StartScan {
1992        payload: WlanFullmacImplStartScanRequest,
1993        responder: WlanFullmacImpl_StartScanResponder,
1994    },
1995    Connect {
1996        payload: WlanFullmacImplConnectRequest,
1997        responder: WlanFullmacImpl_ConnectResponder,
1998    },
1999    Reconnect {
2000        payload: WlanFullmacImplReconnectRequest,
2001        responder: WlanFullmacImpl_ReconnectResponder,
2002    },
2003    /// Initiate a roam attempt, which moves association to a different BSS within the ESS.
2004    Roam {
2005        payload: WlanFullmacImplRoamRequest,
2006        responder: WlanFullmacImpl_RoamResponder,
2007    },
2008    AuthResp {
2009        payload: WlanFullmacImplAuthRespRequest,
2010        responder: WlanFullmacImpl_AuthRespResponder,
2011    },
2012    Deauth {
2013        payload: WlanFullmacImplDeauthRequest,
2014        responder: WlanFullmacImpl_DeauthResponder,
2015    },
2016    AssocResp {
2017        payload: WlanFullmacImplAssocRespRequest,
2018        responder: WlanFullmacImpl_AssocRespResponder,
2019    },
2020    Disassoc {
2021        payload: WlanFullmacImplDisassocRequest,
2022        responder: WlanFullmacImpl_DisassocResponder,
2023    },
2024    StartBss {
2025        payload: WlanFullmacImplStartBssRequest,
2026        responder: WlanFullmacImpl_StartBssResponder,
2027    },
2028    StopBss {
2029        payload: WlanFullmacImplStopBssRequest,
2030        responder: WlanFullmacImpl_StopBssResponder,
2031    },
2032    /// Sets security keys for a connection. This is typically called after a successful key
2033    /// exchange.
2034    ///
2035    /// Note that the platform assumes that the driver will automatically delete keys on a
2036    /// disconnect or key rotation.
2037    SetKeys {
2038        payload: WlanFullmacImplSetKeysRequest,
2039        responder: WlanFullmacImpl_SetKeysResponder,
2040    },
2041    EapolTx {
2042        payload: WlanFullmacImplEapolTxRequest,
2043        responder: WlanFullmacImpl_EapolTxResponder,
2044    },
2045    GetIfaceCounterStats {
2046        responder: WlanFullmacImpl_GetIfaceCounterStatsResponder,
2047    },
2048    GetIfaceHistogramStats {
2049        responder: WlanFullmacImpl_GetIfaceHistogramStatsResponder,
2050    },
2051    /// Informs the driver of the result of an SAE handshake.
2052    SaeHandshakeResp {
2053        payload: WlanFullmacImplSaeHandshakeRespRequest,
2054        responder: WlanFullmacImpl_SaeHandshakeRespResponder,
2055    },
2056    /// Transmit an SAE authentication frame.
2057    SaeFrameTx {
2058        frame: SaeFrame,
2059        responder: WlanFullmacImpl_SaeFrameTxResponder,
2060    },
2061    WmmStatusReq {
2062        responder: WlanFullmacImpl_WmmStatusReqResponder,
2063    },
2064    OnLinkStateChanged {
2065        payload: WlanFullmacImplOnLinkStateChangedRequest,
2066        responder: WlanFullmacImpl_OnLinkStateChangedResponder,
2067    },
2068}
2069
2070impl WlanFullmacImpl_Request {
2071    #[allow(irrefutable_let_patterns)]
2072    pub fn into_init(self) -> Option<(WlanFullmacImplInitRequest, WlanFullmacImpl_InitResponder)> {
2073        if let WlanFullmacImpl_Request::Init { payload, responder } = self {
2074            Some((payload, responder))
2075        } else {
2076            None
2077        }
2078    }
2079
2080    #[allow(irrefutable_let_patterns)]
2081    pub fn into_query(self) -> Option<(WlanFullmacImpl_QueryResponder)> {
2082        if let WlanFullmacImpl_Request::Query { responder } = self {
2083            Some((responder))
2084        } else {
2085            None
2086        }
2087    }
2088
2089    #[allow(irrefutable_let_patterns)]
2090    pub fn into_query_mac_sublayer_support(
2091        self,
2092    ) -> Option<(WlanFullmacImpl_QueryMacSublayerSupportResponder)> {
2093        if let WlanFullmacImpl_Request::QueryMacSublayerSupport { responder } = self {
2094            Some((responder))
2095        } else {
2096            None
2097        }
2098    }
2099
2100    #[allow(irrefutable_let_patterns)]
2101    pub fn into_query_security_support(
2102        self,
2103    ) -> Option<(WlanFullmacImpl_QuerySecuritySupportResponder)> {
2104        if let WlanFullmacImpl_Request::QuerySecuritySupport { responder } = self {
2105            Some((responder))
2106        } else {
2107            None
2108        }
2109    }
2110
2111    #[allow(irrefutable_let_patterns)]
2112    pub fn into_query_spectrum_management_support(
2113        self,
2114    ) -> Option<(WlanFullmacImpl_QuerySpectrumManagementSupportResponder)> {
2115        if let WlanFullmacImpl_Request::QuerySpectrumManagementSupport { responder } = self {
2116            Some((responder))
2117        } else {
2118            None
2119        }
2120    }
2121
2122    #[allow(irrefutable_let_patterns)]
2123    pub fn into_query_telemetry_support(
2124        self,
2125    ) -> Option<(WlanFullmacImpl_QueryTelemetrySupportResponder)> {
2126        if let WlanFullmacImpl_Request::QueryTelemetrySupport { responder } = self {
2127            Some((responder))
2128        } else {
2129            None
2130        }
2131    }
2132
2133    #[allow(irrefutable_let_patterns)]
2134    pub fn into_start_scan(
2135        self,
2136    ) -> Option<(WlanFullmacImplStartScanRequest, WlanFullmacImpl_StartScanResponder)> {
2137        if let WlanFullmacImpl_Request::StartScan { payload, responder } = self {
2138            Some((payload, responder))
2139        } else {
2140            None
2141        }
2142    }
2143
2144    #[allow(irrefutable_let_patterns)]
2145    pub fn into_connect(
2146        self,
2147    ) -> Option<(WlanFullmacImplConnectRequest, WlanFullmacImpl_ConnectResponder)> {
2148        if let WlanFullmacImpl_Request::Connect { payload, responder } = self {
2149            Some((payload, responder))
2150        } else {
2151            None
2152        }
2153    }
2154
2155    #[allow(irrefutable_let_patterns)]
2156    pub fn into_reconnect(
2157        self,
2158    ) -> Option<(WlanFullmacImplReconnectRequest, WlanFullmacImpl_ReconnectResponder)> {
2159        if let WlanFullmacImpl_Request::Reconnect { payload, responder } = self {
2160            Some((payload, responder))
2161        } else {
2162            None
2163        }
2164    }
2165
2166    #[allow(irrefutable_let_patterns)]
2167    pub fn into_roam(self) -> Option<(WlanFullmacImplRoamRequest, WlanFullmacImpl_RoamResponder)> {
2168        if let WlanFullmacImpl_Request::Roam { payload, responder } = self {
2169            Some((payload, responder))
2170        } else {
2171            None
2172        }
2173    }
2174
2175    #[allow(irrefutable_let_patterns)]
2176    pub fn into_auth_resp(
2177        self,
2178    ) -> Option<(WlanFullmacImplAuthRespRequest, WlanFullmacImpl_AuthRespResponder)> {
2179        if let WlanFullmacImpl_Request::AuthResp { payload, responder } = self {
2180            Some((payload, responder))
2181        } else {
2182            None
2183        }
2184    }
2185
2186    #[allow(irrefutable_let_patterns)]
2187    pub fn into_deauth(
2188        self,
2189    ) -> Option<(WlanFullmacImplDeauthRequest, WlanFullmacImpl_DeauthResponder)> {
2190        if let WlanFullmacImpl_Request::Deauth { payload, responder } = self {
2191            Some((payload, responder))
2192        } else {
2193            None
2194        }
2195    }
2196
2197    #[allow(irrefutable_let_patterns)]
2198    pub fn into_assoc_resp(
2199        self,
2200    ) -> Option<(WlanFullmacImplAssocRespRequest, WlanFullmacImpl_AssocRespResponder)> {
2201        if let WlanFullmacImpl_Request::AssocResp { payload, responder } = self {
2202            Some((payload, responder))
2203        } else {
2204            None
2205        }
2206    }
2207
2208    #[allow(irrefutable_let_patterns)]
2209    pub fn into_disassoc(
2210        self,
2211    ) -> Option<(WlanFullmacImplDisassocRequest, WlanFullmacImpl_DisassocResponder)> {
2212        if let WlanFullmacImpl_Request::Disassoc { payload, responder } = self {
2213            Some((payload, responder))
2214        } else {
2215            None
2216        }
2217    }
2218
2219    #[allow(irrefutable_let_patterns)]
2220    pub fn into_start_bss(
2221        self,
2222    ) -> Option<(WlanFullmacImplStartBssRequest, WlanFullmacImpl_StartBssResponder)> {
2223        if let WlanFullmacImpl_Request::StartBss { payload, responder } = self {
2224            Some((payload, responder))
2225        } else {
2226            None
2227        }
2228    }
2229
2230    #[allow(irrefutable_let_patterns)]
2231    pub fn into_stop_bss(
2232        self,
2233    ) -> Option<(WlanFullmacImplStopBssRequest, WlanFullmacImpl_StopBssResponder)> {
2234        if let WlanFullmacImpl_Request::StopBss { payload, responder } = self {
2235            Some((payload, responder))
2236        } else {
2237            None
2238        }
2239    }
2240
2241    #[allow(irrefutable_let_patterns)]
2242    pub fn into_set_keys(
2243        self,
2244    ) -> Option<(WlanFullmacImplSetKeysRequest, WlanFullmacImpl_SetKeysResponder)> {
2245        if let WlanFullmacImpl_Request::SetKeys { payload, responder } = self {
2246            Some((payload, responder))
2247        } else {
2248            None
2249        }
2250    }
2251
2252    #[allow(irrefutable_let_patterns)]
2253    pub fn into_eapol_tx(
2254        self,
2255    ) -> Option<(WlanFullmacImplEapolTxRequest, WlanFullmacImpl_EapolTxResponder)> {
2256        if let WlanFullmacImpl_Request::EapolTx { payload, responder } = self {
2257            Some((payload, responder))
2258        } else {
2259            None
2260        }
2261    }
2262
2263    #[allow(irrefutable_let_patterns)]
2264    pub fn into_get_iface_counter_stats(
2265        self,
2266    ) -> Option<(WlanFullmacImpl_GetIfaceCounterStatsResponder)> {
2267        if let WlanFullmacImpl_Request::GetIfaceCounterStats { responder } = self {
2268            Some((responder))
2269        } else {
2270            None
2271        }
2272    }
2273
2274    #[allow(irrefutable_let_patterns)]
2275    pub fn into_get_iface_histogram_stats(
2276        self,
2277    ) -> Option<(WlanFullmacImpl_GetIfaceHistogramStatsResponder)> {
2278        if let WlanFullmacImpl_Request::GetIfaceHistogramStats { responder } = self {
2279            Some((responder))
2280        } else {
2281            None
2282        }
2283    }
2284
2285    #[allow(irrefutable_let_patterns)]
2286    pub fn into_sae_handshake_resp(
2287        self,
2288    ) -> Option<(WlanFullmacImplSaeHandshakeRespRequest, WlanFullmacImpl_SaeHandshakeRespResponder)>
2289    {
2290        if let WlanFullmacImpl_Request::SaeHandshakeResp { payload, responder } = self {
2291            Some((payload, responder))
2292        } else {
2293            None
2294        }
2295    }
2296
2297    #[allow(irrefutable_let_patterns)]
2298    pub fn into_sae_frame_tx(self) -> Option<(SaeFrame, WlanFullmacImpl_SaeFrameTxResponder)> {
2299        if let WlanFullmacImpl_Request::SaeFrameTx { frame, responder } = self {
2300            Some((frame, responder))
2301        } else {
2302            None
2303        }
2304    }
2305
2306    #[allow(irrefutable_let_patterns)]
2307    pub fn into_wmm_status_req(self) -> Option<(WlanFullmacImpl_WmmStatusReqResponder)> {
2308        if let WlanFullmacImpl_Request::WmmStatusReq { responder } = self {
2309            Some((responder))
2310        } else {
2311            None
2312        }
2313    }
2314
2315    #[allow(irrefutable_let_patterns)]
2316    pub fn into_on_link_state_changed(
2317        self,
2318    ) -> Option<(
2319        WlanFullmacImplOnLinkStateChangedRequest,
2320        WlanFullmacImpl_OnLinkStateChangedResponder,
2321    )> {
2322        if let WlanFullmacImpl_Request::OnLinkStateChanged { payload, responder } = self {
2323            Some((payload, responder))
2324        } else {
2325            None
2326        }
2327    }
2328
2329    /// Name of the method defined in FIDL
2330    pub fn method_name(&self) -> &'static str {
2331        match *self {
2332            WlanFullmacImpl_Request::Init { .. } => "init",
2333            WlanFullmacImpl_Request::Query { .. } => "query",
2334            WlanFullmacImpl_Request::QueryMacSublayerSupport { .. } => "query_mac_sublayer_support",
2335            WlanFullmacImpl_Request::QuerySecuritySupport { .. } => "query_security_support",
2336            WlanFullmacImpl_Request::QuerySpectrumManagementSupport { .. } => {
2337                "query_spectrum_management_support"
2338            }
2339            WlanFullmacImpl_Request::QueryTelemetrySupport { .. } => "query_telemetry_support",
2340            WlanFullmacImpl_Request::StartScan { .. } => "start_scan",
2341            WlanFullmacImpl_Request::Connect { .. } => "connect",
2342            WlanFullmacImpl_Request::Reconnect { .. } => "reconnect",
2343            WlanFullmacImpl_Request::Roam { .. } => "roam",
2344            WlanFullmacImpl_Request::AuthResp { .. } => "auth_resp",
2345            WlanFullmacImpl_Request::Deauth { .. } => "deauth",
2346            WlanFullmacImpl_Request::AssocResp { .. } => "assoc_resp",
2347            WlanFullmacImpl_Request::Disassoc { .. } => "disassoc",
2348            WlanFullmacImpl_Request::StartBss { .. } => "start_bss",
2349            WlanFullmacImpl_Request::StopBss { .. } => "stop_bss",
2350            WlanFullmacImpl_Request::SetKeys { .. } => "set_keys",
2351            WlanFullmacImpl_Request::EapolTx { .. } => "eapol_tx",
2352            WlanFullmacImpl_Request::GetIfaceCounterStats { .. } => "get_iface_counter_stats",
2353            WlanFullmacImpl_Request::GetIfaceHistogramStats { .. } => "get_iface_histogram_stats",
2354            WlanFullmacImpl_Request::SaeHandshakeResp { .. } => "sae_handshake_resp",
2355            WlanFullmacImpl_Request::SaeFrameTx { .. } => "sae_frame_tx",
2356            WlanFullmacImpl_Request::WmmStatusReq { .. } => "wmm_status_req",
2357            WlanFullmacImpl_Request::OnLinkStateChanged { .. } => "on_link_state_changed",
2358        }
2359    }
2360}
2361
2362#[derive(Debug, Clone)]
2363pub struct WlanFullmacImpl_ControlHandle {
2364    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2365}
2366
2367impl fidl::endpoints::ControlHandle for WlanFullmacImpl_ControlHandle {
2368    fn shutdown(&self) {
2369        self.inner.shutdown()
2370    }
2371    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
2372        self.inner.shutdown_with_epitaph(status)
2373    }
2374
2375    fn is_closed(&self) -> bool {
2376        self.inner.channel().is_closed()
2377    }
2378    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
2379        self.inner.channel().on_closed()
2380    }
2381
2382    #[cfg(target_os = "fuchsia")]
2383    fn signal_peer(
2384        &self,
2385        clear_mask: zx::Signals,
2386        set_mask: zx::Signals,
2387    ) -> Result<(), zx_status::Status> {
2388        use fidl::Peered;
2389        self.inner.channel().signal_peer(clear_mask, set_mask)
2390    }
2391}
2392
2393impl WlanFullmacImpl_ControlHandle {}
2394
2395#[must_use = "FIDL methods require a response to be sent"]
2396#[derive(Debug)]
2397pub struct WlanFullmacImpl_InitResponder {
2398    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2399    tx_id: u32,
2400}
2401
2402/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
2403/// if the responder is dropped without sending a response, so that the client
2404/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2405impl std::ops::Drop for WlanFullmacImpl_InitResponder {
2406    fn drop(&mut self) {
2407        self.control_handle.shutdown();
2408        // Safety: drops once, never accessed again
2409        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2410    }
2411}
2412
2413impl fidl::endpoints::Responder for WlanFullmacImpl_InitResponder {
2414    type ControlHandle = WlanFullmacImpl_ControlHandle;
2415
2416    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2417        &self.control_handle
2418    }
2419
2420    fn drop_without_shutdown(mut self) {
2421        // Safety: drops once, never accessed again due to mem::forget
2422        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2423        // Prevent Drop from running (which would shut down the channel)
2424        std::mem::forget(self);
2425    }
2426}
2427
2428impl WlanFullmacImpl_InitResponder {
2429    /// Sends a response to the FIDL transaction.
2430    ///
2431    /// Sets the channel to shutdown if an error occurs.
2432    pub fn send(
2433        self,
2434        mut result: Result<WlanFullmacImplInitResponse, i32>,
2435    ) -> Result<(), fidl::Error> {
2436        let _result = self.send_raw(result);
2437        if _result.is_err() {
2438            self.control_handle.shutdown();
2439        }
2440        self.drop_without_shutdown();
2441        _result
2442    }
2443
2444    /// Similar to "send" but does not shutdown the channel if an error occurs.
2445    pub fn send_no_shutdown_on_err(
2446        self,
2447        mut result: Result<WlanFullmacImplInitResponse, i32>,
2448    ) -> Result<(), fidl::Error> {
2449        let _result = self.send_raw(result);
2450        self.drop_without_shutdown();
2451        _result
2452    }
2453
2454    fn send_raw(
2455        &self,
2456        mut result: Result<WlanFullmacImplInitResponse, i32>,
2457    ) -> Result<(), fidl::Error> {
2458        self.control_handle
2459            .inner
2460            .send::<fidl::encoding::ResultType<WlanFullmacImplInitResponse, i32>>(
2461                result.as_mut().map_err(|e| *e),
2462                self.tx_id,
2463                0x593dfb6cb3f0f1aa,
2464                fidl::encoding::DynamicFlags::empty(),
2465            )
2466    }
2467}
2468
2469#[must_use = "FIDL methods require a response to be sent"]
2470#[derive(Debug)]
2471pub struct WlanFullmacImpl_QueryResponder {
2472    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2473    tx_id: u32,
2474}
2475
2476/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
2477/// if the responder is dropped without sending a response, so that the client
2478/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2479impl std::ops::Drop for WlanFullmacImpl_QueryResponder {
2480    fn drop(&mut self) {
2481        self.control_handle.shutdown();
2482        // Safety: drops once, never accessed again
2483        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2484    }
2485}
2486
2487impl fidl::endpoints::Responder for WlanFullmacImpl_QueryResponder {
2488    type ControlHandle = WlanFullmacImpl_ControlHandle;
2489
2490    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2491        &self.control_handle
2492    }
2493
2494    fn drop_without_shutdown(mut self) {
2495        // Safety: drops once, never accessed again due to mem::forget
2496        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2497        // Prevent Drop from running (which would shut down the channel)
2498        std::mem::forget(self);
2499    }
2500}
2501
2502impl WlanFullmacImpl_QueryResponder {
2503    /// Sends a response to the FIDL transaction.
2504    ///
2505    /// Sets the channel to shutdown if an error occurs.
2506    pub fn send(
2507        self,
2508        mut result: Result<&WlanFullmacImplQueryResponse, i32>,
2509    ) -> Result<(), fidl::Error> {
2510        let _result = self.send_raw(result);
2511        if _result.is_err() {
2512            self.control_handle.shutdown();
2513        }
2514        self.drop_without_shutdown();
2515        _result
2516    }
2517
2518    /// Similar to "send" but does not shutdown the channel if an error occurs.
2519    pub fn send_no_shutdown_on_err(
2520        self,
2521        mut result: Result<&WlanFullmacImplQueryResponse, i32>,
2522    ) -> Result<(), fidl::Error> {
2523        let _result = self.send_raw(result);
2524        self.drop_without_shutdown();
2525        _result
2526    }
2527
2528    fn send_raw(
2529        &self,
2530        mut result: Result<&WlanFullmacImplQueryResponse, i32>,
2531    ) -> Result<(), fidl::Error> {
2532        self.control_handle
2533            .inner
2534            .send::<fidl::encoding::ResultType<WlanFullmacImplQueryResponse, i32>>(
2535                result,
2536                self.tx_id,
2537                0x28ac65f9da3941d4,
2538                fidl::encoding::DynamicFlags::empty(),
2539            )
2540    }
2541}
2542
2543#[must_use = "FIDL methods require a response to be sent"]
2544#[derive(Debug)]
2545pub struct WlanFullmacImpl_QueryMacSublayerSupportResponder {
2546    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2547    tx_id: u32,
2548}
2549
2550/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
2551/// if the responder is dropped without sending a response, so that the client
2552/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2553impl std::ops::Drop for WlanFullmacImpl_QueryMacSublayerSupportResponder {
2554    fn drop(&mut self) {
2555        self.control_handle.shutdown();
2556        // Safety: drops once, never accessed again
2557        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2558    }
2559}
2560
2561impl fidl::endpoints::Responder for WlanFullmacImpl_QueryMacSublayerSupportResponder {
2562    type ControlHandle = WlanFullmacImpl_ControlHandle;
2563
2564    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2565        &self.control_handle
2566    }
2567
2568    fn drop_without_shutdown(mut self) {
2569        // Safety: drops once, never accessed again due to mem::forget
2570        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2571        // Prevent Drop from running (which would shut down the channel)
2572        std::mem::forget(self);
2573    }
2574}
2575
2576impl WlanFullmacImpl_QueryMacSublayerSupportResponder {
2577    /// Sends a response to the FIDL transaction.
2578    ///
2579    /// Sets the channel to shutdown if an error occurs.
2580    pub fn send(
2581        self,
2582        mut result: Result<&fidl_fuchsia_wlan_common::MacSublayerSupport, i32>,
2583    ) -> Result<(), fidl::Error> {
2584        let _result = self.send_raw(result);
2585        if _result.is_err() {
2586            self.control_handle.shutdown();
2587        }
2588        self.drop_without_shutdown();
2589        _result
2590    }
2591
2592    /// Similar to "send" but does not shutdown the channel if an error occurs.
2593    pub fn send_no_shutdown_on_err(
2594        self,
2595        mut result: Result<&fidl_fuchsia_wlan_common::MacSublayerSupport, i32>,
2596    ) -> Result<(), fidl::Error> {
2597        let _result = self.send_raw(result);
2598        self.drop_without_shutdown();
2599        _result
2600    }
2601
2602    fn send_raw(
2603        &self,
2604        mut result: Result<&fidl_fuchsia_wlan_common::MacSublayerSupport, i32>,
2605    ) -> Result<(), fidl::Error> {
2606        self.control_handle.inner.send::<fidl::encoding::ResultType<
2607            WlanFullmacImplQueryMacSublayerSupportResponse,
2608            i32,
2609        >>(
2610            result.map(|resp| (resp,)),
2611            self.tx_id,
2612            0x2f09187eb87d9bad,
2613            fidl::encoding::DynamicFlags::empty(),
2614        )
2615    }
2616}
2617
2618#[must_use = "FIDL methods require a response to be sent"]
2619#[derive(Debug)]
2620pub struct WlanFullmacImpl_QuerySecuritySupportResponder {
2621    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2622    tx_id: u32,
2623}
2624
2625/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
2626/// if the responder is dropped without sending a response, so that the client
2627/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2628impl std::ops::Drop for WlanFullmacImpl_QuerySecuritySupportResponder {
2629    fn drop(&mut self) {
2630        self.control_handle.shutdown();
2631        // Safety: drops once, never accessed again
2632        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2633    }
2634}
2635
2636impl fidl::endpoints::Responder for WlanFullmacImpl_QuerySecuritySupportResponder {
2637    type ControlHandle = WlanFullmacImpl_ControlHandle;
2638
2639    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2640        &self.control_handle
2641    }
2642
2643    fn drop_without_shutdown(mut self) {
2644        // Safety: drops once, never accessed again due to mem::forget
2645        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2646        // Prevent Drop from running (which would shut down the channel)
2647        std::mem::forget(self);
2648    }
2649}
2650
2651impl WlanFullmacImpl_QuerySecuritySupportResponder {
2652    /// Sends a response to the FIDL transaction.
2653    ///
2654    /// Sets the channel to shutdown if an error occurs.
2655    pub fn send(
2656        self,
2657        mut result: Result<&fidl_fuchsia_wlan_common::SecuritySupport, i32>,
2658    ) -> Result<(), fidl::Error> {
2659        let _result = self.send_raw(result);
2660        if _result.is_err() {
2661            self.control_handle.shutdown();
2662        }
2663        self.drop_without_shutdown();
2664        _result
2665    }
2666
2667    /// Similar to "send" but does not shutdown the channel if an error occurs.
2668    pub fn send_no_shutdown_on_err(
2669        self,
2670        mut result: Result<&fidl_fuchsia_wlan_common::SecuritySupport, i32>,
2671    ) -> Result<(), fidl::Error> {
2672        let _result = self.send_raw(result);
2673        self.drop_without_shutdown();
2674        _result
2675    }
2676
2677    fn send_raw(
2678        &self,
2679        mut result: Result<&fidl_fuchsia_wlan_common::SecuritySupport, i32>,
2680    ) -> Result<(), fidl::Error> {
2681        self.control_handle.inner.send::<fidl::encoding::ResultType<
2682            WlanFullmacImplQuerySecuritySupportResponse,
2683            i32,
2684        >>(
2685            result.map(|resp| (resp,)),
2686            self.tx_id,
2687            0x11cf3fa6eeb93f84,
2688            fidl::encoding::DynamicFlags::empty(),
2689        )
2690    }
2691}
2692
2693#[must_use = "FIDL methods require a response to be sent"]
2694#[derive(Debug)]
2695pub struct WlanFullmacImpl_QuerySpectrumManagementSupportResponder {
2696    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2697    tx_id: u32,
2698}
2699
2700/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
2701/// if the responder is dropped without sending a response, so that the client
2702/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2703impl std::ops::Drop for WlanFullmacImpl_QuerySpectrumManagementSupportResponder {
2704    fn drop(&mut self) {
2705        self.control_handle.shutdown();
2706        // Safety: drops once, never accessed again
2707        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2708    }
2709}
2710
2711impl fidl::endpoints::Responder for WlanFullmacImpl_QuerySpectrumManagementSupportResponder {
2712    type ControlHandle = WlanFullmacImpl_ControlHandle;
2713
2714    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2715        &self.control_handle
2716    }
2717
2718    fn drop_without_shutdown(mut self) {
2719        // Safety: drops once, never accessed again due to mem::forget
2720        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2721        // Prevent Drop from running (which would shut down the channel)
2722        std::mem::forget(self);
2723    }
2724}
2725
2726impl WlanFullmacImpl_QuerySpectrumManagementSupportResponder {
2727    /// Sends a response to the FIDL transaction.
2728    ///
2729    /// Sets the channel to shutdown if an error occurs.
2730    pub fn send(
2731        self,
2732        mut result: Result<&fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>,
2733    ) -> Result<(), fidl::Error> {
2734        let _result = self.send_raw(result);
2735        if _result.is_err() {
2736            self.control_handle.shutdown();
2737        }
2738        self.drop_without_shutdown();
2739        _result
2740    }
2741
2742    /// Similar to "send" but does not shutdown the channel if an error occurs.
2743    pub fn send_no_shutdown_on_err(
2744        self,
2745        mut result: Result<&fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>,
2746    ) -> Result<(), fidl::Error> {
2747        let _result = self.send_raw(result);
2748        self.drop_without_shutdown();
2749        _result
2750    }
2751
2752    fn send_raw(
2753        &self,
2754        mut result: Result<&fidl_fuchsia_wlan_common::SpectrumManagementSupport, i32>,
2755    ) -> Result<(), fidl::Error> {
2756        self.control_handle.inner.send::<fidl::encoding::ResultType<
2757            WlanFullmacImplQuerySpectrumManagementSupportResponse,
2758            i32,
2759        >>(
2760            result.map(|resp| (resp,)),
2761            self.tx_id,
2762            0x22ae7551d855b83a,
2763            fidl::encoding::DynamicFlags::empty(),
2764        )
2765    }
2766}
2767
2768#[must_use = "FIDL methods require a response to be sent"]
2769#[derive(Debug)]
2770pub struct WlanFullmacImpl_QueryTelemetrySupportResponder {
2771    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2772    tx_id: u32,
2773}
2774
2775/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
2776/// if the responder is dropped without sending a response, so that the client
2777/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2778impl std::ops::Drop for WlanFullmacImpl_QueryTelemetrySupportResponder {
2779    fn drop(&mut self) {
2780        self.control_handle.shutdown();
2781        // Safety: drops once, never accessed again
2782        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2783    }
2784}
2785
2786impl fidl::endpoints::Responder for WlanFullmacImpl_QueryTelemetrySupportResponder {
2787    type ControlHandle = WlanFullmacImpl_ControlHandle;
2788
2789    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2790        &self.control_handle
2791    }
2792
2793    fn drop_without_shutdown(mut self) {
2794        // Safety: drops once, never accessed again due to mem::forget
2795        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2796        // Prevent Drop from running (which would shut down the channel)
2797        std::mem::forget(self);
2798    }
2799}
2800
2801impl WlanFullmacImpl_QueryTelemetrySupportResponder {
2802    /// Sends a response to the FIDL transaction.
2803    ///
2804    /// Sets the channel to shutdown if an error occurs.
2805    pub fn send(
2806        self,
2807        mut result: Result<&fidl_fuchsia_wlan_stats::TelemetrySupport, i32>,
2808    ) -> Result<(), fidl::Error> {
2809        let _result = self.send_raw(result);
2810        if _result.is_err() {
2811            self.control_handle.shutdown();
2812        }
2813        self.drop_without_shutdown();
2814        _result
2815    }
2816
2817    /// Similar to "send" but does not shutdown the channel if an error occurs.
2818    pub fn send_no_shutdown_on_err(
2819        self,
2820        mut result: Result<&fidl_fuchsia_wlan_stats::TelemetrySupport, i32>,
2821    ) -> Result<(), fidl::Error> {
2822        let _result = self.send_raw(result);
2823        self.drop_without_shutdown();
2824        _result
2825    }
2826
2827    fn send_raw(
2828        &self,
2829        mut result: Result<&fidl_fuchsia_wlan_stats::TelemetrySupport, i32>,
2830    ) -> Result<(), fidl::Error> {
2831        self.control_handle.inner.send::<fidl::encoding::ResultType<
2832            WlanFullmacImplQueryTelemetrySupportResponse,
2833            i32,
2834        >>(
2835            result.map(|resp| (resp,)),
2836            self.tx_id,
2837            0x4561479ca560827f,
2838            fidl::encoding::DynamicFlags::empty(),
2839        )
2840    }
2841}
2842
2843#[must_use = "FIDL methods require a response to be sent"]
2844#[derive(Debug)]
2845pub struct WlanFullmacImpl_StartScanResponder {
2846    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2847    tx_id: u32,
2848}
2849
2850/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
2851/// if the responder is dropped without sending a response, so that the client
2852/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2853impl std::ops::Drop for WlanFullmacImpl_StartScanResponder {
2854    fn drop(&mut self) {
2855        self.control_handle.shutdown();
2856        // Safety: drops once, never accessed again
2857        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2858    }
2859}
2860
2861impl fidl::endpoints::Responder for WlanFullmacImpl_StartScanResponder {
2862    type ControlHandle = WlanFullmacImpl_ControlHandle;
2863
2864    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2865        &self.control_handle
2866    }
2867
2868    fn drop_without_shutdown(mut self) {
2869        // Safety: drops once, never accessed again due to mem::forget
2870        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2871        // Prevent Drop from running (which would shut down the channel)
2872        std::mem::forget(self);
2873    }
2874}
2875
2876impl WlanFullmacImpl_StartScanResponder {
2877    /// Sends a response to the FIDL transaction.
2878    ///
2879    /// Sets the channel to shutdown if an error occurs.
2880    pub fn send(self) -> Result<(), fidl::Error> {
2881        let _result = self.send_raw();
2882        if _result.is_err() {
2883            self.control_handle.shutdown();
2884        }
2885        self.drop_without_shutdown();
2886        _result
2887    }
2888
2889    /// Similar to "send" but does not shutdown the channel if an error occurs.
2890    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
2891        let _result = self.send_raw();
2892        self.drop_without_shutdown();
2893        _result
2894    }
2895
2896    fn send_raw(&self) -> Result<(), fidl::Error> {
2897        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
2898            (),
2899            self.tx_id,
2900            0x26c17bf595aa161c,
2901            fidl::encoding::DynamicFlags::empty(),
2902        )
2903    }
2904}
2905
2906#[must_use = "FIDL methods require a response to be sent"]
2907#[derive(Debug)]
2908pub struct WlanFullmacImpl_ConnectResponder {
2909    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2910    tx_id: u32,
2911}
2912
2913/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
2914/// if the responder is dropped without sending a response, so that the client
2915/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2916impl std::ops::Drop for WlanFullmacImpl_ConnectResponder {
2917    fn drop(&mut self) {
2918        self.control_handle.shutdown();
2919        // Safety: drops once, never accessed again
2920        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2921    }
2922}
2923
2924impl fidl::endpoints::Responder for WlanFullmacImpl_ConnectResponder {
2925    type ControlHandle = WlanFullmacImpl_ControlHandle;
2926
2927    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2928        &self.control_handle
2929    }
2930
2931    fn drop_without_shutdown(mut self) {
2932        // Safety: drops once, never accessed again due to mem::forget
2933        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2934        // Prevent Drop from running (which would shut down the channel)
2935        std::mem::forget(self);
2936    }
2937}
2938
2939impl WlanFullmacImpl_ConnectResponder {
2940    /// Sends a response to the FIDL transaction.
2941    ///
2942    /// Sets the channel to shutdown if an error occurs.
2943    pub fn send(self) -> Result<(), fidl::Error> {
2944        let _result = self.send_raw();
2945        if _result.is_err() {
2946            self.control_handle.shutdown();
2947        }
2948        self.drop_without_shutdown();
2949        _result
2950    }
2951
2952    /// Similar to "send" but does not shutdown the channel if an error occurs.
2953    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
2954        let _result = self.send_raw();
2955        self.drop_without_shutdown();
2956        _result
2957    }
2958
2959    fn send_raw(&self) -> Result<(), fidl::Error> {
2960        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
2961            (),
2962            self.tx_id,
2963            0x19eb0322efb07a76,
2964            fidl::encoding::DynamicFlags::empty(),
2965        )
2966    }
2967}
2968
2969#[must_use = "FIDL methods require a response to be sent"]
2970#[derive(Debug)]
2971pub struct WlanFullmacImpl_ReconnectResponder {
2972    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
2973    tx_id: u32,
2974}
2975
2976/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
2977/// if the responder is dropped without sending a response, so that the client
2978/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
2979impl std::ops::Drop for WlanFullmacImpl_ReconnectResponder {
2980    fn drop(&mut self) {
2981        self.control_handle.shutdown();
2982        // Safety: drops once, never accessed again
2983        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2984    }
2985}
2986
2987impl fidl::endpoints::Responder for WlanFullmacImpl_ReconnectResponder {
2988    type ControlHandle = WlanFullmacImpl_ControlHandle;
2989
2990    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
2991        &self.control_handle
2992    }
2993
2994    fn drop_without_shutdown(mut self) {
2995        // Safety: drops once, never accessed again due to mem::forget
2996        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
2997        // Prevent Drop from running (which would shut down the channel)
2998        std::mem::forget(self);
2999    }
3000}
3001
3002impl WlanFullmacImpl_ReconnectResponder {
3003    /// Sends a response to the FIDL transaction.
3004    ///
3005    /// Sets the channel to shutdown if an error occurs.
3006    pub fn send(self) -> Result<(), fidl::Error> {
3007        let _result = self.send_raw();
3008        if _result.is_err() {
3009            self.control_handle.shutdown();
3010        }
3011        self.drop_without_shutdown();
3012        _result
3013    }
3014
3015    /// Similar to "send" but does not shutdown the channel if an error occurs.
3016    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3017        let _result = self.send_raw();
3018        self.drop_without_shutdown();
3019        _result
3020    }
3021
3022    fn send_raw(&self) -> Result<(), fidl::Error> {
3023        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3024            (),
3025            self.tx_id,
3026            0x474084c4ef19ee71,
3027            fidl::encoding::DynamicFlags::empty(),
3028        )
3029    }
3030}
3031
3032#[must_use = "FIDL methods require a response to be sent"]
3033#[derive(Debug)]
3034pub struct WlanFullmacImpl_RoamResponder {
3035    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3036    tx_id: u32,
3037}
3038
3039/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3040/// if the responder is dropped without sending a response, so that the client
3041/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3042impl std::ops::Drop for WlanFullmacImpl_RoamResponder {
3043    fn drop(&mut self) {
3044        self.control_handle.shutdown();
3045        // Safety: drops once, never accessed again
3046        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3047    }
3048}
3049
3050impl fidl::endpoints::Responder for WlanFullmacImpl_RoamResponder {
3051    type ControlHandle = WlanFullmacImpl_ControlHandle;
3052
3053    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3054        &self.control_handle
3055    }
3056
3057    fn drop_without_shutdown(mut self) {
3058        // Safety: drops once, never accessed again due to mem::forget
3059        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3060        // Prevent Drop from running (which would shut down the channel)
3061        std::mem::forget(self);
3062    }
3063}
3064
3065impl WlanFullmacImpl_RoamResponder {
3066    /// Sends a response to the FIDL transaction.
3067    ///
3068    /// Sets the channel to shutdown if an error occurs.
3069    pub fn send(self) -> Result<(), fidl::Error> {
3070        let _result = self.send_raw();
3071        if _result.is_err() {
3072            self.control_handle.shutdown();
3073        }
3074        self.drop_without_shutdown();
3075        _result
3076    }
3077
3078    /// Similar to "send" but does not shutdown the channel if an error occurs.
3079    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3080        let _result = self.send_raw();
3081        self.drop_without_shutdown();
3082        _result
3083    }
3084
3085    fn send_raw(&self) -> Result<(), fidl::Error> {
3086        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3087            (),
3088            self.tx_id,
3089            0x1e35dcc98b124b64,
3090            fidl::encoding::DynamicFlags::empty(),
3091        )
3092    }
3093}
3094
3095#[must_use = "FIDL methods require a response to be sent"]
3096#[derive(Debug)]
3097pub struct WlanFullmacImpl_AuthRespResponder {
3098    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3099    tx_id: u32,
3100}
3101
3102/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3103/// if the responder is dropped without sending a response, so that the client
3104/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3105impl std::ops::Drop for WlanFullmacImpl_AuthRespResponder {
3106    fn drop(&mut self) {
3107        self.control_handle.shutdown();
3108        // Safety: drops once, never accessed again
3109        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3110    }
3111}
3112
3113impl fidl::endpoints::Responder for WlanFullmacImpl_AuthRespResponder {
3114    type ControlHandle = WlanFullmacImpl_ControlHandle;
3115
3116    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3117        &self.control_handle
3118    }
3119
3120    fn drop_without_shutdown(mut self) {
3121        // Safety: drops once, never accessed again due to mem::forget
3122        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3123        // Prevent Drop from running (which would shut down the channel)
3124        std::mem::forget(self);
3125    }
3126}
3127
3128impl WlanFullmacImpl_AuthRespResponder {
3129    /// Sends a response to the FIDL transaction.
3130    ///
3131    /// Sets the channel to shutdown if an error occurs.
3132    pub fn send(self) -> Result<(), fidl::Error> {
3133        let _result = self.send_raw();
3134        if _result.is_err() {
3135            self.control_handle.shutdown();
3136        }
3137        self.drop_without_shutdown();
3138        _result
3139    }
3140
3141    /// Similar to "send" but does not shutdown the channel if an error occurs.
3142    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3143        let _result = self.send_raw();
3144        self.drop_without_shutdown();
3145        _result
3146    }
3147
3148    fn send_raw(&self) -> Result<(), fidl::Error> {
3149        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3150            (),
3151            self.tx_id,
3152            0x5f7ea24b44a4aaeb,
3153            fidl::encoding::DynamicFlags::empty(),
3154        )
3155    }
3156}
3157
3158#[must_use = "FIDL methods require a response to be sent"]
3159#[derive(Debug)]
3160pub struct WlanFullmacImpl_DeauthResponder {
3161    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3162    tx_id: u32,
3163}
3164
3165/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3166/// if the responder is dropped without sending a response, so that the client
3167/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3168impl std::ops::Drop for WlanFullmacImpl_DeauthResponder {
3169    fn drop(&mut self) {
3170        self.control_handle.shutdown();
3171        // Safety: drops once, never accessed again
3172        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3173    }
3174}
3175
3176impl fidl::endpoints::Responder for WlanFullmacImpl_DeauthResponder {
3177    type ControlHandle = WlanFullmacImpl_ControlHandle;
3178
3179    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3180        &self.control_handle
3181    }
3182
3183    fn drop_without_shutdown(mut self) {
3184        // Safety: drops once, never accessed again due to mem::forget
3185        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3186        // Prevent Drop from running (which would shut down the channel)
3187        std::mem::forget(self);
3188    }
3189}
3190
3191impl WlanFullmacImpl_DeauthResponder {
3192    /// Sends a response to the FIDL transaction.
3193    ///
3194    /// Sets the channel to shutdown if an error occurs.
3195    pub fn send(self) -> Result<(), fidl::Error> {
3196        let _result = self.send_raw();
3197        if _result.is_err() {
3198            self.control_handle.shutdown();
3199        }
3200        self.drop_without_shutdown();
3201        _result
3202    }
3203
3204    /// Similar to "send" but does not shutdown the channel if an error occurs.
3205    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3206        let _result = self.send_raw();
3207        self.drop_without_shutdown();
3208        _result
3209    }
3210
3211    fn send_raw(&self) -> Result<(), fidl::Error> {
3212        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3213            (),
3214            self.tx_id,
3215            0x112786eccbf12f37,
3216            fidl::encoding::DynamicFlags::empty(),
3217        )
3218    }
3219}
3220
3221#[must_use = "FIDL methods require a response to be sent"]
3222#[derive(Debug)]
3223pub struct WlanFullmacImpl_AssocRespResponder {
3224    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3225    tx_id: u32,
3226}
3227
3228/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3229/// if the responder is dropped without sending a response, so that the client
3230/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3231impl std::ops::Drop for WlanFullmacImpl_AssocRespResponder {
3232    fn drop(&mut self) {
3233        self.control_handle.shutdown();
3234        // Safety: drops once, never accessed again
3235        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3236    }
3237}
3238
3239impl fidl::endpoints::Responder for WlanFullmacImpl_AssocRespResponder {
3240    type ControlHandle = WlanFullmacImpl_ControlHandle;
3241
3242    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3243        &self.control_handle
3244    }
3245
3246    fn drop_without_shutdown(mut self) {
3247        // Safety: drops once, never accessed again due to mem::forget
3248        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3249        // Prevent Drop from running (which would shut down the channel)
3250        std::mem::forget(self);
3251    }
3252}
3253
3254impl WlanFullmacImpl_AssocRespResponder {
3255    /// Sends a response to the FIDL transaction.
3256    ///
3257    /// Sets the channel to shutdown if an error occurs.
3258    pub fn send(self) -> Result<(), fidl::Error> {
3259        let _result = self.send_raw();
3260        if _result.is_err() {
3261            self.control_handle.shutdown();
3262        }
3263        self.drop_without_shutdown();
3264        _result
3265    }
3266
3267    /// Similar to "send" but does not shutdown the channel if an error occurs.
3268    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3269        let _result = self.send_raw();
3270        self.drop_without_shutdown();
3271        _result
3272    }
3273
3274    fn send_raw(&self) -> Result<(), fidl::Error> {
3275        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3276            (),
3277            self.tx_id,
3278            0x5022ce6b8eefec2f,
3279            fidl::encoding::DynamicFlags::empty(),
3280        )
3281    }
3282}
3283
3284#[must_use = "FIDL methods require a response to be sent"]
3285#[derive(Debug)]
3286pub struct WlanFullmacImpl_DisassocResponder {
3287    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3288    tx_id: u32,
3289}
3290
3291/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3292/// if the responder is dropped without sending a response, so that the client
3293/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3294impl std::ops::Drop for WlanFullmacImpl_DisassocResponder {
3295    fn drop(&mut self) {
3296        self.control_handle.shutdown();
3297        // Safety: drops once, never accessed again
3298        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3299    }
3300}
3301
3302impl fidl::endpoints::Responder for WlanFullmacImpl_DisassocResponder {
3303    type ControlHandle = WlanFullmacImpl_ControlHandle;
3304
3305    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3306        &self.control_handle
3307    }
3308
3309    fn drop_without_shutdown(mut self) {
3310        // Safety: drops once, never accessed again due to mem::forget
3311        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3312        // Prevent Drop from running (which would shut down the channel)
3313        std::mem::forget(self);
3314    }
3315}
3316
3317impl WlanFullmacImpl_DisassocResponder {
3318    /// Sends a response to the FIDL transaction.
3319    ///
3320    /// Sets the channel to shutdown if an error occurs.
3321    pub fn send(self) -> Result<(), fidl::Error> {
3322        let _result = self.send_raw();
3323        if _result.is_err() {
3324            self.control_handle.shutdown();
3325        }
3326        self.drop_without_shutdown();
3327        _result
3328    }
3329
3330    /// Similar to "send" but does not shutdown the channel if an error occurs.
3331    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3332        let _result = self.send_raw();
3333        self.drop_without_shutdown();
3334        _result
3335    }
3336
3337    fn send_raw(&self) -> Result<(), fidl::Error> {
3338        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3339            (),
3340            self.tx_id,
3341            0x9c0fc4e8de53e01,
3342            fidl::encoding::DynamicFlags::empty(),
3343        )
3344    }
3345}
3346
3347#[must_use = "FIDL methods require a response to be sent"]
3348#[derive(Debug)]
3349pub struct WlanFullmacImpl_StartBssResponder {
3350    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3351    tx_id: u32,
3352}
3353
3354/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3355/// if the responder is dropped without sending a response, so that the client
3356/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3357impl std::ops::Drop for WlanFullmacImpl_StartBssResponder {
3358    fn drop(&mut self) {
3359        self.control_handle.shutdown();
3360        // Safety: drops once, never accessed again
3361        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3362    }
3363}
3364
3365impl fidl::endpoints::Responder for WlanFullmacImpl_StartBssResponder {
3366    type ControlHandle = WlanFullmacImpl_ControlHandle;
3367
3368    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3369        &self.control_handle
3370    }
3371
3372    fn drop_without_shutdown(mut self) {
3373        // Safety: drops once, never accessed again due to mem::forget
3374        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3375        // Prevent Drop from running (which would shut down the channel)
3376        std::mem::forget(self);
3377    }
3378}
3379
3380impl WlanFullmacImpl_StartBssResponder {
3381    /// Sends a response to the FIDL transaction.
3382    ///
3383    /// Sets the channel to shutdown if an error occurs.
3384    pub fn send(self) -> Result<(), fidl::Error> {
3385        let _result = self.send_raw();
3386        if _result.is_err() {
3387            self.control_handle.shutdown();
3388        }
3389        self.drop_without_shutdown();
3390        _result
3391    }
3392
3393    /// Similar to "send" but does not shutdown the channel if an error occurs.
3394    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3395        let _result = self.send_raw();
3396        self.drop_without_shutdown();
3397        _result
3398    }
3399
3400    fn send_raw(&self) -> Result<(), fidl::Error> {
3401        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3402            (),
3403            self.tx_id,
3404            0x6922644d6b1d341d,
3405            fidl::encoding::DynamicFlags::empty(),
3406        )
3407    }
3408}
3409
3410#[must_use = "FIDL methods require a response to be sent"]
3411#[derive(Debug)]
3412pub struct WlanFullmacImpl_StopBssResponder {
3413    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3414    tx_id: u32,
3415}
3416
3417/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3418/// if the responder is dropped without sending a response, so that the client
3419/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3420impl std::ops::Drop for WlanFullmacImpl_StopBssResponder {
3421    fn drop(&mut self) {
3422        self.control_handle.shutdown();
3423        // Safety: drops once, never accessed again
3424        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3425    }
3426}
3427
3428impl fidl::endpoints::Responder for WlanFullmacImpl_StopBssResponder {
3429    type ControlHandle = WlanFullmacImpl_ControlHandle;
3430
3431    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3432        &self.control_handle
3433    }
3434
3435    fn drop_without_shutdown(mut self) {
3436        // Safety: drops once, never accessed again due to mem::forget
3437        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3438        // Prevent Drop from running (which would shut down the channel)
3439        std::mem::forget(self);
3440    }
3441}
3442
3443impl WlanFullmacImpl_StopBssResponder {
3444    /// Sends a response to the FIDL transaction.
3445    ///
3446    /// Sets the channel to shutdown if an error occurs.
3447    pub fn send(self) -> Result<(), fidl::Error> {
3448        let _result = self.send_raw();
3449        if _result.is_err() {
3450            self.control_handle.shutdown();
3451        }
3452        self.drop_without_shutdown();
3453        _result
3454    }
3455
3456    /// Similar to "send" but does not shutdown the channel if an error occurs.
3457    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3458        let _result = self.send_raw();
3459        self.drop_without_shutdown();
3460        _result
3461    }
3462
3463    fn send_raw(&self) -> Result<(), fidl::Error> {
3464        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3465            (),
3466            self.tx_id,
3467            0x5aeb9b72e7575268,
3468            fidl::encoding::DynamicFlags::empty(),
3469        )
3470    }
3471}
3472
3473#[must_use = "FIDL methods require a response to be sent"]
3474#[derive(Debug)]
3475pub struct WlanFullmacImpl_SetKeysResponder {
3476    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3477    tx_id: u32,
3478}
3479
3480/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3481/// if the responder is dropped without sending a response, so that the client
3482/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3483impl std::ops::Drop for WlanFullmacImpl_SetKeysResponder {
3484    fn drop(&mut self) {
3485        self.control_handle.shutdown();
3486        // Safety: drops once, never accessed again
3487        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3488    }
3489}
3490
3491impl fidl::endpoints::Responder for WlanFullmacImpl_SetKeysResponder {
3492    type ControlHandle = WlanFullmacImpl_ControlHandle;
3493
3494    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3495        &self.control_handle
3496    }
3497
3498    fn drop_without_shutdown(mut self) {
3499        // Safety: drops once, never accessed again due to mem::forget
3500        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3501        // Prevent Drop from running (which would shut down the channel)
3502        std::mem::forget(self);
3503    }
3504}
3505
3506impl WlanFullmacImpl_SetKeysResponder {
3507    /// Sends a response to the FIDL transaction.
3508    ///
3509    /// Sets the channel to shutdown if an error occurs.
3510    pub fn send(self, mut resp: &WlanFullmacSetKeysResp) -> Result<(), fidl::Error> {
3511        let _result = self.send_raw(resp);
3512        if _result.is_err() {
3513            self.control_handle.shutdown();
3514        }
3515        self.drop_without_shutdown();
3516        _result
3517    }
3518
3519    /// Similar to "send" but does not shutdown the channel if an error occurs.
3520    pub fn send_no_shutdown_on_err(
3521        self,
3522        mut resp: &WlanFullmacSetKeysResp,
3523    ) -> Result<(), fidl::Error> {
3524        let _result = self.send_raw(resp);
3525        self.drop_without_shutdown();
3526        _result
3527    }
3528
3529    fn send_raw(&self, mut resp: &WlanFullmacSetKeysResp) -> Result<(), fidl::Error> {
3530        self.control_handle.inner.send::<WlanFullmacImplSetKeysResponse>(
3531            (resp,),
3532            self.tx_id,
3533            0x20f46b1e039f0985,
3534            fidl::encoding::DynamicFlags::empty(),
3535        )
3536    }
3537}
3538
3539#[must_use = "FIDL methods require a response to be sent"]
3540#[derive(Debug)]
3541pub struct WlanFullmacImpl_EapolTxResponder {
3542    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3543    tx_id: u32,
3544}
3545
3546/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3547/// if the responder is dropped without sending a response, so that the client
3548/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3549impl std::ops::Drop for WlanFullmacImpl_EapolTxResponder {
3550    fn drop(&mut self) {
3551        self.control_handle.shutdown();
3552        // Safety: drops once, never accessed again
3553        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3554    }
3555}
3556
3557impl fidl::endpoints::Responder for WlanFullmacImpl_EapolTxResponder {
3558    type ControlHandle = WlanFullmacImpl_ControlHandle;
3559
3560    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3561        &self.control_handle
3562    }
3563
3564    fn drop_without_shutdown(mut self) {
3565        // Safety: drops once, never accessed again due to mem::forget
3566        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3567        // Prevent Drop from running (which would shut down the channel)
3568        std::mem::forget(self);
3569    }
3570}
3571
3572impl WlanFullmacImpl_EapolTxResponder {
3573    /// Sends a response to the FIDL transaction.
3574    ///
3575    /// Sets the channel to shutdown if an error occurs.
3576    pub fn send(self) -> Result<(), fidl::Error> {
3577        let _result = self.send_raw();
3578        if _result.is_err() {
3579            self.control_handle.shutdown();
3580        }
3581        self.drop_without_shutdown();
3582        _result
3583    }
3584
3585    /// Similar to "send" but does not shutdown the channel if an error occurs.
3586    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3587        let _result = self.send_raw();
3588        self.drop_without_shutdown();
3589        _result
3590    }
3591
3592    fn send_raw(&self) -> Result<(), fidl::Error> {
3593        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3594            (),
3595            self.tx_id,
3596            0x529a2d90fd4c8177,
3597            fidl::encoding::DynamicFlags::empty(),
3598        )
3599    }
3600}
3601
3602#[must_use = "FIDL methods require a response to be sent"]
3603#[derive(Debug)]
3604pub struct WlanFullmacImpl_GetIfaceCounterStatsResponder {
3605    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3606    tx_id: u32,
3607}
3608
3609/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3610/// if the responder is dropped without sending a response, so that the client
3611/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3612impl std::ops::Drop for WlanFullmacImpl_GetIfaceCounterStatsResponder {
3613    fn drop(&mut self) {
3614        self.control_handle.shutdown();
3615        // Safety: drops once, never accessed again
3616        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3617    }
3618}
3619
3620impl fidl::endpoints::Responder for WlanFullmacImpl_GetIfaceCounterStatsResponder {
3621    type ControlHandle = WlanFullmacImpl_ControlHandle;
3622
3623    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3624        &self.control_handle
3625    }
3626
3627    fn drop_without_shutdown(mut self) {
3628        // Safety: drops once, never accessed again due to mem::forget
3629        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3630        // Prevent Drop from running (which would shut down the channel)
3631        std::mem::forget(self);
3632    }
3633}
3634
3635impl WlanFullmacImpl_GetIfaceCounterStatsResponder {
3636    /// Sends a response to the FIDL transaction.
3637    ///
3638    /// Sets the channel to shutdown if an error occurs.
3639    pub fn send(
3640        self,
3641        mut result: Result<&fidl_fuchsia_wlan_stats::IfaceCounterStats, i32>,
3642    ) -> Result<(), fidl::Error> {
3643        let _result = self.send_raw(result);
3644        if _result.is_err() {
3645            self.control_handle.shutdown();
3646        }
3647        self.drop_without_shutdown();
3648        _result
3649    }
3650
3651    /// Similar to "send" but does not shutdown the channel if an error occurs.
3652    pub fn send_no_shutdown_on_err(
3653        self,
3654        mut result: Result<&fidl_fuchsia_wlan_stats::IfaceCounterStats, i32>,
3655    ) -> Result<(), fidl::Error> {
3656        let _result = self.send_raw(result);
3657        self.drop_without_shutdown();
3658        _result
3659    }
3660
3661    fn send_raw(
3662        &self,
3663        mut result: Result<&fidl_fuchsia_wlan_stats::IfaceCounterStats, i32>,
3664    ) -> Result<(), fidl::Error> {
3665        self.control_handle.inner.send::<fidl::encoding::ResultType<
3666            WlanFullmacImplGetIfaceCounterStatsResponse,
3667            i32,
3668        >>(
3669            result.map(|stats| (stats,)),
3670            self.tx_id,
3671            0x6b640d6c69c99225,
3672            fidl::encoding::DynamicFlags::empty(),
3673        )
3674    }
3675}
3676
3677#[must_use = "FIDL methods require a response to be sent"]
3678#[derive(Debug)]
3679pub struct WlanFullmacImpl_GetIfaceHistogramStatsResponder {
3680    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3681    tx_id: u32,
3682}
3683
3684/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3685/// if the responder is dropped without sending a response, so that the client
3686/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3687impl std::ops::Drop for WlanFullmacImpl_GetIfaceHistogramStatsResponder {
3688    fn drop(&mut self) {
3689        self.control_handle.shutdown();
3690        // Safety: drops once, never accessed again
3691        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3692    }
3693}
3694
3695impl fidl::endpoints::Responder for WlanFullmacImpl_GetIfaceHistogramStatsResponder {
3696    type ControlHandle = WlanFullmacImpl_ControlHandle;
3697
3698    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3699        &self.control_handle
3700    }
3701
3702    fn drop_without_shutdown(mut self) {
3703        // Safety: drops once, never accessed again due to mem::forget
3704        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3705        // Prevent Drop from running (which would shut down the channel)
3706        std::mem::forget(self);
3707    }
3708}
3709
3710impl WlanFullmacImpl_GetIfaceHistogramStatsResponder {
3711    /// Sends a response to the FIDL transaction.
3712    ///
3713    /// Sets the channel to shutdown if an error occurs.
3714    pub fn send(
3715        self,
3716        mut result: Result<&fidl_fuchsia_wlan_stats::IfaceHistogramStats, i32>,
3717    ) -> Result<(), fidl::Error> {
3718        let _result = self.send_raw(result);
3719        if _result.is_err() {
3720            self.control_handle.shutdown();
3721        }
3722        self.drop_without_shutdown();
3723        _result
3724    }
3725
3726    /// Similar to "send" but does not shutdown the channel if an error occurs.
3727    pub fn send_no_shutdown_on_err(
3728        self,
3729        mut result: Result<&fidl_fuchsia_wlan_stats::IfaceHistogramStats, i32>,
3730    ) -> Result<(), fidl::Error> {
3731        let _result = self.send_raw(result);
3732        self.drop_without_shutdown();
3733        _result
3734    }
3735
3736    fn send_raw(
3737        &self,
3738        mut result: Result<&fidl_fuchsia_wlan_stats::IfaceHistogramStats, i32>,
3739    ) -> Result<(), fidl::Error> {
3740        self.control_handle.inner.send::<fidl::encoding::ResultType<
3741            WlanFullmacImplGetIfaceHistogramStatsResponse,
3742            i32,
3743        >>(
3744            result.map(|stats| (stats,)),
3745            self.tx_id,
3746            0x503d586f30ccf2cd,
3747            fidl::encoding::DynamicFlags::empty(),
3748        )
3749    }
3750}
3751
3752#[must_use = "FIDL methods require a response to be sent"]
3753#[derive(Debug)]
3754pub struct WlanFullmacImpl_SaeHandshakeRespResponder {
3755    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3756    tx_id: u32,
3757}
3758
3759/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3760/// if the responder is dropped without sending a response, so that the client
3761/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3762impl std::ops::Drop for WlanFullmacImpl_SaeHandshakeRespResponder {
3763    fn drop(&mut self) {
3764        self.control_handle.shutdown();
3765        // Safety: drops once, never accessed again
3766        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3767    }
3768}
3769
3770impl fidl::endpoints::Responder for WlanFullmacImpl_SaeHandshakeRespResponder {
3771    type ControlHandle = WlanFullmacImpl_ControlHandle;
3772
3773    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3774        &self.control_handle
3775    }
3776
3777    fn drop_without_shutdown(mut self) {
3778        // Safety: drops once, never accessed again due to mem::forget
3779        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3780        // Prevent Drop from running (which would shut down the channel)
3781        std::mem::forget(self);
3782    }
3783}
3784
3785impl WlanFullmacImpl_SaeHandshakeRespResponder {
3786    /// Sends a response to the FIDL transaction.
3787    ///
3788    /// Sets the channel to shutdown if an error occurs.
3789    pub fn send(self) -> Result<(), fidl::Error> {
3790        let _result = self.send_raw();
3791        if _result.is_err() {
3792            self.control_handle.shutdown();
3793        }
3794        self.drop_without_shutdown();
3795        _result
3796    }
3797
3798    /// Similar to "send" but does not shutdown the channel if an error occurs.
3799    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3800        let _result = self.send_raw();
3801        self.drop_without_shutdown();
3802        _result
3803    }
3804
3805    fn send_raw(&self) -> Result<(), fidl::Error> {
3806        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3807            (),
3808            self.tx_id,
3809            0x72cd3a31ae5a54f6,
3810            fidl::encoding::DynamicFlags::empty(),
3811        )
3812    }
3813}
3814
3815#[must_use = "FIDL methods require a response to be sent"]
3816#[derive(Debug)]
3817pub struct WlanFullmacImpl_SaeFrameTxResponder {
3818    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3819    tx_id: u32,
3820}
3821
3822/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3823/// if the responder is dropped without sending a response, so that the client
3824/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3825impl std::ops::Drop for WlanFullmacImpl_SaeFrameTxResponder {
3826    fn drop(&mut self) {
3827        self.control_handle.shutdown();
3828        // Safety: drops once, never accessed again
3829        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3830    }
3831}
3832
3833impl fidl::endpoints::Responder for WlanFullmacImpl_SaeFrameTxResponder {
3834    type ControlHandle = WlanFullmacImpl_ControlHandle;
3835
3836    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3837        &self.control_handle
3838    }
3839
3840    fn drop_without_shutdown(mut self) {
3841        // Safety: drops once, never accessed again due to mem::forget
3842        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3843        // Prevent Drop from running (which would shut down the channel)
3844        std::mem::forget(self);
3845    }
3846}
3847
3848impl WlanFullmacImpl_SaeFrameTxResponder {
3849    /// Sends a response to the FIDL transaction.
3850    ///
3851    /// Sets the channel to shutdown if an error occurs.
3852    pub fn send(self) -> Result<(), fidl::Error> {
3853        let _result = self.send_raw();
3854        if _result.is_err() {
3855            self.control_handle.shutdown();
3856        }
3857        self.drop_without_shutdown();
3858        _result
3859    }
3860
3861    /// Similar to "send" but does not shutdown the channel if an error occurs.
3862    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3863        let _result = self.send_raw();
3864        self.drop_without_shutdown();
3865        _result
3866    }
3867
3868    fn send_raw(&self) -> Result<(), fidl::Error> {
3869        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3870            (),
3871            self.tx_id,
3872            0x4715ad5dc5a6340f,
3873            fidl::encoding::DynamicFlags::empty(),
3874        )
3875    }
3876}
3877
3878#[must_use = "FIDL methods require a response to be sent"]
3879#[derive(Debug)]
3880pub struct WlanFullmacImpl_WmmStatusReqResponder {
3881    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3882    tx_id: u32,
3883}
3884
3885/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3886/// if the responder is dropped without sending a response, so that the client
3887/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3888impl std::ops::Drop for WlanFullmacImpl_WmmStatusReqResponder {
3889    fn drop(&mut self) {
3890        self.control_handle.shutdown();
3891        // Safety: drops once, never accessed again
3892        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3893    }
3894}
3895
3896impl fidl::endpoints::Responder for WlanFullmacImpl_WmmStatusReqResponder {
3897    type ControlHandle = WlanFullmacImpl_ControlHandle;
3898
3899    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3900        &self.control_handle
3901    }
3902
3903    fn drop_without_shutdown(mut self) {
3904        // Safety: drops once, never accessed again due to mem::forget
3905        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3906        // Prevent Drop from running (which would shut down the channel)
3907        std::mem::forget(self);
3908    }
3909}
3910
3911impl WlanFullmacImpl_WmmStatusReqResponder {
3912    /// Sends a response to the FIDL transaction.
3913    ///
3914    /// Sets the channel to shutdown if an error occurs.
3915    pub fn send(self) -> Result<(), fidl::Error> {
3916        let _result = self.send_raw();
3917        if _result.is_err() {
3918            self.control_handle.shutdown();
3919        }
3920        self.drop_without_shutdown();
3921        _result
3922    }
3923
3924    /// Similar to "send" but does not shutdown the channel if an error occurs.
3925    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3926        let _result = self.send_raw();
3927        self.drop_without_shutdown();
3928        _result
3929    }
3930
3931    fn send_raw(&self) -> Result<(), fidl::Error> {
3932        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3933            (),
3934            self.tx_id,
3935            0x635ecef3beb7a059,
3936            fidl::encoding::DynamicFlags::empty(),
3937        )
3938    }
3939}
3940
3941#[must_use = "FIDL methods require a response to be sent"]
3942#[derive(Debug)]
3943pub struct WlanFullmacImpl_OnLinkStateChangedResponder {
3944    control_handle: std::mem::ManuallyDrop<WlanFullmacImpl_ControlHandle>,
3945    tx_id: u32,
3946}
3947
3948/// Set the the channel to be shutdown (see [`WlanFullmacImpl_ControlHandle::shutdown`])
3949/// if the responder is dropped without sending a response, so that the client
3950/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3951impl std::ops::Drop for WlanFullmacImpl_OnLinkStateChangedResponder {
3952    fn drop(&mut self) {
3953        self.control_handle.shutdown();
3954        // Safety: drops once, never accessed again
3955        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3956    }
3957}
3958
3959impl fidl::endpoints::Responder for WlanFullmacImpl_OnLinkStateChangedResponder {
3960    type ControlHandle = WlanFullmacImpl_ControlHandle;
3961
3962    fn control_handle(&self) -> &WlanFullmacImpl_ControlHandle {
3963        &self.control_handle
3964    }
3965
3966    fn drop_without_shutdown(mut self) {
3967        // Safety: drops once, never accessed again due to mem::forget
3968        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3969        // Prevent Drop from running (which would shut down the channel)
3970        std::mem::forget(self);
3971    }
3972}
3973
3974impl WlanFullmacImpl_OnLinkStateChangedResponder {
3975    /// Sends a response to the FIDL transaction.
3976    ///
3977    /// Sets the channel to shutdown if an error occurs.
3978    pub fn send(self) -> Result<(), fidl::Error> {
3979        let _result = self.send_raw();
3980        if _result.is_err() {
3981            self.control_handle.shutdown();
3982        }
3983        self.drop_without_shutdown();
3984        _result
3985    }
3986
3987    /// Similar to "send" but does not shutdown the channel if an error occurs.
3988    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
3989        let _result = self.send_raw();
3990        self.drop_without_shutdown();
3991        _result
3992    }
3993
3994    fn send_raw(&self) -> Result<(), fidl::Error> {
3995        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
3996            (),
3997            self.tx_id,
3998            0x4d896e5b68e488d7,
3999            fidl::encoding::DynamicFlags::empty(),
4000        )
4001    }
4002}
4003
4004#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
4005pub struct WlanFullmacImplIfcMarker;
4006
4007impl fidl::endpoints::ProtocolMarker for WlanFullmacImplIfcMarker {
4008    type Proxy = WlanFullmacImplIfcProxy;
4009    type RequestStream = WlanFullmacImplIfcRequestStream;
4010    #[cfg(target_os = "fuchsia")]
4011    type SynchronousProxy = WlanFullmacImplIfcSynchronousProxy;
4012
4013    const DEBUG_NAME: &'static str = "fuchsia.wlan.fullmac.WlanFullmacImplIfc";
4014}
4015impl fidl::endpoints::DiscoverableProtocolMarker for WlanFullmacImplIfcMarker {}
4016
4017pub trait WlanFullmacImplIfcProxyInterface: Send + Sync {
4018    type OnScanResultResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4019    fn r#on_scan_result(
4020        &self,
4021        payload: &WlanFullmacImplIfcOnScanResultRequest,
4022    ) -> Self::OnScanResultResponseFut;
4023    type OnScanEndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4024    fn r#on_scan_end(
4025        &self,
4026        payload: &WlanFullmacImplIfcOnScanEndRequest,
4027    ) -> Self::OnScanEndResponseFut;
4028    type ConnectConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4029    fn r#connect_conf(
4030        &self,
4031        payload: &WlanFullmacImplIfcConnectConfRequest,
4032    ) -> Self::ConnectConfResponseFut;
4033    type RoamConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4034    fn r#roam_conf(&self, payload: &WlanFullmacImplIfcRoamConfRequest)
4035        -> Self::RoamConfResponseFut;
4036    type RoamStartIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4037    fn r#roam_start_ind(
4038        &self,
4039        payload: &WlanFullmacImplIfcRoamStartIndRequest,
4040    ) -> Self::RoamStartIndResponseFut;
4041    type RoamResultIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4042    fn r#roam_result_ind(
4043        &self,
4044        payload: &WlanFullmacImplIfcRoamResultIndRequest,
4045    ) -> Self::RoamResultIndResponseFut;
4046    type AuthIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4047    fn r#auth_ind(&self, payload: &WlanFullmacImplIfcAuthIndRequest) -> Self::AuthIndResponseFut;
4048    type DeauthConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4049    fn r#deauth_conf(
4050        &self,
4051        payload: &WlanFullmacImplIfcDeauthConfRequest,
4052    ) -> Self::DeauthConfResponseFut;
4053    type DeauthIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4054    fn r#deauth_ind(
4055        &self,
4056        payload: &WlanFullmacImplIfcDeauthIndRequest,
4057    ) -> Self::DeauthIndResponseFut;
4058    type AssocIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4059    fn r#assoc_ind(&self, payload: &WlanFullmacImplIfcAssocIndRequest)
4060        -> Self::AssocIndResponseFut;
4061    type DisassocConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4062    fn r#disassoc_conf(
4063        &self,
4064        payload: &WlanFullmacImplIfcDisassocConfRequest,
4065    ) -> Self::DisassocConfResponseFut;
4066    type DisassocIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4067    fn r#disassoc_ind(
4068        &self,
4069        payload: &WlanFullmacImplIfcDisassocIndRequest,
4070    ) -> Self::DisassocIndResponseFut;
4071    type StartConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4072    fn r#start_conf(
4073        &self,
4074        payload: &WlanFullmacImplIfcStartConfRequest,
4075    ) -> Self::StartConfResponseFut;
4076    type StopConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4077    fn r#stop_conf(&self, payload: &WlanFullmacImplIfcStopConfRequest)
4078        -> Self::StopConfResponseFut;
4079    type EapolConfResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4080    fn r#eapol_conf(
4081        &self,
4082        payload: &WlanFullmacImplIfcEapolConfRequest,
4083    ) -> Self::EapolConfResponseFut;
4084    type OnChannelSwitchResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4085    fn r#on_channel_switch(
4086        &self,
4087        ind: &WlanFullmacChannelSwitchInfo,
4088    ) -> Self::OnChannelSwitchResponseFut;
4089    type SignalReportResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4090    fn r#signal_report(
4091        &self,
4092        ind: &WlanFullmacSignalReportIndication,
4093    ) -> Self::SignalReportResponseFut;
4094    type EapolIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4095    fn r#eapol_ind(&self, payload: &WlanFullmacImplIfcEapolIndRequest)
4096        -> Self::EapolIndResponseFut;
4097    type OnPmkAvailableResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4098    fn r#on_pmk_available(
4099        &self,
4100        payload: &WlanFullmacImplIfcOnPmkAvailableRequest,
4101    ) -> Self::OnPmkAvailableResponseFut;
4102    type SaeHandshakeIndResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4103    fn r#sae_handshake_ind(
4104        &self,
4105        payload: &WlanFullmacImplIfcSaeHandshakeIndRequest,
4106    ) -> Self::SaeHandshakeIndResponseFut;
4107    type SaeFrameRxResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4108    fn r#sae_frame_rx(&self, frame: &SaeFrame) -> Self::SaeFrameRxResponseFut;
4109    type OnWmmStatusRespResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
4110    fn r#on_wmm_status_resp(
4111        &self,
4112        status: i32,
4113        wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
4114    ) -> Self::OnWmmStatusRespResponseFut;
4115}
4116#[derive(Debug)]
4117#[cfg(target_os = "fuchsia")]
4118pub struct WlanFullmacImplIfcSynchronousProxy {
4119    client: fidl::client::sync::Client,
4120}
4121
4122#[cfg(target_os = "fuchsia")]
4123impl fidl::endpoints::SynchronousProxy for WlanFullmacImplIfcSynchronousProxy {
4124    type Proxy = WlanFullmacImplIfcProxy;
4125    type Protocol = WlanFullmacImplIfcMarker;
4126
4127    fn from_channel(inner: fidl::Channel) -> Self {
4128        Self::new(inner)
4129    }
4130
4131    fn into_channel(self) -> fidl::Channel {
4132        self.client.into_channel()
4133    }
4134
4135    fn as_channel(&self) -> &fidl::Channel {
4136        self.client.as_channel()
4137    }
4138}
4139
4140#[cfg(target_os = "fuchsia")]
4141impl WlanFullmacImplIfcSynchronousProxy {
4142    pub fn new(channel: fidl::Channel) -> Self {
4143        let protocol_name =
4144            <WlanFullmacImplIfcMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
4145        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
4146    }
4147
4148    pub fn into_channel(self) -> fidl::Channel {
4149        self.client.into_channel()
4150    }
4151
4152    /// Waits until an event arrives and returns it. It is safe for other
4153    /// threads to make concurrent requests while waiting for an event.
4154    pub fn wait_for_event(
4155        &self,
4156        deadline: zx::MonotonicInstant,
4157    ) -> Result<WlanFullmacImplIfcEvent, fidl::Error> {
4158        WlanFullmacImplIfcEvent::decode(self.client.wait_for_event(deadline)?)
4159    }
4160
4161    pub fn r#on_scan_result(
4162        &self,
4163        mut payload: &WlanFullmacImplIfcOnScanResultRequest,
4164        ___deadline: zx::MonotonicInstant,
4165    ) -> Result<(), fidl::Error> {
4166        let _response = self
4167            .client
4168            .send_query::<WlanFullmacImplIfcOnScanResultRequest, fidl::encoding::EmptyPayload>(
4169                payload,
4170                0x29aa81dc570f7a3e,
4171                fidl::encoding::DynamicFlags::empty(),
4172                ___deadline,
4173            )?;
4174        Ok(_response)
4175    }
4176
4177    pub fn r#on_scan_end(
4178        &self,
4179        mut payload: &WlanFullmacImplIfcOnScanEndRequest,
4180        ___deadline: zx::MonotonicInstant,
4181    ) -> Result<(), fidl::Error> {
4182        let _response = self
4183            .client
4184            .send_query::<WlanFullmacImplIfcOnScanEndRequest, fidl::encoding::EmptyPayload>(
4185                payload,
4186                0x7cd8aff80d27073c,
4187                fidl::encoding::DynamicFlags::empty(),
4188                ___deadline,
4189            )?;
4190        Ok(_response)
4191    }
4192
4193    pub fn r#connect_conf(
4194        &self,
4195        mut payload: &WlanFullmacImplIfcConnectConfRequest,
4196        ___deadline: zx::MonotonicInstant,
4197    ) -> Result<(), fidl::Error> {
4198        let _response = self
4199            .client
4200            .send_query::<WlanFullmacImplIfcConnectConfRequest, fidl::encoding::EmptyPayload>(
4201                payload,
4202                0x3c22c6d80b2a2759,
4203                fidl::encoding::DynamicFlags::empty(),
4204                ___deadline,
4205            )?;
4206        Ok(_response)
4207    }
4208
4209    /// Report the result of an MLME-initiated roam attempt.
4210    pub fn r#roam_conf(
4211        &self,
4212        mut payload: &WlanFullmacImplIfcRoamConfRequest,
4213        ___deadline: zx::MonotonicInstant,
4214    ) -> Result<(), fidl::Error> {
4215        let _response = self
4216            .client
4217            .send_query::<WlanFullmacImplIfcRoamConfRequest, fidl::encoding::EmptyPayload>(
4218                payload,
4219                0x368b2a5b903b3f7b,
4220                fidl::encoding::DynamicFlags::empty(),
4221                ___deadline,
4222            )?;
4223        Ok(_response)
4224    }
4225
4226    /// Report that a fullmac-initiated roam attempt is in progress.
4227    /// Fullmac must send this start indication for all roam attempts.
4228    pub fn r#roam_start_ind(
4229        &self,
4230        mut payload: &WlanFullmacImplIfcRoamStartIndRequest,
4231        ___deadline: zx::MonotonicInstant,
4232    ) -> Result<(), fidl::Error> {
4233        let _response = self
4234            .client
4235            .send_query::<WlanFullmacImplIfcRoamStartIndRequest, fidl::encoding::EmptyPayload>(
4236                payload,
4237                0x23e1d9368935e7e4,
4238                fidl::encoding::DynamicFlags::empty(),
4239                ___deadline,
4240            )?;
4241        Ok(_response)
4242    }
4243
4244    /// Report the result of a fullmac-initiated roam attempt.
4245    pub fn r#roam_result_ind(
4246        &self,
4247        mut payload: &WlanFullmacImplIfcRoamResultIndRequest,
4248        ___deadline: zx::MonotonicInstant,
4249    ) -> Result<(), fidl::Error> {
4250        let _response = self
4251            .client
4252            .send_query::<WlanFullmacImplIfcRoamResultIndRequest, fidl::encoding::EmptyPayload>(
4253                payload,
4254                0x7081c1b1ceea4914,
4255                fidl::encoding::DynamicFlags::empty(),
4256                ___deadline,
4257            )?;
4258        Ok(_response)
4259    }
4260
4261    pub fn r#auth_ind(
4262        &self,
4263        mut payload: &WlanFullmacImplIfcAuthIndRequest,
4264        ___deadline: zx::MonotonicInstant,
4265    ) -> Result<(), fidl::Error> {
4266        let _response = self
4267            .client
4268            .send_query::<WlanFullmacImplIfcAuthIndRequest, fidl::encoding::EmptyPayload>(
4269                payload,
4270                0x270e1f8889650d0b,
4271                fidl::encoding::DynamicFlags::empty(),
4272                ___deadline,
4273            )?;
4274        Ok(_response)
4275    }
4276
4277    pub fn r#deauth_conf(
4278        &self,
4279        mut payload: &WlanFullmacImplIfcDeauthConfRequest,
4280        ___deadline: zx::MonotonicInstant,
4281    ) -> Result<(), fidl::Error> {
4282        let _response = self
4283            .client
4284            .send_query::<WlanFullmacImplIfcDeauthConfRequest, fidl::encoding::EmptyPayload>(
4285                payload,
4286                0x2c94b0d7258111b7,
4287                fidl::encoding::DynamicFlags::empty(),
4288                ___deadline,
4289            )?;
4290        Ok(_response)
4291    }
4292
4293    /// Report that the driver deauthenticated.
4294    pub fn r#deauth_ind(
4295        &self,
4296        mut payload: &WlanFullmacImplIfcDeauthIndRequest,
4297        ___deadline: zx::MonotonicInstant,
4298    ) -> Result<(), fidl::Error> {
4299        let _response = self
4300            .client
4301            .send_query::<WlanFullmacImplIfcDeauthIndRequest, fidl::encoding::EmptyPayload>(
4302                payload,
4303                0x26cd27cdadd8dbaf,
4304                fidl::encoding::DynamicFlags::empty(),
4305                ___deadline,
4306            )?;
4307        Ok(_response)
4308    }
4309
4310    pub fn r#assoc_ind(
4311        &self,
4312        mut payload: &WlanFullmacImplIfcAssocIndRequest,
4313        ___deadline: zx::MonotonicInstant,
4314    ) -> Result<(), fidl::Error> {
4315        let _response = self
4316            .client
4317            .send_query::<WlanFullmacImplIfcAssocIndRequest, fidl::encoding::EmptyPayload>(
4318                payload,
4319                0x3e44529e3dc179ce,
4320                fidl::encoding::DynamicFlags::empty(),
4321                ___deadline,
4322            )?;
4323        Ok(_response)
4324    }
4325
4326    /// Report the result of a previously-issued disassociate request. IEEE 802.11-2020 6.3.9.2.
4327    pub fn r#disassoc_conf(
4328        &self,
4329        mut payload: &WlanFullmacImplIfcDisassocConfRequest,
4330        ___deadline: zx::MonotonicInstant,
4331    ) -> Result<(), fidl::Error> {
4332        let _response = self
4333            .client
4334            .send_query::<WlanFullmacImplIfcDisassocConfRequest, fidl::encoding::EmptyPayload>(
4335                payload,
4336                0x7c713bcd58a76cb3,
4337                fidl::encoding::DynamicFlags::empty(),
4338                ___deadline,
4339            )?;
4340        Ok(_response)
4341    }
4342
4343    /// Report that disassociation with the specified peer occurred (IEEE 802.11-2020 6.3.9.3).
4344    pub fn r#disassoc_ind(
4345        &self,
4346        mut payload: &WlanFullmacImplIfcDisassocIndRequest,
4347        ___deadline: zx::MonotonicInstant,
4348    ) -> Result<(), fidl::Error> {
4349        let _response = self
4350            .client
4351            .send_query::<WlanFullmacImplIfcDisassocIndRequest, fidl::encoding::EmptyPayload>(
4352                payload,
4353                0x6667b381b7f3990f,
4354                fidl::encoding::DynamicFlags::empty(),
4355                ___deadline,
4356            )?;
4357        Ok(_response)
4358    }
4359
4360    /// Report the result of a WlanFullmacImpl::StartBss request.
4361    pub fn r#start_conf(
4362        &self,
4363        mut payload: &WlanFullmacImplIfcStartConfRequest,
4364        ___deadline: zx::MonotonicInstant,
4365    ) -> Result<(), fidl::Error> {
4366        let _response = self
4367            .client
4368            .send_query::<WlanFullmacImplIfcStartConfRequest, fidl::encoding::EmptyPayload>(
4369                payload,
4370                0x3e9b9641f3ddc7fc,
4371                fidl::encoding::DynamicFlags::empty(),
4372                ___deadline,
4373            )?;
4374        Ok(_response)
4375    }
4376
4377    /// Report the result of a WlanFullmacImpl::StopBss request.
4378    pub fn r#stop_conf(
4379        &self,
4380        mut payload: &WlanFullmacImplIfcStopConfRequest,
4381        ___deadline: zx::MonotonicInstant,
4382    ) -> Result<(), fidl::Error> {
4383        let _response = self
4384            .client
4385            .send_query::<WlanFullmacImplIfcStopConfRequest, fidl::encoding::EmptyPayload>(
4386                payload,
4387                0x320a5ff227a4e9df,
4388                fidl::encoding::DynamicFlags::empty(),
4389                ___deadline,
4390            )?;
4391        Ok(_response)
4392    }
4393
4394    /// Report the result of a EAPoL frame transmission (IEEE 802.11-2020 6.3.22.2).
4395    /// EAPoL frames are transmitted by the platform via WlanFullmacImpl::EapolTx.
4396    pub fn r#eapol_conf(
4397        &self,
4398        mut payload: &WlanFullmacImplIfcEapolConfRequest,
4399        ___deadline: zx::MonotonicInstant,
4400    ) -> Result<(), fidl::Error> {
4401        let _response = self
4402            .client
4403            .send_query::<WlanFullmacImplIfcEapolConfRequest, fidl::encoding::EmptyPayload>(
4404                payload,
4405                0x77364db9cc3970ec,
4406                fidl::encoding::DynamicFlags::empty(),
4407                ___deadline,
4408            )?;
4409        Ok(_response)
4410    }
4411
4412    pub fn r#on_channel_switch(
4413        &self,
4414        mut ind: &WlanFullmacChannelSwitchInfo,
4415        ___deadline: zx::MonotonicInstant,
4416    ) -> Result<(), fidl::Error> {
4417        let _response = self
4418            .client
4419            .send_query::<WlanFullmacImplIfcOnChannelSwitchRequest, fidl::encoding::EmptyPayload>(
4420                (ind,),
4421                0x21db0b8f71cae647,
4422                fidl::encoding::DynamicFlags::empty(),
4423                ___deadline,
4424            )?;
4425        Ok(_response)
4426    }
4427
4428    pub fn r#signal_report(
4429        &self,
4430        mut ind: &WlanFullmacSignalReportIndication,
4431        ___deadline: zx::MonotonicInstant,
4432    ) -> Result<(), fidl::Error> {
4433        let _response = self
4434            .client
4435            .send_query::<WlanFullmacImplIfcSignalReportRequest, fidl::encoding::EmptyPayload>(
4436                (ind,),
4437                0x79679fa8789c3d9f,
4438                fidl::encoding::DynamicFlags::empty(),
4439                ___deadline,
4440            )?;
4441        Ok(_response)
4442    }
4443
4444    /// Report that an EAPoL frame was received.
4445    pub fn r#eapol_ind(
4446        &self,
4447        mut payload: &WlanFullmacImplIfcEapolIndRequest,
4448        ___deadline: zx::MonotonicInstant,
4449    ) -> Result<(), fidl::Error> {
4450        let _response = self
4451            .client
4452            .send_query::<WlanFullmacImplIfcEapolIndRequest, fidl::encoding::EmptyPayload>(
4453                payload,
4454                0x3de8ec1eda10d1d0,
4455                fidl::encoding::DynamicFlags::empty(),
4456                ___deadline,
4457            )?;
4458        Ok(_response)
4459    }
4460
4461    /// Inform the platform that the PMK is available after a driver-handled SAE handshake.
4462    pub fn r#on_pmk_available(
4463        &self,
4464        mut payload: &WlanFullmacImplIfcOnPmkAvailableRequest,
4465        ___deadline: zx::MonotonicInstant,
4466    ) -> Result<(), fidl::Error> {
4467        let _response = self
4468            .client
4469            .send_query::<WlanFullmacImplIfcOnPmkAvailableRequest, fidl::encoding::EmptyPayload>(
4470                payload,
4471                0x5cedd8d9be28a17e,
4472                fidl::encoding::DynamicFlags::empty(),
4473                ___deadline,
4474            )?;
4475        Ok(_response)
4476    }
4477
4478    pub fn r#sae_handshake_ind(
4479        &self,
4480        mut payload: &WlanFullmacImplIfcSaeHandshakeIndRequest,
4481        ___deadline: zx::MonotonicInstant,
4482    ) -> Result<(), fidl::Error> {
4483        let _response = self
4484            .client
4485            .send_query::<WlanFullmacImplIfcSaeHandshakeIndRequest, fidl::encoding::EmptyPayload>(
4486                payload,
4487                0x4f3d53885503a1d8,
4488                fidl::encoding::DynamicFlags::empty(),
4489                ___deadline,
4490            )?;
4491        Ok(_response)
4492    }
4493
4494    /// Receive an SAE authentication frame.
4495    pub fn r#sae_frame_rx(
4496        &self,
4497        mut frame: &SaeFrame,
4498        ___deadline: zx::MonotonicInstant,
4499    ) -> Result<(), fidl::Error> {
4500        let _response = self
4501            .client
4502            .send_query::<WlanFullmacImplIfcSaeFrameRxRequest, fidl::encoding::EmptyPayload>(
4503                (frame,),
4504                0x51650906857ed4d4,
4505                fidl::encoding::DynamicFlags::empty(),
4506                ___deadline,
4507            )?;
4508        Ok(_response)
4509    }
4510
4511    pub fn r#on_wmm_status_resp(
4512        &self,
4513        mut status: i32,
4514        mut wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
4515        ___deadline: zx::MonotonicInstant,
4516    ) -> Result<(), fidl::Error> {
4517        let _response = self
4518            .client
4519            .send_query::<WlanFullmacImplIfcOnWmmStatusRespRequest, fidl::encoding::EmptyPayload>(
4520                (status, wmm_params),
4521                0x6823a88bf3ba8b2a,
4522                fidl::encoding::DynamicFlags::empty(),
4523                ___deadline,
4524            )?;
4525        Ok(_response)
4526    }
4527}
4528
4529#[derive(Debug, Clone)]
4530pub struct WlanFullmacImplIfcProxy {
4531    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
4532}
4533
4534impl fidl::endpoints::Proxy for WlanFullmacImplIfcProxy {
4535    type Protocol = WlanFullmacImplIfcMarker;
4536
4537    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
4538        Self::new(inner)
4539    }
4540
4541    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
4542        self.client.into_channel().map_err(|client| Self { client })
4543    }
4544
4545    fn as_channel(&self) -> &::fidl::AsyncChannel {
4546        self.client.as_channel()
4547    }
4548}
4549
4550impl WlanFullmacImplIfcProxy {
4551    /// Create a new Proxy for fuchsia.wlan.fullmac/WlanFullmacImplIfc.
4552    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
4553        let protocol_name =
4554            <WlanFullmacImplIfcMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
4555        Self { client: fidl::client::Client::new(channel, protocol_name) }
4556    }
4557
4558    /// Get a Stream of events from the remote end of the protocol.
4559    ///
4560    /// # Panics
4561    ///
4562    /// Panics if the event stream was already taken.
4563    pub fn take_event_stream(&self) -> WlanFullmacImplIfcEventStream {
4564        WlanFullmacImplIfcEventStream { event_receiver: self.client.take_event_receiver() }
4565    }
4566
4567    pub fn r#on_scan_result(
4568        &self,
4569        mut payload: &WlanFullmacImplIfcOnScanResultRequest,
4570    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4571        WlanFullmacImplIfcProxyInterface::r#on_scan_result(self, payload)
4572    }
4573
4574    pub fn r#on_scan_end(
4575        &self,
4576        mut payload: &WlanFullmacImplIfcOnScanEndRequest,
4577    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4578        WlanFullmacImplIfcProxyInterface::r#on_scan_end(self, payload)
4579    }
4580
4581    pub fn r#connect_conf(
4582        &self,
4583        mut payload: &WlanFullmacImplIfcConnectConfRequest,
4584    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4585        WlanFullmacImplIfcProxyInterface::r#connect_conf(self, payload)
4586    }
4587
4588    /// Report the result of an MLME-initiated roam attempt.
4589    pub fn r#roam_conf(
4590        &self,
4591        mut payload: &WlanFullmacImplIfcRoamConfRequest,
4592    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4593        WlanFullmacImplIfcProxyInterface::r#roam_conf(self, payload)
4594    }
4595
4596    /// Report that a fullmac-initiated roam attempt is in progress.
4597    /// Fullmac must send this start indication for all roam attempts.
4598    pub fn r#roam_start_ind(
4599        &self,
4600        mut payload: &WlanFullmacImplIfcRoamStartIndRequest,
4601    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4602        WlanFullmacImplIfcProxyInterface::r#roam_start_ind(self, payload)
4603    }
4604
4605    /// Report the result of a fullmac-initiated roam attempt.
4606    pub fn r#roam_result_ind(
4607        &self,
4608        mut payload: &WlanFullmacImplIfcRoamResultIndRequest,
4609    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4610        WlanFullmacImplIfcProxyInterface::r#roam_result_ind(self, payload)
4611    }
4612
4613    pub fn r#auth_ind(
4614        &self,
4615        mut payload: &WlanFullmacImplIfcAuthIndRequest,
4616    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4617        WlanFullmacImplIfcProxyInterface::r#auth_ind(self, payload)
4618    }
4619
4620    pub fn r#deauth_conf(
4621        &self,
4622        mut payload: &WlanFullmacImplIfcDeauthConfRequest,
4623    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4624        WlanFullmacImplIfcProxyInterface::r#deauth_conf(self, payload)
4625    }
4626
4627    /// Report that the driver deauthenticated.
4628    pub fn r#deauth_ind(
4629        &self,
4630        mut payload: &WlanFullmacImplIfcDeauthIndRequest,
4631    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4632        WlanFullmacImplIfcProxyInterface::r#deauth_ind(self, payload)
4633    }
4634
4635    pub fn r#assoc_ind(
4636        &self,
4637        mut payload: &WlanFullmacImplIfcAssocIndRequest,
4638    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4639        WlanFullmacImplIfcProxyInterface::r#assoc_ind(self, payload)
4640    }
4641
4642    /// Report the result of a previously-issued disassociate request. IEEE 802.11-2020 6.3.9.2.
4643    pub fn r#disassoc_conf(
4644        &self,
4645        mut payload: &WlanFullmacImplIfcDisassocConfRequest,
4646    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4647        WlanFullmacImplIfcProxyInterface::r#disassoc_conf(self, payload)
4648    }
4649
4650    /// Report that disassociation with the specified peer occurred (IEEE 802.11-2020 6.3.9.3).
4651    pub fn r#disassoc_ind(
4652        &self,
4653        mut payload: &WlanFullmacImplIfcDisassocIndRequest,
4654    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4655        WlanFullmacImplIfcProxyInterface::r#disassoc_ind(self, payload)
4656    }
4657
4658    /// Report the result of a WlanFullmacImpl::StartBss request.
4659    pub fn r#start_conf(
4660        &self,
4661        mut payload: &WlanFullmacImplIfcStartConfRequest,
4662    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4663        WlanFullmacImplIfcProxyInterface::r#start_conf(self, payload)
4664    }
4665
4666    /// Report the result of a WlanFullmacImpl::StopBss request.
4667    pub fn r#stop_conf(
4668        &self,
4669        mut payload: &WlanFullmacImplIfcStopConfRequest,
4670    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4671        WlanFullmacImplIfcProxyInterface::r#stop_conf(self, payload)
4672    }
4673
4674    /// Report the result of a EAPoL frame transmission (IEEE 802.11-2020 6.3.22.2).
4675    /// EAPoL frames are transmitted by the platform via WlanFullmacImpl::EapolTx.
4676    pub fn r#eapol_conf(
4677        &self,
4678        mut payload: &WlanFullmacImplIfcEapolConfRequest,
4679    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4680        WlanFullmacImplIfcProxyInterface::r#eapol_conf(self, payload)
4681    }
4682
4683    pub fn r#on_channel_switch(
4684        &self,
4685        mut ind: &WlanFullmacChannelSwitchInfo,
4686    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4687        WlanFullmacImplIfcProxyInterface::r#on_channel_switch(self, ind)
4688    }
4689
4690    pub fn r#signal_report(
4691        &self,
4692        mut ind: &WlanFullmacSignalReportIndication,
4693    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4694        WlanFullmacImplIfcProxyInterface::r#signal_report(self, ind)
4695    }
4696
4697    /// Report that an EAPoL frame was received.
4698    pub fn r#eapol_ind(
4699        &self,
4700        mut payload: &WlanFullmacImplIfcEapolIndRequest,
4701    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4702        WlanFullmacImplIfcProxyInterface::r#eapol_ind(self, payload)
4703    }
4704
4705    /// Inform the platform that the PMK is available after a driver-handled SAE handshake.
4706    pub fn r#on_pmk_available(
4707        &self,
4708        mut payload: &WlanFullmacImplIfcOnPmkAvailableRequest,
4709    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4710        WlanFullmacImplIfcProxyInterface::r#on_pmk_available(self, payload)
4711    }
4712
4713    pub fn r#sae_handshake_ind(
4714        &self,
4715        mut payload: &WlanFullmacImplIfcSaeHandshakeIndRequest,
4716    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4717        WlanFullmacImplIfcProxyInterface::r#sae_handshake_ind(self, payload)
4718    }
4719
4720    /// Receive an SAE authentication frame.
4721    pub fn r#sae_frame_rx(
4722        &self,
4723        mut frame: &SaeFrame,
4724    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4725        WlanFullmacImplIfcProxyInterface::r#sae_frame_rx(self, frame)
4726    }
4727
4728    pub fn r#on_wmm_status_resp(
4729        &self,
4730        mut status: i32,
4731        mut wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
4732    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
4733        WlanFullmacImplIfcProxyInterface::r#on_wmm_status_resp(self, status, wmm_params)
4734    }
4735}
4736
4737impl WlanFullmacImplIfcProxyInterface for WlanFullmacImplIfcProxy {
4738    type OnScanResultResponseFut =
4739        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4740    fn r#on_scan_result(
4741        &self,
4742        mut payload: &WlanFullmacImplIfcOnScanResultRequest,
4743    ) -> Self::OnScanResultResponseFut {
4744        fn _decode(
4745            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4746        ) -> Result<(), fidl::Error> {
4747            let _response = fidl::client::decode_transaction_body::<
4748                fidl::encoding::EmptyPayload,
4749                fidl::encoding::DefaultFuchsiaResourceDialect,
4750                0x29aa81dc570f7a3e,
4751            >(_buf?)?;
4752            Ok(_response)
4753        }
4754        self.client.send_query_and_decode::<WlanFullmacImplIfcOnScanResultRequest, ()>(
4755            payload,
4756            0x29aa81dc570f7a3e,
4757            fidl::encoding::DynamicFlags::empty(),
4758            _decode,
4759        )
4760    }
4761
4762    type OnScanEndResponseFut =
4763        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4764    fn r#on_scan_end(
4765        &self,
4766        mut payload: &WlanFullmacImplIfcOnScanEndRequest,
4767    ) -> Self::OnScanEndResponseFut {
4768        fn _decode(
4769            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4770        ) -> Result<(), fidl::Error> {
4771            let _response = fidl::client::decode_transaction_body::<
4772                fidl::encoding::EmptyPayload,
4773                fidl::encoding::DefaultFuchsiaResourceDialect,
4774                0x7cd8aff80d27073c,
4775            >(_buf?)?;
4776            Ok(_response)
4777        }
4778        self.client.send_query_and_decode::<WlanFullmacImplIfcOnScanEndRequest, ()>(
4779            payload,
4780            0x7cd8aff80d27073c,
4781            fidl::encoding::DynamicFlags::empty(),
4782            _decode,
4783        )
4784    }
4785
4786    type ConnectConfResponseFut =
4787        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4788    fn r#connect_conf(
4789        &self,
4790        mut payload: &WlanFullmacImplIfcConnectConfRequest,
4791    ) -> Self::ConnectConfResponseFut {
4792        fn _decode(
4793            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4794        ) -> Result<(), fidl::Error> {
4795            let _response = fidl::client::decode_transaction_body::<
4796                fidl::encoding::EmptyPayload,
4797                fidl::encoding::DefaultFuchsiaResourceDialect,
4798                0x3c22c6d80b2a2759,
4799            >(_buf?)?;
4800            Ok(_response)
4801        }
4802        self.client.send_query_and_decode::<WlanFullmacImplIfcConnectConfRequest, ()>(
4803            payload,
4804            0x3c22c6d80b2a2759,
4805            fidl::encoding::DynamicFlags::empty(),
4806            _decode,
4807        )
4808    }
4809
4810    type RoamConfResponseFut =
4811        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4812    fn r#roam_conf(
4813        &self,
4814        mut payload: &WlanFullmacImplIfcRoamConfRequest,
4815    ) -> Self::RoamConfResponseFut {
4816        fn _decode(
4817            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4818        ) -> Result<(), fidl::Error> {
4819            let _response = fidl::client::decode_transaction_body::<
4820                fidl::encoding::EmptyPayload,
4821                fidl::encoding::DefaultFuchsiaResourceDialect,
4822                0x368b2a5b903b3f7b,
4823            >(_buf?)?;
4824            Ok(_response)
4825        }
4826        self.client.send_query_and_decode::<WlanFullmacImplIfcRoamConfRequest, ()>(
4827            payload,
4828            0x368b2a5b903b3f7b,
4829            fidl::encoding::DynamicFlags::empty(),
4830            _decode,
4831        )
4832    }
4833
4834    type RoamStartIndResponseFut =
4835        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4836    fn r#roam_start_ind(
4837        &self,
4838        mut payload: &WlanFullmacImplIfcRoamStartIndRequest,
4839    ) -> Self::RoamStartIndResponseFut {
4840        fn _decode(
4841            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4842        ) -> Result<(), fidl::Error> {
4843            let _response = fidl::client::decode_transaction_body::<
4844                fidl::encoding::EmptyPayload,
4845                fidl::encoding::DefaultFuchsiaResourceDialect,
4846                0x23e1d9368935e7e4,
4847            >(_buf?)?;
4848            Ok(_response)
4849        }
4850        self.client.send_query_and_decode::<WlanFullmacImplIfcRoamStartIndRequest, ()>(
4851            payload,
4852            0x23e1d9368935e7e4,
4853            fidl::encoding::DynamicFlags::empty(),
4854            _decode,
4855        )
4856    }
4857
4858    type RoamResultIndResponseFut =
4859        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4860    fn r#roam_result_ind(
4861        &self,
4862        mut payload: &WlanFullmacImplIfcRoamResultIndRequest,
4863    ) -> Self::RoamResultIndResponseFut {
4864        fn _decode(
4865            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4866        ) -> Result<(), fidl::Error> {
4867            let _response = fidl::client::decode_transaction_body::<
4868                fidl::encoding::EmptyPayload,
4869                fidl::encoding::DefaultFuchsiaResourceDialect,
4870                0x7081c1b1ceea4914,
4871            >(_buf?)?;
4872            Ok(_response)
4873        }
4874        self.client.send_query_and_decode::<WlanFullmacImplIfcRoamResultIndRequest, ()>(
4875            payload,
4876            0x7081c1b1ceea4914,
4877            fidl::encoding::DynamicFlags::empty(),
4878            _decode,
4879        )
4880    }
4881
4882    type AuthIndResponseFut =
4883        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4884    fn r#auth_ind(
4885        &self,
4886        mut payload: &WlanFullmacImplIfcAuthIndRequest,
4887    ) -> Self::AuthIndResponseFut {
4888        fn _decode(
4889            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4890        ) -> Result<(), fidl::Error> {
4891            let _response = fidl::client::decode_transaction_body::<
4892                fidl::encoding::EmptyPayload,
4893                fidl::encoding::DefaultFuchsiaResourceDialect,
4894                0x270e1f8889650d0b,
4895            >(_buf?)?;
4896            Ok(_response)
4897        }
4898        self.client.send_query_and_decode::<WlanFullmacImplIfcAuthIndRequest, ()>(
4899            payload,
4900            0x270e1f8889650d0b,
4901            fidl::encoding::DynamicFlags::empty(),
4902            _decode,
4903        )
4904    }
4905
4906    type DeauthConfResponseFut =
4907        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4908    fn r#deauth_conf(
4909        &self,
4910        mut payload: &WlanFullmacImplIfcDeauthConfRequest,
4911    ) -> Self::DeauthConfResponseFut {
4912        fn _decode(
4913            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4914        ) -> Result<(), fidl::Error> {
4915            let _response = fidl::client::decode_transaction_body::<
4916                fidl::encoding::EmptyPayload,
4917                fidl::encoding::DefaultFuchsiaResourceDialect,
4918                0x2c94b0d7258111b7,
4919            >(_buf?)?;
4920            Ok(_response)
4921        }
4922        self.client.send_query_and_decode::<WlanFullmacImplIfcDeauthConfRequest, ()>(
4923            payload,
4924            0x2c94b0d7258111b7,
4925            fidl::encoding::DynamicFlags::empty(),
4926            _decode,
4927        )
4928    }
4929
4930    type DeauthIndResponseFut =
4931        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4932    fn r#deauth_ind(
4933        &self,
4934        mut payload: &WlanFullmacImplIfcDeauthIndRequest,
4935    ) -> Self::DeauthIndResponseFut {
4936        fn _decode(
4937            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4938        ) -> Result<(), fidl::Error> {
4939            let _response = fidl::client::decode_transaction_body::<
4940                fidl::encoding::EmptyPayload,
4941                fidl::encoding::DefaultFuchsiaResourceDialect,
4942                0x26cd27cdadd8dbaf,
4943            >(_buf?)?;
4944            Ok(_response)
4945        }
4946        self.client.send_query_and_decode::<WlanFullmacImplIfcDeauthIndRequest, ()>(
4947            payload,
4948            0x26cd27cdadd8dbaf,
4949            fidl::encoding::DynamicFlags::empty(),
4950            _decode,
4951        )
4952    }
4953
4954    type AssocIndResponseFut =
4955        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4956    fn r#assoc_ind(
4957        &self,
4958        mut payload: &WlanFullmacImplIfcAssocIndRequest,
4959    ) -> Self::AssocIndResponseFut {
4960        fn _decode(
4961            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4962        ) -> Result<(), fidl::Error> {
4963            let _response = fidl::client::decode_transaction_body::<
4964                fidl::encoding::EmptyPayload,
4965                fidl::encoding::DefaultFuchsiaResourceDialect,
4966                0x3e44529e3dc179ce,
4967            >(_buf?)?;
4968            Ok(_response)
4969        }
4970        self.client.send_query_and_decode::<WlanFullmacImplIfcAssocIndRequest, ()>(
4971            payload,
4972            0x3e44529e3dc179ce,
4973            fidl::encoding::DynamicFlags::empty(),
4974            _decode,
4975        )
4976    }
4977
4978    type DisassocConfResponseFut =
4979        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
4980    fn r#disassoc_conf(
4981        &self,
4982        mut payload: &WlanFullmacImplIfcDisassocConfRequest,
4983    ) -> Self::DisassocConfResponseFut {
4984        fn _decode(
4985            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4986        ) -> Result<(), fidl::Error> {
4987            let _response = fidl::client::decode_transaction_body::<
4988                fidl::encoding::EmptyPayload,
4989                fidl::encoding::DefaultFuchsiaResourceDialect,
4990                0x7c713bcd58a76cb3,
4991            >(_buf?)?;
4992            Ok(_response)
4993        }
4994        self.client.send_query_and_decode::<WlanFullmacImplIfcDisassocConfRequest, ()>(
4995            payload,
4996            0x7c713bcd58a76cb3,
4997            fidl::encoding::DynamicFlags::empty(),
4998            _decode,
4999        )
5000    }
5001
5002    type DisassocIndResponseFut =
5003        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5004    fn r#disassoc_ind(
5005        &self,
5006        mut payload: &WlanFullmacImplIfcDisassocIndRequest,
5007    ) -> Self::DisassocIndResponseFut {
5008        fn _decode(
5009            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5010        ) -> Result<(), fidl::Error> {
5011            let _response = fidl::client::decode_transaction_body::<
5012                fidl::encoding::EmptyPayload,
5013                fidl::encoding::DefaultFuchsiaResourceDialect,
5014                0x6667b381b7f3990f,
5015            >(_buf?)?;
5016            Ok(_response)
5017        }
5018        self.client.send_query_and_decode::<WlanFullmacImplIfcDisassocIndRequest, ()>(
5019            payload,
5020            0x6667b381b7f3990f,
5021            fidl::encoding::DynamicFlags::empty(),
5022            _decode,
5023        )
5024    }
5025
5026    type StartConfResponseFut =
5027        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5028    fn r#start_conf(
5029        &self,
5030        mut payload: &WlanFullmacImplIfcStartConfRequest,
5031    ) -> Self::StartConfResponseFut {
5032        fn _decode(
5033            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5034        ) -> Result<(), fidl::Error> {
5035            let _response = fidl::client::decode_transaction_body::<
5036                fidl::encoding::EmptyPayload,
5037                fidl::encoding::DefaultFuchsiaResourceDialect,
5038                0x3e9b9641f3ddc7fc,
5039            >(_buf?)?;
5040            Ok(_response)
5041        }
5042        self.client.send_query_and_decode::<WlanFullmacImplIfcStartConfRequest, ()>(
5043            payload,
5044            0x3e9b9641f3ddc7fc,
5045            fidl::encoding::DynamicFlags::empty(),
5046            _decode,
5047        )
5048    }
5049
5050    type StopConfResponseFut =
5051        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5052    fn r#stop_conf(
5053        &self,
5054        mut payload: &WlanFullmacImplIfcStopConfRequest,
5055    ) -> Self::StopConfResponseFut {
5056        fn _decode(
5057            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5058        ) -> Result<(), fidl::Error> {
5059            let _response = fidl::client::decode_transaction_body::<
5060                fidl::encoding::EmptyPayload,
5061                fidl::encoding::DefaultFuchsiaResourceDialect,
5062                0x320a5ff227a4e9df,
5063            >(_buf?)?;
5064            Ok(_response)
5065        }
5066        self.client.send_query_and_decode::<WlanFullmacImplIfcStopConfRequest, ()>(
5067            payload,
5068            0x320a5ff227a4e9df,
5069            fidl::encoding::DynamicFlags::empty(),
5070            _decode,
5071        )
5072    }
5073
5074    type EapolConfResponseFut =
5075        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5076    fn r#eapol_conf(
5077        &self,
5078        mut payload: &WlanFullmacImplIfcEapolConfRequest,
5079    ) -> Self::EapolConfResponseFut {
5080        fn _decode(
5081            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5082        ) -> Result<(), fidl::Error> {
5083            let _response = fidl::client::decode_transaction_body::<
5084                fidl::encoding::EmptyPayload,
5085                fidl::encoding::DefaultFuchsiaResourceDialect,
5086                0x77364db9cc3970ec,
5087            >(_buf?)?;
5088            Ok(_response)
5089        }
5090        self.client.send_query_and_decode::<WlanFullmacImplIfcEapolConfRequest, ()>(
5091            payload,
5092            0x77364db9cc3970ec,
5093            fidl::encoding::DynamicFlags::empty(),
5094            _decode,
5095        )
5096    }
5097
5098    type OnChannelSwitchResponseFut =
5099        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5100    fn r#on_channel_switch(
5101        &self,
5102        mut ind: &WlanFullmacChannelSwitchInfo,
5103    ) -> Self::OnChannelSwitchResponseFut {
5104        fn _decode(
5105            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5106        ) -> Result<(), fidl::Error> {
5107            let _response = fidl::client::decode_transaction_body::<
5108                fidl::encoding::EmptyPayload,
5109                fidl::encoding::DefaultFuchsiaResourceDialect,
5110                0x21db0b8f71cae647,
5111            >(_buf?)?;
5112            Ok(_response)
5113        }
5114        self.client.send_query_and_decode::<WlanFullmacImplIfcOnChannelSwitchRequest, ()>(
5115            (ind,),
5116            0x21db0b8f71cae647,
5117            fidl::encoding::DynamicFlags::empty(),
5118            _decode,
5119        )
5120    }
5121
5122    type SignalReportResponseFut =
5123        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5124    fn r#signal_report(
5125        &self,
5126        mut ind: &WlanFullmacSignalReportIndication,
5127    ) -> Self::SignalReportResponseFut {
5128        fn _decode(
5129            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5130        ) -> Result<(), fidl::Error> {
5131            let _response = fidl::client::decode_transaction_body::<
5132                fidl::encoding::EmptyPayload,
5133                fidl::encoding::DefaultFuchsiaResourceDialect,
5134                0x79679fa8789c3d9f,
5135            >(_buf?)?;
5136            Ok(_response)
5137        }
5138        self.client.send_query_and_decode::<WlanFullmacImplIfcSignalReportRequest, ()>(
5139            (ind,),
5140            0x79679fa8789c3d9f,
5141            fidl::encoding::DynamicFlags::empty(),
5142            _decode,
5143        )
5144    }
5145
5146    type EapolIndResponseFut =
5147        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5148    fn r#eapol_ind(
5149        &self,
5150        mut payload: &WlanFullmacImplIfcEapolIndRequest,
5151    ) -> Self::EapolIndResponseFut {
5152        fn _decode(
5153            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5154        ) -> Result<(), fidl::Error> {
5155            let _response = fidl::client::decode_transaction_body::<
5156                fidl::encoding::EmptyPayload,
5157                fidl::encoding::DefaultFuchsiaResourceDialect,
5158                0x3de8ec1eda10d1d0,
5159            >(_buf?)?;
5160            Ok(_response)
5161        }
5162        self.client.send_query_and_decode::<WlanFullmacImplIfcEapolIndRequest, ()>(
5163            payload,
5164            0x3de8ec1eda10d1d0,
5165            fidl::encoding::DynamicFlags::empty(),
5166            _decode,
5167        )
5168    }
5169
5170    type OnPmkAvailableResponseFut =
5171        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5172    fn r#on_pmk_available(
5173        &self,
5174        mut payload: &WlanFullmacImplIfcOnPmkAvailableRequest,
5175    ) -> Self::OnPmkAvailableResponseFut {
5176        fn _decode(
5177            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5178        ) -> Result<(), fidl::Error> {
5179            let _response = fidl::client::decode_transaction_body::<
5180                fidl::encoding::EmptyPayload,
5181                fidl::encoding::DefaultFuchsiaResourceDialect,
5182                0x5cedd8d9be28a17e,
5183            >(_buf?)?;
5184            Ok(_response)
5185        }
5186        self.client.send_query_and_decode::<WlanFullmacImplIfcOnPmkAvailableRequest, ()>(
5187            payload,
5188            0x5cedd8d9be28a17e,
5189            fidl::encoding::DynamicFlags::empty(),
5190            _decode,
5191        )
5192    }
5193
5194    type SaeHandshakeIndResponseFut =
5195        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5196    fn r#sae_handshake_ind(
5197        &self,
5198        mut payload: &WlanFullmacImplIfcSaeHandshakeIndRequest,
5199    ) -> Self::SaeHandshakeIndResponseFut {
5200        fn _decode(
5201            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5202        ) -> Result<(), fidl::Error> {
5203            let _response = fidl::client::decode_transaction_body::<
5204                fidl::encoding::EmptyPayload,
5205                fidl::encoding::DefaultFuchsiaResourceDialect,
5206                0x4f3d53885503a1d8,
5207            >(_buf?)?;
5208            Ok(_response)
5209        }
5210        self.client.send_query_and_decode::<WlanFullmacImplIfcSaeHandshakeIndRequest, ()>(
5211            payload,
5212            0x4f3d53885503a1d8,
5213            fidl::encoding::DynamicFlags::empty(),
5214            _decode,
5215        )
5216    }
5217
5218    type SaeFrameRxResponseFut =
5219        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5220    fn r#sae_frame_rx(&self, mut frame: &SaeFrame) -> Self::SaeFrameRxResponseFut {
5221        fn _decode(
5222            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5223        ) -> Result<(), fidl::Error> {
5224            let _response = fidl::client::decode_transaction_body::<
5225                fidl::encoding::EmptyPayload,
5226                fidl::encoding::DefaultFuchsiaResourceDialect,
5227                0x51650906857ed4d4,
5228            >(_buf?)?;
5229            Ok(_response)
5230        }
5231        self.client.send_query_and_decode::<WlanFullmacImplIfcSaeFrameRxRequest, ()>(
5232            (frame,),
5233            0x51650906857ed4d4,
5234            fidl::encoding::DynamicFlags::empty(),
5235            _decode,
5236        )
5237    }
5238
5239    type OnWmmStatusRespResponseFut =
5240        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
5241    fn r#on_wmm_status_resp(
5242        &self,
5243        mut status: i32,
5244        mut wmm_params: &fidl_fuchsia_wlan_common::WlanWmmParameters,
5245    ) -> Self::OnWmmStatusRespResponseFut {
5246        fn _decode(
5247            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5248        ) -> Result<(), fidl::Error> {
5249            let _response = fidl::client::decode_transaction_body::<
5250                fidl::encoding::EmptyPayload,
5251                fidl::encoding::DefaultFuchsiaResourceDialect,
5252                0x6823a88bf3ba8b2a,
5253            >(_buf?)?;
5254            Ok(_response)
5255        }
5256        self.client.send_query_and_decode::<WlanFullmacImplIfcOnWmmStatusRespRequest, ()>(
5257            (status, wmm_params),
5258            0x6823a88bf3ba8b2a,
5259            fidl::encoding::DynamicFlags::empty(),
5260            _decode,
5261        )
5262    }
5263}
5264
5265pub struct WlanFullmacImplIfcEventStream {
5266    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
5267}
5268
5269impl std::marker::Unpin for WlanFullmacImplIfcEventStream {}
5270
5271impl futures::stream::FusedStream for WlanFullmacImplIfcEventStream {
5272    fn is_terminated(&self) -> bool {
5273        self.event_receiver.is_terminated()
5274    }
5275}
5276
5277impl futures::Stream for WlanFullmacImplIfcEventStream {
5278    type Item = Result<WlanFullmacImplIfcEvent, fidl::Error>;
5279
5280    fn poll_next(
5281        mut self: std::pin::Pin<&mut Self>,
5282        cx: &mut std::task::Context<'_>,
5283    ) -> std::task::Poll<Option<Self::Item>> {
5284        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
5285            &mut self.event_receiver,
5286            cx
5287        )?) {
5288            Some(buf) => std::task::Poll::Ready(Some(WlanFullmacImplIfcEvent::decode(buf))),
5289            None => std::task::Poll::Ready(None),
5290        }
5291    }
5292}
5293
5294#[derive(Debug)]
5295pub enum WlanFullmacImplIfcEvent {}
5296
5297impl WlanFullmacImplIfcEvent {
5298    /// Decodes a message buffer as a [`WlanFullmacImplIfcEvent`].
5299    fn decode(
5300        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
5301    ) -> Result<WlanFullmacImplIfcEvent, fidl::Error> {
5302        let (bytes, _handles) = buf.split_mut();
5303        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
5304        debug_assert_eq!(tx_header.tx_id, 0);
5305        match tx_header.ordinal {
5306            _ => Err(fidl::Error::UnknownOrdinal {
5307                ordinal: tx_header.ordinal,
5308                protocol_name:
5309                    <WlanFullmacImplIfcMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
5310            }),
5311        }
5312    }
5313}
5314
5315/// A Stream of incoming requests for fuchsia.wlan.fullmac/WlanFullmacImplIfc.
5316pub struct WlanFullmacImplIfcRequestStream {
5317    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
5318    is_terminated: bool,
5319}
5320
5321impl std::marker::Unpin for WlanFullmacImplIfcRequestStream {}
5322
5323impl futures::stream::FusedStream for WlanFullmacImplIfcRequestStream {
5324    fn is_terminated(&self) -> bool {
5325        self.is_terminated
5326    }
5327}
5328
5329impl fidl::endpoints::RequestStream for WlanFullmacImplIfcRequestStream {
5330    type Protocol = WlanFullmacImplIfcMarker;
5331    type ControlHandle = WlanFullmacImplIfcControlHandle;
5332
5333    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
5334        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
5335    }
5336
5337    fn control_handle(&self) -> Self::ControlHandle {
5338        WlanFullmacImplIfcControlHandle { inner: self.inner.clone() }
5339    }
5340
5341    fn into_inner(
5342        self,
5343    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
5344    {
5345        (self.inner, self.is_terminated)
5346    }
5347
5348    fn from_inner(
5349        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
5350        is_terminated: bool,
5351    ) -> Self {
5352        Self { inner, is_terminated }
5353    }
5354}
5355
5356impl futures::Stream for WlanFullmacImplIfcRequestStream {
5357    type Item = Result<WlanFullmacImplIfcRequest, fidl::Error>;
5358
5359    fn poll_next(
5360        mut self: std::pin::Pin<&mut Self>,
5361        cx: &mut std::task::Context<'_>,
5362    ) -> std::task::Poll<Option<Self::Item>> {
5363        let this = &mut *self;
5364        if this.inner.check_shutdown(cx) {
5365            this.is_terminated = true;
5366            return std::task::Poll::Ready(None);
5367        }
5368        if this.is_terminated {
5369            panic!("polled WlanFullmacImplIfcRequestStream after completion");
5370        }
5371        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
5372            |bytes, handles| {
5373                match this.inner.channel().read_etc(cx, bytes, handles) {
5374                    std::task::Poll::Ready(Ok(())) => {}
5375                    std::task::Poll::Pending => return std::task::Poll::Pending,
5376                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
5377                        this.is_terminated = true;
5378                        return std::task::Poll::Ready(None);
5379                    }
5380                    std::task::Poll::Ready(Err(e)) => {
5381                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
5382                            e.into(),
5383                        ))))
5384                    }
5385                }
5386
5387                // A message has been received from the channel
5388                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
5389
5390                std::task::Poll::Ready(Some(match header.ordinal {
5391                0x29aa81dc570f7a3e => {
5392                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5393                    let mut req = fidl::new_empty!(WlanFullmacImplIfcOnScanResultRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5394                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcOnScanResultRequest>(&header, _body_bytes, handles, &mut req)?;
5395                    let control_handle = WlanFullmacImplIfcControlHandle {
5396                        inner: this.inner.clone(),
5397                    };
5398                    Ok(WlanFullmacImplIfcRequest::OnScanResult {payload: req,
5399                        responder: WlanFullmacImplIfcOnScanResultResponder {
5400                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5401                            tx_id: header.tx_id,
5402                        },
5403                    })
5404                }
5405                0x7cd8aff80d27073c => {
5406                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5407                    let mut req = fidl::new_empty!(WlanFullmacImplIfcOnScanEndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5408                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcOnScanEndRequest>(&header, _body_bytes, handles, &mut req)?;
5409                    let control_handle = WlanFullmacImplIfcControlHandle {
5410                        inner: this.inner.clone(),
5411                    };
5412                    Ok(WlanFullmacImplIfcRequest::OnScanEnd {payload: req,
5413                        responder: WlanFullmacImplIfcOnScanEndResponder {
5414                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5415                            tx_id: header.tx_id,
5416                        },
5417                    })
5418                }
5419                0x3c22c6d80b2a2759 => {
5420                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5421                    let mut req = fidl::new_empty!(WlanFullmacImplIfcConnectConfRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5422                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcConnectConfRequest>(&header, _body_bytes, handles, &mut req)?;
5423                    let control_handle = WlanFullmacImplIfcControlHandle {
5424                        inner: this.inner.clone(),
5425                    };
5426                    Ok(WlanFullmacImplIfcRequest::ConnectConf {payload: req,
5427                        responder: WlanFullmacImplIfcConnectConfResponder {
5428                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5429                            tx_id: header.tx_id,
5430                        },
5431                    })
5432                }
5433                0x368b2a5b903b3f7b => {
5434                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5435                    let mut req = fidl::new_empty!(WlanFullmacImplIfcRoamConfRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5436                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcRoamConfRequest>(&header, _body_bytes, handles, &mut req)?;
5437                    let control_handle = WlanFullmacImplIfcControlHandle {
5438                        inner: this.inner.clone(),
5439                    };
5440                    Ok(WlanFullmacImplIfcRequest::RoamConf {payload: req,
5441                        responder: WlanFullmacImplIfcRoamConfResponder {
5442                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5443                            tx_id: header.tx_id,
5444                        },
5445                    })
5446                }
5447                0x23e1d9368935e7e4 => {
5448                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5449                    let mut req = fidl::new_empty!(WlanFullmacImplIfcRoamStartIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5450                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcRoamStartIndRequest>(&header, _body_bytes, handles, &mut req)?;
5451                    let control_handle = WlanFullmacImplIfcControlHandle {
5452                        inner: this.inner.clone(),
5453                    };
5454                    Ok(WlanFullmacImplIfcRequest::RoamStartInd {payload: req,
5455                        responder: WlanFullmacImplIfcRoamStartIndResponder {
5456                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5457                            tx_id: header.tx_id,
5458                        },
5459                    })
5460                }
5461                0x7081c1b1ceea4914 => {
5462                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5463                    let mut req = fidl::new_empty!(WlanFullmacImplIfcRoamResultIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5464                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcRoamResultIndRequest>(&header, _body_bytes, handles, &mut req)?;
5465                    let control_handle = WlanFullmacImplIfcControlHandle {
5466                        inner: this.inner.clone(),
5467                    };
5468                    Ok(WlanFullmacImplIfcRequest::RoamResultInd {payload: req,
5469                        responder: WlanFullmacImplIfcRoamResultIndResponder {
5470                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5471                            tx_id: header.tx_id,
5472                        },
5473                    })
5474                }
5475                0x270e1f8889650d0b => {
5476                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5477                    let mut req = fidl::new_empty!(WlanFullmacImplIfcAuthIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5478                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcAuthIndRequest>(&header, _body_bytes, handles, &mut req)?;
5479                    let control_handle = WlanFullmacImplIfcControlHandle {
5480                        inner: this.inner.clone(),
5481                    };
5482                    Ok(WlanFullmacImplIfcRequest::AuthInd {payload: req,
5483                        responder: WlanFullmacImplIfcAuthIndResponder {
5484                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5485                            tx_id: header.tx_id,
5486                        },
5487                    })
5488                }
5489                0x2c94b0d7258111b7 => {
5490                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5491                    let mut req = fidl::new_empty!(WlanFullmacImplIfcDeauthConfRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5492                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcDeauthConfRequest>(&header, _body_bytes, handles, &mut req)?;
5493                    let control_handle = WlanFullmacImplIfcControlHandle {
5494                        inner: this.inner.clone(),
5495                    };
5496                    Ok(WlanFullmacImplIfcRequest::DeauthConf {payload: req,
5497                        responder: WlanFullmacImplIfcDeauthConfResponder {
5498                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5499                            tx_id: header.tx_id,
5500                        },
5501                    })
5502                }
5503                0x26cd27cdadd8dbaf => {
5504                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5505                    let mut req = fidl::new_empty!(WlanFullmacImplIfcDeauthIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5506                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcDeauthIndRequest>(&header, _body_bytes, handles, &mut req)?;
5507                    let control_handle = WlanFullmacImplIfcControlHandle {
5508                        inner: this.inner.clone(),
5509                    };
5510                    Ok(WlanFullmacImplIfcRequest::DeauthInd {payload: req,
5511                        responder: WlanFullmacImplIfcDeauthIndResponder {
5512                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5513                            tx_id: header.tx_id,
5514                        },
5515                    })
5516                }
5517                0x3e44529e3dc179ce => {
5518                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5519                    let mut req = fidl::new_empty!(WlanFullmacImplIfcAssocIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5520                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcAssocIndRequest>(&header, _body_bytes, handles, &mut req)?;
5521                    let control_handle = WlanFullmacImplIfcControlHandle {
5522                        inner: this.inner.clone(),
5523                    };
5524                    Ok(WlanFullmacImplIfcRequest::AssocInd {payload: req,
5525                        responder: WlanFullmacImplIfcAssocIndResponder {
5526                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5527                            tx_id: header.tx_id,
5528                        },
5529                    })
5530                }
5531                0x7c713bcd58a76cb3 => {
5532                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5533                    let mut req = fidl::new_empty!(WlanFullmacImplIfcDisassocConfRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5534                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcDisassocConfRequest>(&header, _body_bytes, handles, &mut req)?;
5535                    let control_handle = WlanFullmacImplIfcControlHandle {
5536                        inner: this.inner.clone(),
5537                    };
5538                    Ok(WlanFullmacImplIfcRequest::DisassocConf {payload: req,
5539                        responder: WlanFullmacImplIfcDisassocConfResponder {
5540                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5541                            tx_id: header.tx_id,
5542                        },
5543                    })
5544                }
5545                0x6667b381b7f3990f => {
5546                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5547                    let mut req = fidl::new_empty!(WlanFullmacImplIfcDisassocIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5548                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcDisassocIndRequest>(&header, _body_bytes, handles, &mut req)?;
5549                    let control_handle = WlanFullmacImplIfcControlHandle {
5550                        inner: this.inner.clone(),
5551                    };
5552                    Ok(WlanFullmacImplIfcRequest::DisassocInd {payload: req,
5553                        responder: WlanFullmacImplIfcDisassocIndResponder {
5554                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5555                            tx_id: header.tx_id,
5556                        },
5557                    })
5558                }
5559                0x3e9b9641f3ddc7fc => {
5560                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5561                    let mut req = fidl::new_empty!(WlanFullmacImplIfcStartConfRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5562                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcStartConfRequest>(&header, _body_bytes, handles, &mut req)?;
5563                    let control_handle = WlanFullmacImplIfcControlHandle {
5564                        inner: this.inner.clone(),
5565                    };
5566                    Ok(WlanFullmacImplIfcRequest::StartConf {payload: req,
5567                        responder: WlanFullmacImplIfcStartConfResponder {
5568                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5569                            tx_id: header.tx_id,
5570                        },
5571                    })
5572                }
5573                0x320a5ff227a4e9df => {
5574                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5575                    let mut req = fidl::new_empty!(WlanFullmacImplIfcStopConfRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5576                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcStopConfRequest>(&header, _body_bytes, handles, &mut req)?;
5577                    let control_handle = WlanFullmacImplIfcControlHandle {
5578                        inner: this.inner.clone(),
5579                    };
5580                    Ok(WlanFullmacImplIfcRequest::StopConf {payload: req,
5581                        responder: WlanFullmacImplIfcStopConfResponder {
5582                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5583                            tx_id: header.tx_id,
5584                        },
5585                    })
5586                }
5587                0x77364db9cc3970ec => {
5588                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5589                    let mut req = fidl::new_empty!(WlanFullmacImplIfcEapolConfRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5590                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcEapolConfRequest>(&header, _body_bytes, handles, &mut req)?;
5591                    let control_handle = WlanFullmacImplIfcControlHandle {
5592                        inner: this.inner.clone(),
5593                    };
5594                    Ok(WlanFullmacImplIfcRequest::EapolConf {payload: req,
5595                        responder: WlanFullmacImplIfcEapolConfResponder {
5596                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5597                            tx_id: header.tx_id,
5598                        },
5599                    })
5600                }
5601                0x21db0b8f71cae647 => {
5602                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5603                    let mut req = fidl::new_empty!(WlanFullmacImplIfcOnChannelSwitchRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5604                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcOnChannelSwitchRequest>(&header, _body_bytes, handles, &mut req)?;
5605                    let control_handle = WlanFullmacImplIfcControlHandle {
5606                        inner: this.inner.clone(),
5607                    };
5608                    Ok(WlanFullmacImplIfcRequest::OnChannelSwitch {ind: req.ind,
5609
5610                        responder: WlanFullmacImplIfcOnChannelSwitchResponder {
5611                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5612                            tx_id: header.tx_id,
5613                        },
5614                    })
5615                }
5616                0x79679fa8789c3d9f => {
5617                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5618                    let mut req = fidl::new_empty!(WlanFullmacImplIfcSignalReportRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5619                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcSignalReportRequest>(&header, _body_bytes, handles, &mut req)?;
5620                    let control_handle = WlanFullmacImplIfcControlHandle {
5621                        inner: this.inner.clone(),
5622                    };
5623                    Ok(WlanFullmacImplIfcRequest::SignalReport {ind: req.ind,
5624
5625                        responder: WlanFullmacImplIfcSignalReportResponder {
5626                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5627                            tx_id: header.tx_id,
5628                        },
5629                    })
5630                }
5631                0x3de8ec1eda10d1d0 => {
5632                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5633                    let mut req = fidl::new_empty!(WlanFullmacImplIfcEapolIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5634                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcEapolIndRequest>(&header, _body_bytes, handles, &mut req)?;
5635                    let control_handle = WlanFullmacImplIfcControlHandle {
5636                        inner: this.inner.clone(),
5637                    };
5638                    Ok(WlanFullmacImplIfcRequest::EapolInd {payload: req,
5639                        responder: WlanFullmacImplIfcEapolIndResponder {
5640                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5641                            tx_id: header.tx_id,
5642                        },
5643                    })
5644                }
5645                0x5cedd8d9be28a17e => {
5646                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5647                    let mut req = fidl::new_empty!(WlanFullmacImplIfcOnPmkAvailableRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5648                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcOnPmkAvailableRequest>(&header, _body_bytes, handles, &mut req)?;
5649                    let control_handle = WlanFullmacImplIfcControlHandle {
5650                        inner: this.inner.clone(),
5651                    };
5652                    Ok(WlanFullmacImplIfcRequest::OnPmkAvailable {payload: req,
5653                        responder: WlanFullmacImplIfcOnPmkAvailableResponder {
5654                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5655                            tx_id: header.tx_id,
5656                        },
5657                    })
5658                }
5659                0x4f3d53885503a1d8 => {
5660                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5661                    let mut req = fidl::new_empty!(WlanFullmacImplIfcSaeHandshakeIndRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5662                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcSaeHandshakeIndRequest>(&header, _body_bytes, handles, &mut req)?;
5663                    let control_handle = WlanFullmacImplIfcControlHandle {
5664                        inner: this.inner.clone(),
5665                    };
5666                    Ok(WlanFullmacImplIfcRequest::SaeHandshakeInd {payload: req,
5667                        responder: WlanFullmacImplIfcSaeHandshakeIndResponder {
5668                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5669                            tx_id: header.tx_id,
5670                        },
5671                    })
5672                }
5673                0x51650906857ed4d4 => {
5674                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5675                    let mut req = fidl::new_empty!(WlanFullmacImplIfcSaeFrameRxRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5676                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcSaeFrameRxRequest>(&header, _body_bytes, handles, &mut req)?;
5677                    let control_handle = WlanFullmacImplIfcControlHandle {
5678                        inner: this.inner.clone(),
5679                    };
5680                    Ok(WlanFullmacImplIfcRequest::SaeFrameRx {frame: req.frame,
5681
5682                        responder: WlanFullmacImplIfcSaeFrameRxResponder {
5683                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5684                            tx_id: header.tx_id,
5685                        },
5686                    })
5687                }
5688                0x6823a88bf3ba8b2a => {
5689                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5690                    let mut req = fidl::new_empty!(WlanFullmacImplIfcOnWmmStatusRespRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5691                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<WlanFullmacImplIfcOnWmmStatusRespRequest>(&header, _body_bytes, handles, &mut req)?;
5692                    let control_handle = WlanFullmacImplIfcControlHandle {
5693                        inner: this.inner.clone(),
5694                    };
5695                    Ok(WlanFullmacImplIfcRequest::OnWmmStatusResp {status: req.status,
5696wmm_params: req.wmm_params,
5697
5698                        responder: WlanFullmacImplIfcOnWmmStatusRespResponder {
5699                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5700                            tx_id: header.tx_id,
5701                        },
5702                    })
5703                }
5704                _ => Err(fidl::Error::UnknownOrdinal {
5705                    ordinal: header.ordinal,
5706                    protocol_name: <WlanFullmacImplIfcMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
5707                }),
5708            }))
5709            },
5710        )
5711    }
5712}
5713
5714/// Protocol definition for communication from the fullmac vendor driver to the platform.
5715#[derive(Debug)]
5716pub enum WlanFullmacImplIfcRequest {
5717    OnScanResult {
5718        payload: WlanFullmacImplIfcOnScanResultRequest,
5719        responder: WlanFullmacImplIfcOnScanResultResponder,
5720    },
5721    OnScanEnd {
5722        payload: WlanFullmacImplIfcOnScanEndRequest,
5723        responder: WlanFullmacImplIfcOnScanEndResponder,
5724    },
5725    ConnectConf {
5726        payload: WlanFullmacImplIfcConnectConfRequest,
5727        responder: WlanFullmacImplIfcConnectConfResponder,
5728    },
5729    /// Report the result of an MLME-initiated roam attempt.
5730    RoamConf {
5731        payload: WlanFullmacImplIfcRoamConfRequest,
5732        responder: WlanFullmacImplIfcRoamConfResponder,
5733    },
5734    /// Report that a fullmac-initiated roam attempt is in progress.
5735    /// Fullmac must send this start indication for all roam attempts.
5736    RoamStartInd {
5737        payload: WlanFullmacImplIfcRoamStartIndRequest,
5738        responder: WlanFullmacImplIfcRoamStartIndResponder,
5739    },
5740    /// Report the result of a fullmac-initiated roam attempt.
5741    RoamResultInd {
5742        payload: WlanFullmacImplIfcRoamResultIndRequest,
5743        responder: WlanFullmacImplIfcRoamResultIndResponder,
5744    },
5745    AuthInd {
5746        payload: WlanFullmacImplIfcAuthIndRequest,
5747        responder: WlanFullmacImplIfcAuthIndResponder,
5748    },
5749    DeauthConf {
5750        payload: WlanFullmacImplIfcDeauthConfRequest,
5751        responder: WlanFullmacImplIfcDeauthConfResponder,
5752    },
5753    /// Report that the driver deauthenticated.
5754    DeauthInd {
5755        payload: WlanFullmacImplIfcDeauthIndRequest,
5756        responder: WlanFullmacImplIfcDeauthIndResponder,
5757    },
5758    AssocInd {
5759        payload: WlanFullmacImplIfcAssocIndRequest,
5760        responder: WlanFullmacImplIfcAssocIndResponder,
5761    },
5762    /// Report the result of a previously-issued disassociate request. IEEE 802.11-2020 6.3.9.2.
5763    DisassocConf {
5764        payload: WlanFullmacImplIfcDisassocConfRequest,
5765        responder: WlanFullmacImplIfcDisassocConfResponder,
5766    },
5767    /// Report that disassociation with the specified peer occurred (IEEE 802.11-2020 6.3.9.3).
5768    DisassocInd {
5769        payload: WlanFullmacImplIfcDisassocIndRequest,
5770        responder: WlanFullmacImplIfcDisassocIndResponder,
5771    },
5772    /// Report the result of a WlanFullmacImpl::StartBss request.
5773    StartConf {
5774        payload: WlanFullmacImplIfcStartConfRequest,
5775        responder: WlanFullmacImplIfcStartConfResponder,
5776    },
5777    /// Report the result of a WlanFullmacImpl::StopBss request.
5778    StopConf {
5779        payload: WlanFullmacImplIfcStopConfRequest,
5780        responder: WlanFullmacImplIfcStopConfResponder,
5781    },
5782    /// Report the result of a EAPoL frame transmission (IEEE 802.11-2020 6.3.22.2).
5783    /// EAPoL frames are transmitted by the platform via WlanFullmacImpl::EapolTx.
5784    EapolConf {
5785        payload: WlanFullmacImplIfcEapolConfRequest,
5786        responder: WlanFullmacImplIfcEapolConfResponder,
5787    },
5788    OnChannelSwitch {
5789        ind: WlanFullmacChannelSwitchInfo,
5790        responder: WlanFullmacImplIfcOnChannelSwitchResponder,
5791    },
5792    SignalReport {
5793        ind: WlanFullmacSignalReportIndication,
5794        responder: WlanFullmacImplIfcSignalReportResponder,
5795    },
5796    /// Report that an EAPoL frame was received.
5797    EapolInd {
5798        payload: WlanFullmacImplIfcEapolIndRequest,
5799        responder: WlanFullmacImplIfcEapolIndResponder,
5800    },
5801    /// Inform the platform that the PMK is available after a driver-handled SAE handshake.
5802    OnPmkAvailable {
5803        payload: WlanFullmacImplIfcOnPmkAvailableRequest,
5804        responder: WlanFullmacImplIfcOnPmkAvailableResponder,
5805    },
5806    SaeHandshakeInd {
5807        payload: WlanFullmacImplIfcSaeHandshakeIndRequest,
5808        responder: WlanFullmacImplIfcSaeHandshakeIndResponder,
5809    },
5810    /// Receive an SAE authentication frame.
5811    SaeFrameRx { frame: SaeFrame, responder: WlanFullmacImplIfcSaeFrameRxResponder },
5812    OnWmmStatusResp {
5813        status: i32,
5814        wmm_params: fidl_fuchsia_wlan_common::WlanWmmParameters,
5815        responder: WlanFullmacImplIfcOnWmmStatusRespResponder,
5816    },
5817}
5818
5819impl WlanFullmacImplIfcRequest {
5820    #[allow(irrefutable_let_patterns)]
5821    pub fn into_on_scan_result(
5822        self,
5823    ) -> Option<(WlanFullmacImplIfcOnScanResultRequest, WlanFullmacImplIfcOnScanResultResponder)>
5824    {
5825        if let WlanFullmacImplIfcRequest::OnScanResult { payload, responder } = self {
5826            Some((payload, responder))
5827        } else {
5828            None
5829        }
5830    }
5831
5832    #[allow(irrefutable_let_patterns)]
5833    pub fn into_on_scan_end(
5834        self,
5835    ) -> Option<(WlanFullmacImplIfcOnScanEndRequest, WlanFullmacImplIfcOnScanEndResponder)> {
5836        if let WlanFullmacImplIfcRequest::OnScanEnd { payload, responder } = self {
5837            Some((payload, responder))
5838        } else {
5839            None
5840        }
5841    }
5842
5843    #[allow(irrefutable_let_patterns)]
5844    pub fn into_connect_conf(
5845        self,
5846    ) -> Option<(WlanFullmacImplIfcConnectConfRequest, WlanFullmacImplIfcConnectConfResponder)>
5847    {
5848        if let WlanFullmacImplIfcRequest::ConnectConf { payload, responder } = self {
5849            Some((payload, responder))
5850        } else {
5851            None
5852        }
5853    }
5854
5855    #[allow(irrefutable_let_patterns)]
5856    pub fn into_roam_conf(
5857        self,
5858    ) -> Option<(WlanFullmacImplIfcRoamConfRequest, WlanFullmacImplIfcRoamConfResponder)> {
5859        if let WlanFullmacImplIfcRequest::RoamConf { payload, responder } = self {
5860            Some((payload, responder))
5861        } else {
5862            None
5863        }
5864    }
5865
5866    #[allow(irrefutable_let_patterns)]
5867    pub fn into_roam_start_ind(
5868        self,
5869    ) -> Option<(WlanFullmacImplIfcRoamStartIndRequest, WlanFullmacImplIfcRoamStartIndResponder)>
5870    {
5871        if let WlanFullmacImplIfcRequest::RoamStartInd { payload, responder } = self {
5872            Some((payload, responder))
5873        } else {
5874            None
5875        }
5876    }
5877
5878    #[allow(irrefutable_let_patterns)]
5879    pub fn into_roam_result_ind(
5880        self,
5881    ) -> Option<(WlanFullmacImplIfcRoamResultIndRequest, WlanFullmacImplIfcRoamResultIndResponder)>
5882    {
5883        if let WlanFullmacImplIfcRequest::RoamResultInd { payload, responder } = self {
5884            Some((payload, responder))
5885        } else {
5886            None
5887        }
5888    }
5889
5890    #[allow(irrefutable_let_patterns)]
5891    pub fn into_auth_ind(
5892        self,
5893    ) -> Option<(WlanFullmacImplIfcAuthIndRequest, WlanFullmacImplIfcAuthIndResponder)> {
5894        if let WlanFullmacImplIfcRequest::AuthInd { payload, responder } = self {
5895            Some((payload, responder))
5896        } else {
5897            None
5898        }
5899    }
5900
5901    #[allow(irrefutable_let_patterns)]
5902    pub fn into_deauth_conf(
5903        self,
5904    ) -> Option<(WlanFullmacImplIfcDeauthConfRequest, WlanFullmacImplIfcDeauthConfResponder)> {
5905        if let WlanFullmacImplIfcRequest::DeauthConf { payload, responder } = self {
5906            Some((payload, responder))
5907        } else {
5908            None
5909        }
5910    }
5911
5912    #[allow(irrefutable_let_patterns)]
5913    pub fn into_deauth_ind(
5914        self,
5915    ) -> Option<(WlanFullmacImplIfcDeauthIndRequest, WlanFullmacImplIfcDeauthIndResponder)> {
5916        if let WlanFullmacImplIfcRequest::DeauthInd { payload, responder } = self {
5917            Some((payload, responder))
5918        } else {
5919            None
5920        }
5921    }
5922
5923    #[allow(irrefutable_let_patterns)]
5924    pub fn into_assoc_ind(
5925        self,
5926    ) -> Option<(WlanFullmacImplIfcAssocIndRequest, WlanFullmacImplIfcAssocIndResponder)> {
5927        if let WlanFullmacImplIfcRequest::AssocInd { payload, responder } = self {
5928            Some((payload, responder))
5929        } else {
5930            None
5931        }
5932    }
5933
5934    #[allow(irrefutable_let_patterns)]
5935    pub fn into_disassoc_conf(
5936        self,
5937    ) -> Option<(WlanFullmacImplIfcDisassocConfRequest, WlanFullmacImplIfcDisassocConfResponder)>
5938    {
5939        if let WlanFullmacImplIfcRequest::DisassocConf { payload, responder } = self {
5940            Some((payload, responder))
5941        } else {
5942            None
5943        }
5944    }
5945
5946    #[allow(irrefutable_let_patterns)]
5947    pub fn into_disassoc_ind(
5948        self,
5949    ) -> Option<(WlanFullmacImplIfcDisassocIndRequest, WlanFullmacImplIfcDisassocIndResponder)>
5950    {
5951        if let WlanFullmacImplIfcRequest::DisassocInd { payload, responder } = self {
5952            Some((payload, responder))
5953        } else {
5954            None
5955        }
5956    }
5957
5958    #[allow(irrefutable_let_patterns)]
5959    pub fn into_start_conf(
5960        self,
5961    ) -> Option<(WlanFullmacImplIfcStartConfRequest, WlanFullmacImplIfcStartConfResponder)> {
5962        if let WlanFullmacImplIfcRequest::StartConf { payload, responder } = self {
5963            Some((payload, responder))
5964        } else {
5965            None
5966        }
5967    }
5968
5969    #[allow(irrefutable_let_patterns)]
5970    pub fn into_stop_conf(
5971        self,
5972    ) -> Option<(WlanFullmacImplIfcStopConfRequest, WlanFullmacImplIfcStopConfResponder)> {
5973        if let WlanFullmacImplIfcRequest::StopConf { payload, responder } = self {
5974            Some((payload, responder))
5975        } else {
5976            None
5977        }
5978    }
5979
5980    #[allow(irrefutable_let_patterns)]
5981    pub fn into_eapol_conf(
5982        self,
5983    ) -> Option<(WlanFullmacImplIfcEapolConfRequest, WlanFullmacImplIfcEapolConfResponder)> {
5984        if let WlanFullmacImplIfcRequest::EapolConf { payload, responder } = self {
5985            Some((payload, responder))
5986        } else {
5987            None
5988        }
5989    }
5990
5991    #[allow(irrefutable_let_patterns)]
5992    pub fn into_on_channel_switch(
5993        self,
5994    ) -> Option<(WlanFullmacChannelSwitchInfo, WlanFullmacImplIfcOnChannelSwitchResponder)> {
5995        if let WlanFullmacImplIfcRequest::OnChannelSwitch { ind, responder } = self {
5996            Some((ind, responder))
5997        } else {
5998            None
5999        }
6000    }
6001
6002    #[allow(irrefutable_let_patterns)]
6003    pub fn into_signal_report(
6004        self,
6005    ) -> Option<(WlanFullmacSignalReportIndication, WlanFullmacImplIfcSignalReportResponder)> {
6006        if let WlanFullmacImplIfcRequest::SignalReport { ind, responder } = self {
6007            Some((ind, responder))
6008        } else {
6009            None
6010        }
6011    }
6012
6013    #[allow(irrefutable_let_patterns)]
6014    pub fn into_eapol_ind(
6015        self,
6016    ) -> Option<(WlanFullmacImplIfcEapolIndRequest, WlanFullmacImplIfcEapolIndResponder)> {
6017        if let WlanFullmacImplIfcRequest::EapolInd { payload, responder } = self {
6018            Some((payload, responder))
6019        } else {
6020            None
6021        }
6022    }
6023
6024    #[allow(irrefutable_let_patterns)]
6025    pub fn into_on_pmk_available(
6026        self,
6027    ) -> Option<(WlanFullmacImplIfcOnPmkAvailableRequest, WlanFullmacImplIfcOnPmkAvailableResponder)>
6028    {
6029        if let WlanFullmacImplIfcRequest::OnPmkAvailable { payload, responder } = self {
6030            Some((payload, responder))
6031        } else {
6032            None
6033        }
6034    }
6035
6036    #[allow(irrefutable_let_patterns)]
6037    pub fn into_sae_handshake_ind(
6038        self,
6039    ) -> Option<(
6040        WlanFullmacImplIfcSaeHandshakeIndRequest,
6041        WlanFullmacImplIfcSaeHandshakeIndResponder,
6042    )> {
6043        if let WlanFullmacImplIfcRequest::SaeHandshakeInd { payload, responder } = self {
6044            Some((payload, responder))
6045        } else {
6046            None
6047        }
6048    }
6049
6050    #[allow(irrefutable_let_patterns)]
6051    pub fn into_sae_frame_rx(self) -> Option<(SaeFrame, WlanFullmacImplIfcSaeFrameRxResponder)> {
6052        if let WlanFullmacImplIfcRequest::SaeFrameRx { frame, responder } = self {
6053            Some((frame, responder))
6054        } else {
6055            None
6056        }
6057    }
6058
6059    #[allow(irrefutable_let_patterns)]
6060    pub fn into_on_wmm_status_resp(
6061        self,
6062    ) -> Option<(
6063        i32,
6064        fidl_fuchsia_wlan_common::WlanWmmParameters,
6065        WlanFullmacImplIfcOnWmmStatusRespResponder,
6066    )> {
6067        if let WlanFullmacImplIfcRequest::OnWmmStatusResp { status, wmm_params, responder } = self {
6068            Some((status, wmm_params, responder))
6069        } else {
6070            None
6071        }
6072    }
6073
6074    /// Name of the method defined in FIDL
6075    pub fn method_name(&self) -> &'static str {
6076        match *self {
6077            WlanFullmacImplIfcRequest::OnScanResult { .. } => "on_scan_result",
6078            WlanFullmacImplIfcRequest::OnScanEnd { .. } => "on_scan_end",
6079            WlanFullmacImplIfcRequest::ConnectConf { .. } => "connect_conf",
6080            WlanFullmacImplIfcRequest::RoamConf { .. } => "roam_conf",
6081            WlanFullmacImplIfcRequest::RoamStartInd { .. } => "roam_start_ind",
6082            WlanFullmacImplIfcRequest::RoamResultInd { .. } => "roam_result_ind",
6083            WlanFullmacImplIfcRequest::AuthInd { .. } => "auth_ind",
6084            WlanFullmacImplIfcRequest::DeauthConf { .. } => "deauth_conf",
6085            WlanFullmacImplIfcRequest::DeauthInd { .. } => "deauth_ind",
6086            WlanFullmacImplIfcRequest::AssocInd { .. } => "assoc_ind",
6087            WlanFullmacImplIfcRequest::DisassocConf { .. } => "disassoc_conf",
6088            WlanFullmacImplIfcRequest::DisassocInd { .. } => "disassoc_ind",
6089            WlanFullmacImplIfcRequest::StartConf { .. } => "start_conf",
6090            WlanFullmacImplIfcRequest::StopConf { .. } => "stop_conf",
6091            WlanFullmacImplIfcRequest::EapolConf { .. } => "eapol_conf",
6092            WlanFullmacImplIfcRequest::OnChannelSwitch { .. } => "on_channel_switch",
6093            WlanFullmacImplIfcRequest::SignalReport { .. } => "signal_report",
6094            WlanFullmacImplIfcRequest::EapolInd { .. } => "eapol_ind",
6095            WlanFullmacImplIfcRequest::OnPmkAvailable { .. } => "on_pmk_available",
6096            WlanFullmacImplIfcRequest::SaeHandshakeInd { .. } => "sae_handshake_ind",
6097            WlanFullmacImplIfcRequest::SaeFrameRx { .. } => "sae_frame_rx",
6098            WlanFullmacImplIfcRequest::OnWmmStatusResp { .. } => "on_wmm_status_resp",
6099        }
6100    }
6101}
6102
6103#[derive(Debug, Clone)]
6104pub struct WlanFullmacImplIfcControlHandle {
6105    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
6106}
6107
6108impl fidl::endpoints::ControlHandle for WlanFullmacImplIfcControlHandle {
6109    fn shutdown(&self) {
6110        self.inner.shutdown()
6111    }
6112    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
6113        self.inner.shutdown_with_epitaph(status)
6114    }
6115
6116    fn is_closed(&self) -> bool {
6117        self.inner.channel().is_closed()
6118    }
6119    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
6120        self.inner.channel().on_closed()
6121    }
6122
6123    #[cfg(target_os = "fuchsia")]
6124    fn signal_peer(
6125        &self,
6126        clear_mask: zx::Signals,
6127        set_mask: zx::Signals,
6128    ) -> Result<(), zx_status::Status> {
6129        use fidl::Peered;
6130        self.inner.channel().signal_peer(clear_mask, set_mask)
6131    }
6132}
6133
6134impl WlanFullmacImplIfcControlHandle {}
6135
6136#[must_use = "FIDL methods require a response to be sent"]
6137#[derive(Debug)]
6138pub struct WlanFullmacImplIfcOnScanResultResponder {
6139    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6140    tx_id: u32,
6141}
6142
6143/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
6144/// if the responder is dropped without sending a response, so that the client
6145/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
6146impl std::ops::Drop for WlanFullmacImplIfcOnScanResultResponder {
6147    fn drop(&mut self) {
6148        self.control_handle.shutdown();
6149        // Safety: drops once, never accessed again
6150        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6151    }
6152}
6153
6154impl fidl::endpoints::Responder for WlanFullmacImplIfcOnScanResultResponder {
6155    type ControlHandle = WlanFullmacImplIfcControlHandle;
6156
6157    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6158        &self.control_handle
6159    }
6160
6161    fn drop_without_shutdown(mut self) {
6162        // Safety: drops once, never accessed again due to mem::forget
6163        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6164        // Prevent Drop from running (which would shut down the channel)
6165        std::mem::forget(self);
6166    }
6167}
6168
6169impl WlanFullmacImplIfcOnScanResultResponder {
6170    /// Sends a response to the FIDL transaction.
6171    ///
6172    /// Sets the channel to shutdown if an error occurs.
6173    pub fn send(self) -> Result<(), fidl::Error> {
6174        let _result = self.send_raw();
6175        if _result.is_err() {
6176            self.control_handle.shutdown();
6177        }
6178        self.drop_without_shutdown();
6179        _result
6180    }
6181
6182    /// Similar to "send" but does not shutdown the channel if an error occurs.
6183    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6184        let _result = self.send_raw();
6185        self.drop_without_shutdown();
6186        _result
6187    }
6188
6189    fn send_raw(&self) -> Result<(), fidl::Error> {
6190        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6191            (),
6192            self.tx_id,
6193            0x29aa81dc570f7a3e,
6194            fidl::encoding::DynamicFlags::empty(),
6195        )
6196    }
6197}
6198
6199#[must_use = "FIDL methods require a response to be sent"]
6200#[derive(Debug)]
6201pub struct WlanFullmacImplIfcOnScanEndResponder {
6202    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6203    tx_id: u32,
6204}
6205
6206/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
6207/// if the responder is dropped without sending a response, so that the client
6208/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
6209impl std::ops::Drop for WlanFullmacImplIfcOnScanEndResponder {
6210    fn drop(&mut self) {
6211        self.control_handle.shutdown();
6212        // Safety: drops once, never accessed again
6213        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6214    }
6215}
6216
6217impl fidl::endpoints::Responder for WlanFullmacImplIfcOnScanEndResponder {
6218    type ControlHandle = WlanFullmacImplIfcControlHandle;
6219
6220    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6221        &self.control_handle
6222    }
6223
6224    fn drop_without_shutdown(mut self) {
6225        // Safety: drops once, never accessed again due to mem::forget
6226        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6227        // Prevent Drop from running (which would shut down the channel)
6228        std::mem::forget(self);
6229    }
6230}
6231
6232impl WlanFullmacImplIfcOnScanEndResponder {
6233    /// Sends a response to the FIDL transaction.
6234    ///
6235    /// Sets the channel to shutdown if an error occurs.
6236    pub fn send(self) -> Result<(), fidl::Error> {
6237        let _result = self.send_raw();
6238        if _result.is_err() {
6239            self.control_handle.shutdown();
6240        }
6241        self.drop_without_shutdown();
6242        _result
6243    }
6244
6245    /// Similar to "send" but does not shutdown the channel if an error occurs.
6246    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6247        let _result = self.send_raw();
6248        self.drop_without_shutdown();
6249        _result
6250    }
6251
6252    fn send_raw(&self) -> Result<(), fidl::Error> {
6253        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6254            (),
6255            self.tx_id,
6256            0x7cd8aff80d27073c,
6257            fidl::encoding::DynamicFlags::empty(),
6258        )
6259    }
6260}
6261
6262#[must_use = "FIDL methods require a response to be sent"]
6263#[derive(Debug)]
6264pub struct WlanFullmacImplIfcConnectConfResponder {
6265    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6266    tx_id: u32,
6267}
6268
6269/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
6270/// if the responder is dropped without sending a response, so that the client
6271/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
6272impl std::ops::Drop for WlanFullmacImplIfcConnectConfResponder {
6273    fn drop(&mut self) {
6274        self.control_handle.shutdown();
6275        // Safety: drops once, never accessed again
6276        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6277    }
6278}
6279
6280impl fidl::endpoints::Responder for WlanFullmacImplIfcConnectConfResponder {
6281    type ControlHandle = WlanFullmacImplIfcControlHandle;
6282
6283    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6284        &self.control_handle
6285    }
6286
6287    fn drop_without_shutdown(mut self) {
6288        // Safety: drops once, never accessed again due to mem::forget
6289        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6290        // Prevent Drop from running (which would shut down the channel)
6291        std::mem::forget(self);
6292    }
6293}
6294
6295impl WlanFullmacImplIfcConnectConfResponder {
6296    /// Sends a response to the FIDL transaction.
6297    ///
6298    /// Sets the channel to shutdown if an error occurs.
6299    pub fn send(self) -> Result<(), fidl::Error> {
6300        let _result = self.send_raw();
6301        if _result.is_err() {
6302            self.control_handle.shutdown();
6303        }
6304        self.drop_without_shutdown();
6305        _result
6306    }
6307
6308    /// Similar to "send" but does not shutdown the channel if an error occurs.
6309    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6310        let _result = self.send_raw();
6311        self.drop_without_shutdown();
6312        _result
6313    }
6314
6315    fn send_raw(&self) -> Result<(), fidl::Error> {
6316        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6317            (),
6318            self.tx_id,
6319            0x3c22c6d80b2a2759,
6320            fidl::encoding::DynamicFlags::empty(),
6321        )
6322    }
6323}
6324
6325#[must_use = "FIDL methods require a response to be sent"]
6326#[derive(Debug)]
6327pub struct WlanFullmacImplIfcRoamConfResponder {
6328    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6329    tx_id: u32,
6330}
6331
6332/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
6333/// if the responder is dropped without sending a response, so that the client
6334/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
6335impl std::ops::Drop for WlanFullmacImplIfcRoamConfResponder {
6336    fn drop(&mut self) {
6337        self.control_handle.shutdown();
6338        // Safety: drops once, never accessed again
6339        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6340    }
6341}
6342
6343impl fidl::endpoints::Responder for WlanFullmacImplIfcRoamConfResponder {
6344    type ControlHandle = WlanFullmacImplIfcControlHandle;
6345
6346    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6347        &self.control_handle
6348    }
6349
6350    fn drop_without_shutdown(mut self) {
6351        // Safety: drops once, never accessed again due to mem::forget
6352        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6353        // Prevent Drop from running (which would shut down the channel)
6354        std::mem::forget(self);
6355    }
6356}
6357
6358impl WlanFullmacImplIfcRoamConfResponder {
6359    /// Sends a response to the FIDL transaction.
6360    ///
6361    /// Sets the channel to shutdown if an error occurs.
6362    pub fn send(self) -> Result<(), fidl::Error> {
6363        let _result = self.send_raw();
6364        if _result.is_err() {
6365            self.control_handle.shutdown();
6366        }
6367        self.drop_without_shutdown();
6368        _result
6369    }
6370
6371    /// Similar to "send" but does not shutdown the channel if an error occurs.
6372    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6373        let _result = self.send_raw();
6374        self.drop_without_shutdown();
6375        _result
6376    }
6377
6378    fn send_raw(&self) -> Result<(), fidl::Error> {
6379        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6380            (),
6381            self.tx_id,
6382            0x368b2a5b903b3f7b,
6383            fidl::encoding::DynamicFlags::empty(),
6384        )
6385    }
6386}
6387
6388#[must_use = "FIDL methods require a response to be sent"]
6389#[derive(Debug)]
6390pub struct WlanFullmacImplIfcRoamStartIndResponder {
6391    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6392    tx_id: u32,
6393}
6394
6395/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
6396/// if the responder is dropped without sending a response, so that the client
6397/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
6398impl std::ops::Drop for WlanFullmacImplIfcRoamStartIndResponder {
6399    fn drop(&mut self) {
6400        self.control_handle.shutdown();
6401        // Safety: drops once, never accessed again
6402        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6403    }
6404}
6405
6406impl fidl::endpoints::Responder for WlanFullmacImplIfcRoamStartIndResponder {
6407    type ControlHandle = WlanFullmacImplIfcControlHandle;
6408
6409    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6410        &self.control_handle
6411    }
6412
6413    fn drop_without_shutdown(mut self) {
6414        // Safety: drops once, never accessed again due to mem::forget
6415        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6416        // Prevent Drop from running (which would shut down the channel)
6417        std::mem::forget(self);
6418    }
6419}
6420
6421impl WlanFullmacImplIfcRoamStartIndResponder {
6422    /// Sends a response to the FIDL transaction.
6423    ///
6424    /// Sets the channel to shutdown if an error occurs.
6425    pub fn send(self) -> Result<(), fidl::Error> {
6426        let _result = self.send_raw();
6427        if _result.is_err() {
6428            self.control_handle.shutdown();
6429        }
6430        self.drop_without_shutdown();
6431        _result
6432    }
6433
6434    /// Similar to "send" but does not shutdown the channel if an error occurs.
6435    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6436        let _result = self.send_raw();
6437        self.drop_without_shutdown();
6438        _result
6439    }
6440
6441    fn send_raw(&self) -> Result<(), fidl::Error> {
6442        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6443            (),
6444            self.tx_id,
6445            0x23e1d9368935e7e4,
6446            fidl::encoding::DynamicFlags::empty(),
6447        )
6448    }
6449}
6450
6451#[must_use = "FIDL methods require a response to be sent"]
6452#[derive(Debug)]
6453pub struct WlanFullmacImplIfcRoamResultIndResponder {
6454    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6455    tx_id: u32,
6456}
6457
6458/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
6459/// if the responder is dropped without sending a response, so that the client
6460/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
6461impl std::ops::Drop for WlanFullmacImplIfcRoamResultIndResponder {
6462    fn drop(&mut self) {
6463        self.control_handle.shutdown();
6464        // Safety: drops once, never accessed again
6465        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6466    }
6467}
6468
6469impl fidl::endpoints::Responder for WlanFullmacImplIfcRoamResultIndResponder {
6470    type ControlHandle = WlanFullmacImplIfcControlHandle;
6471
6472    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6473        &self.control_handle
6474    }
6475
6476    fn drop_without_shutdown(mut self) {
6477        // Safety: drops once, never accessed again due to mem::forget
6478        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6479        // Prevent Drop from running (which would shut down the channel)
6480        std::mem::forget(self);
6481    }
6482}
6483
6484impl WlanFullmacImplIfcRoamResultIndResponder {
6485    /// Sends a response to the FIDL transaction.
6486    ///
6487    /// Sets the channel to shutdown if an error occurs.
6488    pub fn send(self) -> Result<(), fidl::Error> {
6489        let _result = self.send_raw();
6490        if _result.is_err() {
6491            self.control_handle.shutdown();
6492        }
6493        self.drop_without_shutdown();
6494        _result
6495    }
6496
6497    /// Similar to "send" but does not shutdown the channel if an error occurs.
6498    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6499        let _result = self.send_raw();
6500        self.drop_without_shutdown();
6501        _result
6502    }
6503
6504    fn send_raw(&self) -> Result<(), fidl::Error> {
6505        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6506            (),
6507            self.tx_id,
6508            0x7081c1b1ceea4914,
6509            fidl::encoding::DynamicFlags::empty(),
6510        )
6511    }
6512}
6513
6514#[must_use = "FIDL methods require a response to be sent"]
6515#[derive(Debug)]
6516pub struct WlanFullmacImplIfcAuthIndResponder {
6517    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6518    tx_id: u32,
6519}
6520
6521/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
6522/// if the responder is dropped without sending a response, so that the client
6523/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
6524impl std::ops::Drop for WlanFullmacImplIfcAuthIndResponder {
6525    fn drop(&mut self) {
6526        self.control_handle.shutdown();
6527        // Safety: drops once, never accessed again
6528        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6529    }
6530}
6531
6532impl fidl::endpoints::Responder for WlanFullmacImplIfcAuthIndResponder {
6533    type ControlHandle = WlanFullmacImplIfcControlHandle;
6534
6535    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6536        &self.control_handle
6537    }
6538
6539    fn drop_without_shutdown(mut self) {
6540        // Safety: drops once, never accessed again due to mem::forget
6541        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6542        // Prevent Drop from running (which would shut down the channel)
6543        std::mem::forget(self);
6544    }
6545}
6546
6547impl WlanFullmacImplIfcAuthIndResponder {
6548    /// Sends a response to the FIDL transaction.
6549    ///
6550    /// Sets the channel to shutdown if an error occurs.
6551    pub fn send(self) -> Result<(), fidl::Error> {
6552        let _result = self.send_raw();
6553        if _result.is_err() {
6554            self.control_handle.shutdown();
6555        }
6556        self.drop_without_shutdown();
6557        _result
6558    }
6559
6560    /// Similar to "send" but does not shutdown the channel if an error occurs.
6561    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6562        let _result = self.send_raw();
6563        self.drop_without_shutdown();
6564        _result
6565    }
6566
6567    fn send_raw(&self) -> Result<(), fidl::Error> {
6568        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6569            (),
6570            self.tx_id,
6571            0x270e1f8889650d0b,
6572            fidl::encoding::DynamicFlags::empty(),
6573        )
6574    }
6575}
6576
6577#[must_use = "FIDL methods require a response to be sent"]
6578#[derive(Debug)]
6579pub struct WlanFullmacImplIfcDeauthConfResponder {
6580    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6581    tx_id: u32,
6582}
6583
6584/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
6585/// if the responder is dropped without sending a response, so that the client
6586/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
6587impl std::ops::Drop for WlanFullmacImplIfcDeauthConfResponder {
6588    fn drop(&mut self) {
6589        self.control_handle.shutdown();
6590        // Safety: drops once, never accessed again
6591        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6592    }
6593}
6594
6595impl fidl::endpoints::Responder for WlanFullmacImplIfcDeauthConfResponder {
6596    type ControlHandle = WlanFullmacImplIfcControlHandle;
6597
6598    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6599        &self.control_handle
6600    }
6601
6602    fn drop_without_shutdown(mut self) {
6603        // Safety: drops once, never accessed again due to mem::forget
6604        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6605        // Prevent Drop from running (which would shut down the channel)
6606        std::mem::forget(self);
6607    }
6608}
6609
6610impl WlanFullmacImplIfcDeauthConfResponder {
6611    /// Sends a response to the FIDL transaction.
6612    ///
6613    /// Sets the channel to shutdown if an error occurs.
6614    pub fn send(self) -> Result<(), fidl::Error> {
6615        let _result = self.send_raw();
6616        if _result.is_err() {
6617            self.control_handle.shutdown();
6618        }
6619        self.drop_without_shutdown();
6620        _result
6621    }
6622
6623    /// Similar to "send" but does not shutdown the channel if an error occurs.
6624    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6625        let _result = self.send_raw();
6626        self.drop_without_shutdown();
6627        _result
6628    }
6629
6630    fn send_raw(&self) -> Result<(), fidl::Error> {
6631        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6632            (),
6633            self.tx_id,
6634            0x2c94b0d7258111b7,
6635            fidl::encoding::DynamicFlags::empty(),
6636        )
6637    }
6638}
6639
6640#[must_use = "FIDL methods require a response to be sent"]
6641#[derive(Debug)]
6642pub struct WlanFullmacImplIfcDeauthIndResponder {
6643    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6644    tx_id: u32,
6645}
6646
6647/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
6648/// if the responder is dropped without sending a response, so that the client
6649/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
6650impl std::ops::Drop for WlanFullmacImplIfcDeauthIndResponder {
6651    fn drop(&mut self) {
6652        self.control_handle.shutdown();
6653        // Safety: drops once, never accessed again
6654        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6655    }
6656}
6657
6658impl fidl::endpoints::Responder for WlanFullmacImplIfcDeauthIndResponder {
6659    type ControlHandle = WlanFullmacImplIfcControlHandle;
6660
6661    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6662        &self.control_handle
6663    }
6664
6665    fn drop_without_shutdown(mut self) {
6666        // Safety: drops once, never accessed again due to mem::forget
6667        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6668        // Prevent Drop from running (which would shut down the channel)
6669        std::mem::forget(self);
6670    }
6671}
6672
6673impl WlanFullmacImplIfcDeauthIndResponder {
6674    /// Sends a response to the FIDL transaction.
6675    ///
6676    /// Sets the channel to shutdown if an error occurs.
6677    pub fn send(self) -> Result<(), fidl::Error> {
6678        let _result = self.send_raw();
6679        if _result.is_err() {
6680            self.control_handle.shutdown();
6681        }
6682        self.drop_without_shutdown();
6683        _result
6684    }
6685
6686    /// Similar to "send" but does not shutdown the channel if an error occurs.
6687    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6688        let _result = self.send_raw();
6689        self.drop_without_shutdown();
6690        _result
6691    }
6692
6693    fn send_raw(&self) -> Result<(), fidl::Error> {
6694        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6695            (),
6696            self.tx_id,
6697            0x26cd27cdadd8dbaf,
6698            fidl::encoding::DynamicFlags::empty(),
6699        )
6700    }
6701}
6702
6703#[must_use = "FIDL methods require a response to be sent"]
6704#[derive(Debug)]
6705pub struct WlanFullmacImplIfcAssocIndResponder {
6706    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6707    tx_id: u32,
6708}
6709
6710/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
6711/// if the responder is dropped without sending a response, so that the client
6712/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
6713impl std::ops::Drop for WlanFullmacImplIfcAssocIndResponder {
6714    fn drop(&mut self) {
6715        self.control_handle.shutdown();
6716        // Safety: drops once, never accessed again
6717        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6718    }
6719}
6720
6721impl fidl::endpoints::Responder for WlanFullmacImplIfcAssocIndResponder {
6722    type ControlHandle = WlanFullmacImplIfcControlHandle;
6723
6724    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6725        &self.control_handle
6726    }
6727
6728    fn drop_without_shutdown(mut self) {
6729        // Safety: drops once, never accessed again due to mem::forget
6730        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6731        // Prevent Drop from running (which would shut down the channel)
6732        std::mem::forget(self);
6733    }
6734}
6735
6736impl WlanFullmacImplIfcAssocIndResponder {
6737    /// Sends a response to the FIDL transaction.
6738    ///
6739    /// Sets the channel to shutdown if an error occurs.
6740    pub fn send(self) -> Result<(), fidl::Error> {
6741        let _result = self.send_raw();
6742        if _result.is_err() {
6743            self.control_handle.shutdown();
6744        }
6745        self.drop_without_shutdown();
6746        _result
6747    }
6748
6749    /// Similar to "send" but does not shutdown the channel if an error occurs.
6750    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6751        let _result = self.send_raw();
6752        self.drop_without_shutdown();
6753        _result
6754    }
6755
6756    fn send_raw(&self) -> Result<(), fidl::Error> {
6757        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6758            (),
6759            self.tx_id,
6760            0x3e44529e3dc179ce,
6761            fidl::encoding::DynamicFlags::empty(),
6762        )
6763    }
6764}
6765
6766#[must_use = "FIDL methods require a response to be sent"]
6767#[derive(Debug)]
6768pub struct WlanFullmacImplIfcDisassocConfResponder {
6769    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6770    tx_id: u32,
6771}
6772
6773/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
6774/// if the responder is dropped without sending a response, so that the client
6775/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
6776impl std::ops::Drop for WlanFullmacImplIfcDisassocConfResponder {
6777    fn drop(&mut self) {
6778        self.control_handle.shutdown();
6779        // Safety: drops once, never accessed again
6780        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6781    }
6782}
6783
6784impl fidl::endpoints::Responder for WlanFullmacImplIfcDisassocConfResponder {
6785    type ControlHandle = WlanFullmacImplIfcControlHandle;
6786
6787    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6788        &self.control_handle
6789    }
6790
6791    fn drop_without_shutdown(mut self) {
6792        // Safety: drops once, never accessed again due to mem::forget
6793        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6794        // Prevent Drop from running (which would shut down the channel)
6795        std::mem::forget(self);
6796    }
6797}
6798
6799impl WlanFullmacImplIfcDisassocConfResponder {
6800    /// Sends a response to the FIDL transaction.
6801    ///
6802    /// Sets the channel to shutdown if an error occurs.
6803    pub fn send(self) -> Result<(), fidl::Error> {
6804        let _result = self.send_raw();
6805        if _result.is_err() {
6806            self.control_handle.shutdown();
6807        }
6808        self.drop_without_shutdown();
6809        _result
6810    }
6811
6812    /// Similar to "send" but does not shutdown the channel if an error occurs.
6813    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6814        let _result = self.send_raw();
6815        self.drop_without_shutdown();
6816        _result
6817    }
6818
6819    fn send_raw(&self) -> Result<(), fidl::Error> {
6820        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6821            (),
6822            self.tx_id,
6823            0x7c713bcd58a76cb3,
6824            fidl::encoding::DynamicFlags::empty(),
6825        )
6826    }
6827}
6828
6829#[must_use = "FIDL methods require a response to be sent"]
6830#[derive(Debug)]
6831pub struct WlanFullmacImplIfcDisassocIndResponder {
6832    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6833    tx_id: u32,
6834}
6835
6836/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
6837/// if the responder is dropped without sending a response, so that the client
6838/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
6839impl std::ops::Drop for WlanFullmacImplIfcDisassocIndResponder {
6840    fn drop(&mut self) {
6841        self.control_handle.shutdown();
6842        // Safety: drops once, never accessed again
6843        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6844    }
6845}
6846
6847impl fidl::endpoints::Responder for WlanFullmacImplIfcDisassocIndResponder {
6848    type ControlHandle = WlanFullmacImplIfcControlHandle;
6849
6850    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6851        &self.control_handle
6852    }
6853
6854    fn drop_without_shutdown(mut self) {
6855        // Safety: drops once, never accessed again due to mem::forget
6856        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6857        // Prevent Drop from running (which would shut down the channel)
6858        std::mem::forget(self);
6859    }
6860}
6861
6862impl WlanFullmacImplIfcDisassocIndResponder {
6863    /// Sends a response to the FIDL transaction.
6864    ///
6865    /// Sets the channel to shutdown if an error occurs.
6866    pub fn send(self) -> Result<(), fidl::Error> {
6867        let _result = self.send_raw();
6868        if _result.is_err() {
6869            self.control_handle.shutdown();
6870        }
6871        self.drop_without_shutdown();
6872        _result
6873    }
6874
6875    /// Similar to "send" but does not shutdown the channel if an error occurs.
6876    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6877        let _result = self.send_raw();
6878        self.drop_without_shutdown();
6879        _result
6880    }
6881
6882    fn send_raw(&self) -> Result<(), fidl::Error> {
6883        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6884            (),
6885            self.tx_id,
6886            0x6667b381b7f3990f,
6887            fidl::encoding::DynamicFlags::empty(),
6888        )
6889    }
6890}
6891
6892#[must_use = "FIDL methods require a response to be sent"]
6893#[derive(Debug)]
6894pub struct WlanFullmacImplIfcStartConfResponder {
6895    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6896    tx_id: u32,
6897}
6898
6899/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
6900/// if the responder is dropped without sending a response, so that the client
6901/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
6902impl std::ops::Drop for WlanFullmacImplIfcStartConfResponder {
6903    fn drop(&mut self) {
6904        self.control_handle.shutdown();
6905        // Safety: drops once, never accessed again
6906        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6907    }
6908}
6909
6910impl fidl::endpoints::Responder for WlanFullmacImplIfcStartConfResponder {
6911    type ControlHandle = WlanFullmacImplIfcControlHandle;
6912
6913    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6914        &self.control_handle
6915    }
6916
6917    fn drop_without_shutdown(mut self) {
6918        // Safety: drops once, never accessed again due to mem::forget
6919        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6920        // Prevent Drop from running (which would shut down the channel)
6921        std::mem::forget(self);
6922    }
6923}
6924
6925impl WlanFullmacImplIfcStartConfResponder {
6926    /// Sends a response to the FIDL transaction.
6927    ///
6928    /// Sets the channel to shutdown if an error occurs.
6929    pub fn send(self) -> Result<(), fidl::Error> {
6930        let _result = self.send_raw();
6931        if _result.is_err() {
6932            self.control_handle.shutdown();
6933        }
6934        self.drop_without_shutdown();
6935        _result
6936    }
6937
6938    /// Similar to "send" but does not shutdown the channel if an error occurs.
6939    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
6940        let _result = self.send_raw();
6941        self.drop_without_shutdown();
6942        _result
6943    }
6944
6945    fn send_raw(&self) -> Result<(), fidl::Error> {
6946        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
6947            (),
6948            self.tx_id,
6949            0x3e9b9641f3ddc7fc,
6950            fidl::encoding::DynamicFlags::empty(),
6951        )
6952    }
6953}
6954
6955#[must_use = "FIDL methods require a response to be sent"]
6956#[derive(Debug)]
6957pub struct WlanFullmacImplIfcStopConfResponder {
6958    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
6959    tx_id: u32,
6960}
6961
6962/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
6963/// if the responder is dropped without sending a response, so that the client
6964/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
6965impl std::ops::Drop for WlanFullmacImplIfcStopConfResponder {
6966    fn drop(&mut self) {
6967        self.control_handle.shutdown();
6968        // Safety: drops once, never accessed again
6969        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6970    }
6971}
6972
6973impl fidl::endpoints::Responder for WlanFullmacImplIfcStopConfResponder {
6974    type ControlHandle = WlanFullmacImplIfcControlHandle;
6975
6976    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
6977        &self.control_handle
6978    }
6979
6980    fn drop_without_shutdown(mut self) {
6981        // Safety: drops once, never accessed again due to mem::forget
6982        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
6983        // Prevent Drop from running (which would shut down the channel)
6984        std::mem::forget(self);
6985    }
6986}
6987
6988impl WlanFullmacImplIfcStopConfResponder {
6989    /// Sends a response to the FIDL transaction.
6990    ///
6991    /// Sets the channel to shutdown if an error occurs.
6992    pub fn send(self) -> Result<(), fidl::Error> {
6993        let _result = self.send_raw();
6994        if _result.is_err() {
6995            self.control_handle.shutdown();
6996        }
6997        self.drop_without_shutdown();
6998        _result
6999    }
7000
7001    /// Similar to "send" but does not shutdown the channel if an error occurs.
7002    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7003        let _result = self.send_raw();
7004        self.drop_without_shutdown();
7005        _result
7006    }
7007
7008    fn send_raw(&self) -> Result<(), fidl::Error> {
7009        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7010            (),
7011            self.tx_id,
7012            0x320a5ff227a4e9df,
7013            fidl::encoding::DynamicFlags::empty(),
7014        )
7015    }
7016}
7017
7018#[must_use = "FIDL methods require a response to be sent"]
7019#[derive(Debug)]
7020pub struct WlanFullmacImplIfcEapolConfResponder {
7021    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7022    tx_id: u32,
7023}
7024
7025/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
7026/// if the responder is dropped without sending a response, so that the client
7027/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
7028impl std::ops::Drop for WlanFullmacImplIfcEapolConfResponder {
7029    fn drop(&mut self) {
7030        self.control_handle.shutdown();
7031        // Safety: drops once, never accessed again
7032        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7033    }
7034}
7035
7036impl fidl::endpoints::Responder for WlanFullmacImplIfcEapolConfResponder {
7037    type ControlHandle = WlanFullmacImplIfcControlHandle;
7038
7039    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7040        &self.control_handle
7041    }
7042
7043    fn drop_without_shutdown(mut self) {
7044        // Safety: drops once, never accessed again due to mem::forget
7045        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7046        // Prevent Drop from running (which would shut down the channel)
7047        std::mem::forget(self);
7048    }
7049}
7050
7051impl WlanFullmacImplIfcEapolConfResponder {
7052    /// Sends a response to the FIDL transaction.
7053    ///
7054    /// Sets the channel to shutdown if an error occurs.
7055    pub fn send(self) -> Result<(), fidl::Error> {
7056        let _result = self.send_raw();
7057        if _result.is_err() {
7058            self.control_handle.shutdown();
7059        }
7060        self.drop_without_shutdown();
7061        _result
7062    }
7063
7064    /// Similar to "send" but does not shutdown the channel if an error occurs.
7065    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7066        let _result = self.send_raw();
7067        self.drop_without_shutdown();
7068        _result
7069    }
7070
7071    fn send_raw(&self) -> Result<(), fidl::Error> {
7072        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7073            (),
7074            self.tx_id,
7075            0x77364db9cc3970ec,
7076            fidl::encoding::DynamicFlags::empty(),
7077        )
7078    }
7079}
7080
7081#[must_use = "FIDL methods require a response to be sent"]
7082#[derive(Debug)]
7083pub struct WlanFullmacImplIfcOnChannelSwitchResponder {
7084    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7085    tx_id: u32,
7086}
7087
7088/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
7089/// if the responder is dropped without sending a response, so that the client
7090/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
7091impl std::ops::Drop for WlanFullmacImplIfcOnChannelSwitchResponder {
7092    fn drop(&mut self) {
7093        self.control_handle.shutdown();
7094        // Safety: drops once, never accessed again
7095        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7096    }
7097}
7098
7099impl fidl::endpoints::Responder for WlanFullmacImplIfcOnChannelSwitchResponder {
7100    type ControlHandle = WlanFullmacImplIfcControlHandle;
7101
7102    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7103        &self.control_handle
7104    }
7105
7106    fn drop_without_shutdown(mut self) {
7107        // Safety: drops once, never accessed again due to mem::forget
7108        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7109        // Prevent Drop from running (which would shut down the channel)
7110        std::mem::forget(self);
7111    }
7112}
7113
7114impl WlanFullmacImplIfcOnChannelSwitchResponder {
7115    /// Sends a response to the FIDL transaction.
7116    ///
7117    /// Sets the channel to shutdown if an error occurs.
7118    pub fn send(self) -> Result<(), fidl::Error> {
7119        let _result = self.send_raw();
7120        if _result.is_err() {
7121            self.control_handle.shutdown();
7122        }
7123        self.drop_without_shutdown();
7124        _result
7125    }
7126
7127    /// Similar to "send" but does not shutdown the channel if an error occurs.
7128    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7129        let _result = self.send_raw();
7130        self.drop_without_shutdown();
7131        _result
7132    }
7133
7134    fn send_raw(&self) -> Result<(), fidl::Error> {
7135        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7136            (),
7137            self.tx_id,
7138            0x21db0b8f71cae647,
7139            fidl::encoding::DynamicFlags::empty(),
7140        )
7141    }
7142}
7143
7144#[must_use = "FIDL methods require a response to be sent"]
7145#[derive(Debug)]
7146pub struct WlanFullmacImplIfcSignalReportResponder {
7147    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7148    tx_id: u32,
7149}
7150
7151/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
7152/// if the responder is dropped without sending a response, so that the client
7153/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
7154impl std::ops::Drop for WlanFullmacImplIfcSignalReportResponder {
7155    fn drop(&mut self) {
7156        self.control_handle.shutdown();
7157        // Safety: drops once, never accessed again
7158        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7159    }
7160}
7161
7162impl fidl::endpoints::Responder for WlanFullmacImplIfcSignalReportResponder {
7163    type ControlHandle = WlanFullmacImplIfcControlHandle;
7164
7165    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7166        &self.control_handle
7167    }
7168
7169    fn drop_without_shutdown(mut self) {
7170        // Safety: drops once, never accessed again due to mem::forget
7171        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7172        // Prevent Drop from running (which would shut down the channel)
7173        std::mem::forget(self);
7174    }
7175}
7176
7177impl WlanFullmacImplIfcSignalReportResponder {
7178    /// Sends a response to the FIDL transaction.
7179    ///
7180    /// Sets the channel to shutdown if an error occurs.
7181    pub fn send(self) -> Result<(), fidl::Error> {
7182        let _result = self.send_raw();
7183        if _result.is_err() {
7184            self.control_handle.shutdown();
7185        }
7186        self.drop_without_shutdown();
7187        _result
7188    }
7189
7190    /// Similar to "send" but does not shutdown the channel if an error occurs.
7191    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7192        let _result = self.send_raw();
7193        self.drop_without_shutdown();
7194        _result
7195    }
7196
7197    fn send_raw(&self) -> Result<(), fidl::Error> {
7198        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7199            (),
7200            self.tx_id,
7201            0x79679fa8789c3d9f,
7202            fidl::encoding::DynamicFlags::empty(),
7203        )
7204    }
7205}
7206
7207#[must_use = "FIDL methods require a response to be sent"]
7208#[derive(Debug)]
7209pub struct WlanFullmacImplIfcEapolIndResponder {
7210    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7211    tx_id: u32,
7212}
7213
7214/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
7215/// if the responder is dropped without sending a response, so that the client
7216/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
7217impl std::ops::Drop for WlanFullmacImplIfcEapolIndResponder {
7218    fn drop(&mut self) {
7219        self.control_handle.shutdown();
7220        // Safety: drops once, never accessed again
7221        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7222    }
7223}
7224
7225impl fidl::endpoints::Responder for WlanFullmacImplIfcEapolIndResponder {
7226    type ControlHandle = WlanFullmacImplIfcControlHandle;
7227
7228    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7229        &self.control_handle
7230    }
7231
7232    fn drop_without_shutdown(mut self) {
7233        // Safety: drops once, never accessed again due to mem::forget
7234        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7235        // Prevent Drop from running (which would shut down the channel)
7236        std::mem::forget(self);
7237    }
7238}
7239
7240impl WlanFullmacImplIfcEapolIndResponder {
7241    /// Sends a response to the FIDL transaction.
7242    ///
7243    /// Sets the channel to shutdown if an error occurs.
7244    pub fn send(self) -> Result<(), fidl::Error> {
7245        let _result = self.send_raw();
7246        if _result.is_err() {
7247            self.control_handle.shutdown();
7248        }
7249        self.drop_without_shutdown();
7250        _result
7251    }
7252
7253    /// Similar to "send" but does not shutdown the channel if an error occurs.
7254    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7255        let _result = self.send_raw();
7256        self.drop_without_shutdown();
7257        _result
7258    }
7259
7260    fn send_raw(&self) -> Result<(), fidl::Error> {
7261        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7262            (),
7263            self.tx_id,
7264            0x3de8ec1eda10d1d0,
7265            fidl::encoding::DynamicFlags::empty(),
7266        )
7267    }
7268}
7269
7270#[must_use = "FIDL methods require a response to be sent"]
7271#[derive(Debug)]
7272pub struct WlanFullmacImplIfcOnPmkAvailableResponder {
7273    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7274    tx_id: u32,
7275}
7276
7277/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
7278/// if the responder is dropped without sending a response, so that the client
7279/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
7280impl std::ops::Drop for WlanFullmacImplIfcOnPmkAvailableResponder {
7281    fn drop(&mut self) {
7282        self.control_handle.shutdown();
7283        // Safety: drops once, never accessed again
7284        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7285    }
7286}
7287
7288impl fidl::endpoints::Responder for WlanFullmacImplIfcOnPmkAvailableResponder {
7289    type ControlHandle = WlanFullmacImplIfcControlHandle;
7290
7291    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7292        &self.control_handle
7293    }
7294
7295    fn drop_without_shutdown(mut self) {
7296        // Safety: drops once, never accessed again due to mem::forget
7297        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7298        // Prevent Drop from running (which would shut down the channel)
7299        std::mem::forget(self);
7300    }
7301}
7302
7303impl WlanFullmacImplIfcOnPmkAvailableResponder {
7304    /// Sends a response to the FIDL transaction.
7305    ///
7306    /// Sets the channel to shutdown if an error occurs.
7307    pub fn send(self) -> Result<(), fidl::Error> {
7308        let _result = self.send_raw();
7309        if _result.is_err() {
7310            self.control_handle.shutdown();
7311        }
7312        self.drop_without_shutdown();
7313        _result
7314    }
7315
7316    /// Similar to "send" but does not shutdown the channel if an error occurs.
7317    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7318        let _result = self.send_raw();
7319        self.drop_without_shutdown();
7320        _result
7321    }
7322
7323    fn send_raw(&self) -> Result<(), fidl::Error> {
7324        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7325            (),
7326            self.tx_id,
7327            0x5cedd8d9be28a17e,
7328            fidl::encoding::DynamicFlags::empty(),
7329        )
7330    }
7331}
7332
7333#[must_use = "FIDL methods require a response to be sent"]
7334#[derive(Debug)]
7335pub struct WlanFullmacImplIfcSaeHandshakeIndResponder {
7336    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7337    tx_id: u32,
7338}
7339
7340/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
7341/// if the responder is dropped without sending a response, so that the client
7342/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
7343impl std::ops::Drop for WlanFullmacImplIfcSaeHandshakeIndResponder {
7344    fn drop(&mut self) {
7345        self.control_handle.shutdown();
7346        // Safety: drops once, never accessed again
7347        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7348    }
7349}
7350
7351impl fidl::endpoints::Responder for WlanFullmacImplIfcSaeHandshakeIndResponder {
7352    type ControlHandle = WlanFullmacImplIfcControlHandle;
7353
7354    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7355        &self.control_handle
7356    }
7357
7358    fn drop_without_shutdown(mut self) {
7359        // Safety: drops once, never accessed again due to mem::forget
7360        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7361        // Prevent Drop from running (which would shut down the channel)
7362        std::mem::forget(self);
7363    }
7364}
7365
7366impl WlanFullmacImplIfcSaeHandshakeIndResponder {
7367    /// Sends a response to the FIDL transaction.
7368    ///
7369    /// Sets the channel to shutdown if an error occurs.
7370    pub fn send(self) -> Result<(), fidl::Error> {
7371        let _result = self.send_raw();
7372        if _result.is_err() {
7373            self.control_handle.shutdown();
7374        }
7375        self.drop_without_shutdown();
7376        _result
7377    }
7378
7379    /// Similar to "send" but does not shutdown the channel if an error occurs.
7380    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7381        let _result = self.send_raw();
7382        self.drop_without_shutdown();
7383        _result
7384    }
7385
7386    fn send_raw(&self) -> Result<(), fidl::Error> {
7387        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7388            (),
7389            self.tx_id,
7390            0x4f3d53885503a1d8,
7391            fidl::encoding::DynamicFlags::empty(),
7392        )
7393    }
7394}
7395
7396#[must_use = "FIDL methods require a response to be sent"]
7397#[derive(Debug)]
7398pub struct WlanFullmacImplIfcSaeFrameRxResponder {
7399    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7400    tx_id: u32,
7401}
7402
7403/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
7404/// if the responder is dropped without sending a response, so that the client
7405/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
7406impl std::ops::Drop for WlanFullmacImplIfcSaeFrameRxResponder {
7407    fn drop(&mut self) {
7408        self.control_handle.shutdown();
7409        // Safety: drops once, never accessed again
7410        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7411    }
7412}
7413
7414impl fidl::endpoints::Responder for WlanFullmacImplIfcSaeFrameRxResponder {
7415    type ControlHandle = WlanFullmacImplIfcControlHandle;
7416
7417    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7418        &self.control_handle
7419    }
7420
7421    fn drop_without_shutdown(mut self) {
7422        // Safety: drops once, never accessed again due to mem::forget
7423        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7424        // Prevent Drop from running (which would shut down the channel)
7425        std::mem::forget(self);
7426    }
7427}
7428
7429impl WlanFullmacImplIfcSaeFrameRxResponder {
7430    /// Sends a response to the FIDL transaction.
7431    ///
7432    /// Sets the channel to shutdown if an error occurs.
7433    pub fn send(self) -> Result<(), fidl::Error> {
7434        let _result = self.send_raw();
7435        if _result.is_err() {
7436            self.control_handle.shutdown();
7437        }
7438        self.drop_without_shutdown();
7439        _result
7440    }
7441
7442    /// Similar to "send" but does not shutdown the channel if an error occurs.
7443    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7444        let _result = self.send_raw();
7445        self.drop_without_shutdown();
7446        _result
7447    }
7448
7449    fn send_raw(&self) -> Result<(), fidl::Error> {
7450        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7451            (),
7452            self.tx_id,
7453            0x51650906857ed4d4,
7454            fidl::encoding::DynamicFlags::empty(),
7455        )
7456    }
7457}
7458
7459#[must_use = "FIDL methods require a response to be sent"]
7460#[derive(Debug)]
7461pub struct WlanFullmacImplIfcOnWmmStatusRespResponder {
7462    control_handle: std::mem::ManuallyDrop<WlanFullmacImplIfcControlHandle>,
7463    tx_id: u32,
7464}
7465
7466/// Set the the channel to be shutdown (see [`WlanFullmacImplIfcControlHandle::shutdown`])
7467/// if the responder is dropped without sending a response, so that the client
7468/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
7469impl std::ops::Drop for WlanFullmacImplIfcOnWmmStatusRespResponder {
7470    fn drop(&mut self) {
7471        self.control_handle.shutdown();
7472        // Safety: drops once, never accessed again
7473        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7474    }
7475}
7476
7477impl fidl::endpoints::Responder for WlanFullmacImplIfcOnWmmStatusRespResponder {
7478    type ControlHandle = WlanFullmacImplIfcControlHandle;
7479
7480    fn control_handle(&self) -> &WlanFullmacImplIfcControlHandle {
7481        &self.control_handle
7482    }
7483
7484    fn drop_without_shutdown(mut self) {
7485        // Safety: drops once, never accessed again due to mem::forget
7486        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7487        // Prevent Drop from running (which would shut down the channel)
7488        std::mem::forget(self);
7489    }
7490}
7491
7492impl WlanFullmacImplIfcOnWmmStatusRespResponder {
7493    /// Sends a response to the FIDL transaction.
7494    ///
7495    /// Sets the channel to shutdown if an error occurs.
7496    pub fn send(self) -> Result<(), fidl::Error> {
7497        let _result = self.send_raw();
7498        if _result.is_err() {
7499            self.control_handle.shutdown();
7500        }
7501        self.drop_without_shutdown();
7502        _result
7503    }
7504
7505    /// Similar to "send" but does not shutdown the channel if an error occurs.
7506    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
7507        let _result = self.send_raw();
7508        self.drop_without_shutdown();
7509        _result
7510    }
7511
7512    fn send_raw(&self) -> Result<(), fidl::Error> {
7513        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
7514            (),
7515            self.tx_id,
7516            0x6823a88bf3ba8b2a,
7517            fidl::encoding::DynamicFlags::empty(),
7518        )
7519    }
7520}
7521
7522#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
7523pub struct ServiceMarker;
7524
7525#[cfg(target_os = "fuchsia")]
7526impl fidl::endpoints::ServiceMarker for ServiceMarker {
7527    type Proxy = ServiceProxy;
7528    type Request = ServiceRequest;
7529    const SERVICE_NAME: &'static str = "fuchsia.wlan.fullmac.Service";
7530}
7531
7532/// A request for one of the member protocols of Service.
7533///
7534#[cfg(target_os = "fuchsia")]
7535pub enum ServiceRequest {
7536    WlanFullmacImpl(WlanFullmacImpl_RequestStream),
7537}
7538
7539#[cfg(target_os = "fuchsia")]
7540impl fidl::endpoints::ServiceRequest for ServiceRequest {
7541    type Service = ServiceMarker;
7542
7543    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
7544        match name {
7545            "wlan_fullmac_impl" => Self::WlanFullmacImpl(
7546                <WlanFullmacImpl_RequestStream as fidl::endpoints::RequestStream>::from_channel(
7547                    _channel,
7548                ),
7549            ),
7550            _ => panic!("no such member protocol name for service Service"),
7551        }
7552    }
7553
7554    fn member_names() -> &'static [&'static str] {
7555        &["wlan_fullmac_impl"]
7556    }
7557}
7558#[cfg(target_os = "fuchsia")]
7559pub struct ServiceProxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);
7560
7561#[cfg(target_os = "fuchsia")]
7562impl fidl::endpoints::ServiceProxy for ServiceProxy {
7563    type Service = ServiceMarker;
7564
7565    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
7566        Self(opener)
7567    }
7568}
7569
7570#[cfg(target_os = "fuchsia")]
7571impl ServiceProxy {
7572    pub fn connect_to_wlan_fullmac_impl(&self) -> Result<WlanFullmacImpl_Proxy, fidl::Error> {
7573        let (proxy, server_end) = fidl::endpoints::create_proxy::<WlanFullmacImpl_Marker>();
7574        self.connect_channel_to_wlan_fullmac_impl(server_end)?;
7575        Ok(proxy)
7576    }
7577
7578    /// Like `connect_to_wlan_fullmac_impl`, but returns a sync proxy.
7579    /// See [`Self::connect_to_wlan_fullmac_impl`] for more details.
7580    pub fn connect_to_wlan_fullmac_impl_sync(
7581        &self,
7582    ) -> Result<WlanFullmacImpl_SynchronousProxy, fidl::Error> {
7583        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<WlanFullmacImpl_Marker>();
7584        self.connect_channel_to_wlan_fullmac_impl(server_end)?;
7585        Ok(proxy)
7586    }
7587
7588    /// Like `connect_to_wlan_fullmac_impl`, but accepts a server end.
7589    /// See [`Self::connect_to_wlan_fullmac_impl`] for more details.
7590    pub fn connect_channel_to_wlan_fullmac_impl(
7591        &self,
7592        server_end: fidl::endpoints::ServerEnd<WlanFullmacImpl_Marker>,
7593    ) -> Result<(), fidl::Error> {
7594        self.0.open_member("wlan_fullmac_impl", server_end.into_channel())
7595    }
7596
7597    pub fn instance_name(&self) -> &str {
7598        self.0.instance_name()
7599    }
7600}
7601
7602mod internal {
7603    use super::*;
7604
7605    impl WlanFullmacImplInitRequest {
7606        #[inline(always)]
7607        fn max_ordinal_present(&self) -> u64 {
7608            if let Some(_) = self.ifc {
7609                return 1;
7610            }
7611            0
7612        }
7613    }
7614
7615    impl fidl::encoding::ResourceTypeMarker for WlanFullmacImplInitRequest {
7616        type Borrowed<'a> = &'a mut Self;
7617        fn take_or_borrow<'a>(
7618            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7619        ) -> Self::Borrowed<'a> {
7620            value
7621        }
7622    }
7623
7624    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplInitRequest {
7625        type Owned = Self;
7626
7627        #[inline(always)]
7628        fn inline_align(_context: fidl::encoding::Context) -> usize {
7629            8
7630        }
7631
7632        #[inline(always)]
7633        fn inline_size(_context: fidl::encoding::Context) -> usize {
7634            16
7635        }
7636    }
7637
7638    unsafe impl
7639        fidl::encoding::Encode<
7640            WlanFullmacImplInitRequest,
7641            fidl::encoding::DefaultFuchsiaResourceDialect,
7642        > for &mut WlanFullmacImplInitRequest
7643    {
7644        unsafe fn encode(
7645            self,
7646            encoder: &mut fidl::encoding::Encoder<
7647                '_,
7648                fidl::encoding::DefaultFuchsiaResourceDialect,
7649            >,
7650            offset: usize,
7651            mut depth: fidl::encoding::Depth,
7652        ) -> fidl::Result<()> {
7653            encoder.debug_check_bounds::<WlanFullmacImplInitRequest>(offset);
7654            // Vector header
7655            let max_ordinal: u64 = self.max_ordinal_present();
7656            encoder.write_num(max_ordinal, offset);
7657            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7658            // Calling encoder.out_of_line_offset(0) is not allowed.
7659            if max_ordinal == 0 {
7660                return Ok(());
7661            }
7662            depth.increment()?;
7663            let envelope_size = 8;
7664            let bytes_len = max_ordinal as usize * envelope_size;
7665            #[allow(unused_variables)]
7666            let offset = encoder.out_of_line_offset(bytes_len);
7667            let mut _prev_end_offset: usize = 0;
7668            if 1 > max_ordinal {
7669                return Ok(());
7670            }
7671
7672            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7673            // are envelope_size bytes.
7674            let cur_offset: usize = (1 - 1) * envelope_size;
7675
7676            // Zero reserved fields.
7677            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7678
7679            // Safety:
7680            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7681            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7682            //   envelope_size bytes, there is always sufficient room.
7683            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<WlanFullmacImplIfcMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
7684            self.ifc.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<WlanFullmacImplIfcMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
7685            encoder, offset + cur_offset, depth
7686        )?;
7687
7688            _prev_end_offset = cur_offset + envelope_size;
7689
7690            Ok(())
7691        }
7692    }
7693
7694    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7695        for WlanFullmacImplInitRequest
7696    {
7697        #[inline(always)]
7698        fn new_empty() -> Self {
7699            Self::default()
7700        }
7701
7702        unsafe fn decode(
7703            &mut self,
7704            decoder: &mut fidl::encoding::Decoder<
7705                '_,
7706                fidl::encoding::DefaultFuchsiaResourceDialect,
7707            >,
7708            offset: usize,
7709            mut depth: fidl::encoding::Depth,
7710        ) -> fidl::Result<()> {
7711            decoder.debug_check_bounds::<Self>(offset);
7712            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7713                None => return Err(fidl::Error::NotNullable),
7714                Some(len) => len,
7715            };
7716            // Calling decoder.out_of_line_offset(0) is not allowed.
7717            if len == 0 {
7718                return Ok(());
7719            };
7720            depth.increment()?;
7721            let envelope_size = 8;
7722            let bytes_len = len * envelope_size;
7723            let offset = decoder.out_of_line_offset(bytes_len)?;
7724            // Decode the envelope for each type.
7725            let mut _next_ordinal_to_read = 0;
7726            let mut next_offset = offset;
7727            let end_offset = offset + bytes_len;
7728            _next_ordinal_to_read += 1;
7729            if next_offset >= end_offset {
7730                return Ok(());
7731            }
7732
7733            // Decode unknown envelopes for gaps in ordinals.
7734            while _next_ordinal_to_read < 1 {
7735                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7736                _next_ordinal_to_read += 1;
7737                next_offset += envelope_size;
7738            }
7739
7740            let next_out_of_line = decoder.next_out_of_line();
7741            let handles_before = decoder.remaining_handles();
7742            if let Some((inlined, num_bytes, num_handles)) =
7743                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7744            {
7745                let member_inline_size = <fidl::encoding::Endpoint<
7746                    fidl::endpoints::ClientEnd<WlanFullmacImplIfcMarker>,
7747                > as fidl::encoding::TypeMarker>::inline_size(
7748                    decoder.context
7749                );
7750                if inlined != (member_inline_size <= 4) {
7751                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7752                }
7753                let inner_offset;
7754                let mut inner_depth = depth.clone();
7755                if inlined {
7756                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7757                    inner_offset = next_offset;
7758                } else {
7759                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7760                    inner_depth.increment()?;
7761                }
7762                let val_ref = self.ifc.get_or_insert_with(|| {
7763                    fidl::new_empty!(
7764                        fidl::encoding::Endpoint<
7765                            fidl::endpoints::ClientEnd<WlanFullmacImplIfcMarker>,
7766                        >,
7767                        fidl::encoding::DefaultFuchsiaResourceDialect
7768                    )
7769                });
7770                fidl::decode!(
7771                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<WlanFullmacImplIfcMarker>>,
7772                    fidl::encoding::DefaultFuchsiaResourceDialect,
7773                    val_ref,
7774                    decoder,
7775                    inner_offset,
7776                    inner_depth
7777                )?;
7778                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7779                {
7780                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7781                }
7782                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7783                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7784                }
7785            }
7786
7787            next_offset += envelope_size;
7788
7789            // Decode the remaining unknown envelopes.
7790            while next_offset < end_offset {
7791                _next_ordinal_to_read += 1;
7792                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7793                next_offset += envelope_size;
7794            }
7795
7796            Ok(())
7797        }
7798    }
7799
7800    impl WlanFullmacImplInitResponse {
7801        #[inline(always)]
7802        fn max_ordinal_present(&self) -> u64 {
7803            if let Some(_) = self.sme_channel {
7804                return 1;
7805            }
7806            0
7807        }
7808    }
7809
7810    impl fidl::encoding::ResourceTypeMarker for WlanFullmacImplInitResponse {
7811        type Borrowed<'a> = &'a mut Self;
7812        fn take_or_borrow<'a>(
7813            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7814        ) -> Self::Borrowed<'a> {
7815            value
7816        }
7817    }
7818
7819    unsafe impl fidl::encoding::TypeMarker for WlanFullmacImplInitResponse {
7820        type Owned = Self;
7821
7822        #[inline(always)]
7823        fn inline_align(_context: fidl::encoding::Context) -> usize {
7824            8
7825        }
7826
7827        #[inline(always)]
7828        fn inline_size(_context: fidl::encoding::Context) -> usize {
7829            16
7830        }
7831    }
7832
7833    unsafe impl
7834        fidl::encoding::Encode<
7835            WlanFullmacImplInitResponse,
7836            fidl::encoding::DefaultFuchsiaResourceDialect,
7837        > for &mut WlanFullmacImplInitResponse
7838    {
7839        unsafe fn encode(
7840            self,
7841            encoder: &mut fidl::encoding::Encoder<
7842                '_,
7843                fidl::encoding::DefaultFuchsiaResourceDialect,
7844            >,
7845            offset: usize,
7846            mut depth: fidl::encoding::Depth,
7847        ) -> fidl::Result<()> {
7848            encoder.debug_check_bounds::<WlanFullmacImplInitResponse>(offset);
7849            // Vector header
7850            let max_ordinal: u64 = self.max_ordinal_present();
7851            encoder.write_num(max_ordinal, offset);
7852            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7853            // Calling encoder.out_of_line_offset(0) is not allowed.
7854            if max_ordinal == 0 {
7855                return Ok(());
7856            }
7857            depth.increment()?;
7858            let envelope_size = 8;
7859            let bytes_len = max_ordinal as usize * envelope_size;
7860            #[allow(unused_variables)]
7861            let offset = encoder.out_of_line_offset(bytes_len);
7862            let mut _prev_end_offset: usize = 0;
7863            if 1 > max_ordinal {
7864                return Ok(());
7865            }
7866
7867            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7868            // are envelope_size bytes.
7869            let cur_offset: usize = (1 - 1) * envelope_size;
7870
7871            // Zero reserved fields.
7872            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7873
7874            // Safety:
7875            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7876            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7877            //   envelope_size bytes, there is always sufficient room.
7878            fidl::encoding::encode_in_envelope_optional::<
7879                fidl::encoding::HandleType<
7880                    fidl::Channel,
7881                    { fidl::ObjectType::CHANNEL.into_raw() },
7882                    2147483648,
7883                >,
7884                fidl::encoding::DefaultFuchsiaResourceDialect,
7885            >(
7886                self.sme_channel.as_mut().map(
7887                    <fidl::encoding::HandleType<
7888                        fidl::Channel,
7889                        { fidl::ObjectType::CHANNEL.into_raw() },
7890                        2147483648,
7891                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
7892                ),
7893                encoder,
7894                offset + cur_offset,
7895                depth,
7896            )?;
7897
7898            _prev_end_offset = cur_offset + envelope_size;
7899
7900            Ok(())
7901        }
7902    }
7903
7904    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7905        for WlanFullmacImplInitResponse
7906    {
7907        #[inline(always)]
7908        fn new_empty() -> Self {
7909            Self::default()
7910        }
7911
7912        unsafe fn decode(
7913            &mut self,
7914            decoder: &mut fidl::encoding::Decoder<
7915                '_,
7916                fidl::encoding::DefaultFuchsiaResourceDialect,
7917            >,
7918            offset: usize,
7919            mut depth: fidl::encoding::Depth,
7920        ) -> fidl::Result<()> {
7921            decoder.debug_check_bounds::<Self>(offset);
7922            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7923                None => return Err(fidl::Error::NotNullable),
7924                Some(len) => len,
7925            };
7926            // Calling decoder.out_of_line_offset(0) is not allowed.
7927            if len == 0 {
7928                return Ok(());
7929            };
7930            depth.increment()?;
7931            let envelope_size = 8;
7932            let bytes_len = len * envelope_size;
7933            let offset = decoder.out_of_line_offset(bytes_len)?;
7934            // Decode the envelope for each type.
7935            let mut _next_ordinal_to_read = 0;
7936            let mut next_offset = offset;
7937            let end_offset = offset + bytes_len;
7938            _next_ordinal_to_read += 1;
7939            if next_offset >= end_offset {
7940                return Ok(());
7941            }
7942
7943            // Decode unknown envelopes for gaps in ordinals.
7944            while _next_ordinal_to_read < 1 {
7945                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7946                _next_ordinal_to_read += 1;
7947                next_offset += envelope_size;
7948            }
7949
7950            let next_out_of_line = decoder.next_out_of_line();
7951            let handles_before = decoder.remaining_handles();
7952            if let Some((inlined, num_bytes, num_handles)) =
7953                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7954            {
7955                let member_inline_size = <fidl::encoding::HandleType<
7956                    fidl::Channel,
7957                    { fidl::ObjectType::CHANNEL.into_raw() },
7958                    2147483648,
7959                > as fidl::encoding::TypeMarker>::inline_size(
7960                    decoder.context
7961                );
7962                if inlined != (member_inline_size <= 4) {
7963                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7964                }
7965                let inner_offset;
7966                let mut inner_depth = depth.clone();
7967                if inlined {
7968                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7969                    inner_offset = next_offset;
7970                } else {
7971                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7972                    inner_depth.increment()?;
7973                }
7974                let val_ref =
7975                self.sme_channel.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
7976                fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
7977                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7978                {
7979                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7980                }
7981                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7982                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7983                }
7984            }
7985
7986            next_offset += envelope_size;
7987
7988            // Decode the remaining unknown envelopes.
7989            while next_offset < end_offset {
7990                _next_ordinal_to_read += 1;
7991                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7992                next_offset += envelope_size;
7993            }
7994
7995            Ok(())
7996        }
7997    }
7998}