fidl_fuchsia_wlan_fullmac/
fidl_fuchsia_wlan_fullmac.rs

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

fidl_fuchsia_wlan_fullmac/
fidl_fuchsia_wlan_fullmac.rs
