1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 pub type MacAddr = [u8; 6];
8
9 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
10 #[repr(u32)]
11 pub enum BssType {
12 Unknown = 0,
13 Infrastructure = 1,
14 Independent = 2,
15 Mesh = 3,
16 Personal = 4,
17 UnknownOrdinal_(u32) = 5,
18 }
19 impl ::std::convert::From<u32> for BssType {
20 fn from(value: u32) -> Self {
21 match value {
22 0 => Self::Unknown,
23 1 => Self::Infrastructure,
24 2 => Self::Independent,
25 3 => Self::Mesh,
26 4 => Self::Personal,
27
28 _ => Self::UnknownOrdinal_(value),
29 }
30 }
31 }
32
33 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BssType, ___E> for BssType
34 where
35 ___E: ?Sized,
36 {
37 #[inline]
38 fn encode(
39 self,
40 encoder: &mut ___E,
41 out: &mut ::core::mem::MaybeUninit<crate::wire::BssType>,
42 _: (),
43 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
44 ::fidl_next::Encode::encode(&self, encoder, out, ())
45 }
46 }
47
48 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::BssType, ___E> for &'a BssType
49 where
50 ___E: ?Sized,
51 {
52 #[inline]
53 fn encode(
54 self,
55 encoder: &mut ___E,
56 out: &mut ::core::mem::MaybeUninit<crate::wire::BssType>,
57 _: (),
58 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
59 ::fidl_next::munge!(let crate::wire::BssType { value } = out);
60 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
61 BssType::Unknown => 0,
62
63 BssType::Infrastructure => 1,
64
65 BssType::Independent => 2,
66
67 BssType::Mesh => 3,
68
69 BssType::Personal => 4,
70
71 BssType::UnknownOrdinal_(value) => value,
72 }));
73
74 Ok(())
75 }
76 }
77
78 impl ::core::convert::From<crate::wire::BssType> for BssType {
79 fn from(wire: crate::wire::BssType) -> Self {
80 match u32::from(wire.value) {
81 0 => Self::Unknown,
82
83 1 => Self::Infrastructure,
84
85 2 => Self::Independent,
86
87 3 => Self::Mesh,
88
89 4 => Self::Personal,
90
91 value => Self::UnknownOrdinal_(value),
92 }
93 }
94 }
95
96 impl ::fidl_next::FromWire<crate::wire::BssType> for BssType {
97 #[inline]
98 fn from_wire(wire: crate::wire::BssType) -> Self {
99 Self::from(wire)
100 }
101 }
102
103 impl ::fidl_next::FromWireRef<crate::wire::BssType> for BssType {
104 #[inline]
105 fn from_wire_ref(wire: &crate::wire::BssType) -> Self {
106 Self::from(*wire)
107 }
108 }
109
110 #[doc = " Corresponds to the Capability Information field defined by IEEE Std 802.11-2020, 9.4.1.4.\n This contains subfields that indicate support for requested or optional capabilities.\n\n TODO(https://fxbug.dev/367315525) Consider making this a bitfield.\n"]
111 pub type CapabilityInfo = u16;
112
113 #[doc = " Channel width is derived from the HT operation and VHT operation IEs,\n or defaults to 20 MHz if not specified explicitly\n\n IEEE Std 802.11-2016, Table 9-153 - HT/VHT Operation Information subfields\n"]
114 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
115 #[repr(u32)]
116 pub enum ChannelBandwidth {
117 Cbw20 = 1,
118 Cbw40 = 2,
119 Cbw40Below = 3,
120 Cbw80 = 4,
121 Cbw160 = 5,
122 Cbw80P80 = 6,
123 UnknownOrdinal_(u32) = 7,
124 }
125 impl ::std::convert::From<u32> for ChannelBandwidth {
126 fn from(value: u32) -> Self {
127 match value {
128 1 => Self::Cbw20,
129 2 => Self::Cbw40,
130 3 => Self::Cbw40Below,
131 4 => Self::Cbw80,
132 5 => Self::Cbw160,
133 6 => Self::Cbw80P80,
134
135 _ => Self::UnknownOrdinal_(value),
136 }
137 }
138 }
139
140 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ChannelBandwidth, ___E> for ChannelBandwidth
141 where
142 ___E: ?Sized,
143 {
144 #[inline]
145 fn encode(
146 self,
147 encoder: &mut ___E,
148 out: &mut ::core::mem::MaybeUninit<crate::wire::ChannelBandwidth>,
149 _: (),
150 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
151 ::fidl_next::Encode::encode(&self, encoder, out, ())
152 }
153 }
154
155 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ChannelBandwidth, ___E>
156 for &'a ChannelBandwidth
157 where
158 ___E: ?Sized,
159 {
160 #[inline]
161 fn encode(
162 self,
163 encoder: &mut ___E,
164 out: &mut ::core::mem::MaybeUninit<crate::wire::ChannelBandwidth>,
165 _: (),
166 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
167 ::fidl_next::munge!(let crate::wire::ChannelBandwidth { value } = out);
168 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
169 ChannelBandwidth::Cbw20 => 1,
170
171 ChannelBandwidth::Cbw40 => 2,
172
173 ChannelBandwidth::Cbw40Below => 3,
174
175 ChannelBandwidth::Cbw80 => 4,
176
177 ChannelBandwidth::Cbw160 => 5,
178
179 ChannelBandwidth::Cbw80P80 => 6,
180
181 ChannelBandwidth::UnknownOrdinal_(value) => value,
182 }));
183
184 Ok(())
185 }
186 }
187
188 impl ::core::convert::From<crate::wire::ChannelBandwidth> for ChannelBandwidth {
189 fn from(wire: crate::wire::ChannelBandwidth) -> Self {
190 match u32::from(wire.value) {
191 1 => Self::Cbw20,
192
193 2 => Self::Cbw40,
194
195 3 => Self::Cbw40Below,
196
197 4 => Self::Cbw80,
198
199 5 => Self::Cbw160,
200
201 6 => Self::Cbw80P80,
202
203 value => Self::UnknownOrdinal_(value),
204 }
205 }
206 }
207
208 impl ::fidl_next::FromWire<crate::wire::ChannelBandwidth> for ChannelBandwidth {
209 #[inline]
210 fn from_wire(wire: crate::wire::ChannelBandwidth) -> Self {
211 Self::from(wire)
212 }
213 }
214
215 impl ::fidl_next::FromWireRef<crate::wire::ChannelBandwidth> for ChannelBandwidth {
216 #[inline]
217 fn from_wire_ref(wire: &crate::wire::ChannelBandwidth) -> Self {
218 Self::from(*wire)
219 }
220 }
221
222 #[doc = " Channel information derived from the DSSS parameter set, HT operation,\n and VHT operation IEs, as well as the primary channel on which a frame\n is received.\n\n IEEE Std 802.11-2016, 9.4.2.4 - DSSS Parameter Set element\n IEEE Std 802.11-2016, 9.4.2.57 - HT Operation element\n IEEE Std 802.11-2016, 9.4.2.159 - VHT Operation element\n"]
223 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
224 pub struct WlanChannel {
225 pub primary: u8,
226
227 pub cbw: crate::natural::ChannelBandwidth,
228
229 pub secondary80: u8,
230 }
231
232 unsafe impl<___E> ::fidl_next::Encode<crate::wire::WlanChannel, ___E> for WlanChannel
233 where
234 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
235 {
236 #[inline]
237 fn encode(
238 self,
239 encoder_: &mut ___E,
240 out_: &mut ::core::mem::MaybeUninit<crate::wire::WlanChannel>,
241 _: (),
242 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
243 ::fidl_next::munge! {
244 let crate::wire::WlanChannel {
245 primary,
246 cbw,
247 secondary80,
248
249 } = out_;
250 }
251
252 ::fidl_next::Encode::encode(self.primary, encoder_, primary, ())?;
253
254 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(primary.as_mut_ptr()) };
255
256 ::fidl_next::Encode::encode(self.cbw, encoder_, cbw, ())?;
257
258 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(cbw.as_mut_ptr()) };
259
260 ::fidl_next::Encode::encode(self.secondary80, encoder_, secondary80, ())?;
261
262 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(secondary80.as_mut_ptr()) };
263
264 Ok(())
265 }
266 }
267
268 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WlanChannel, ___E> for &'a WlanChannel
269 where
270 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
271 {
272 #[inline]
273 fn encode(
274 self,
275 encoder_: &mut ___E,
276 out_: &mut ::core::mem::MaybeUninit<crate::wire::WlanChannel>,
277 _: (),
278 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
279 ::fidl_next::munge! {
280 let crate::wire::WlanChannel {
281 primary,
282 cbw,
283 secondary80,
284
285 } = out_;
286 }
287
288 ::fidl_next::Encode::encode(&self.primary, encoder_, primary, ())?;
289
290 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(primary.as_mut_ptr()) };
291
292 ::fidl_next::Encode::encode(&self.cbw, encoder_, cbw, ())?;
293
294 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(cbw.as_mut_ptr()) };
295
296 ::fidl_next::Encode::encode(&self.secondary80, encoder_, secondary80, ())?;
297
298 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(secondary80.as_mut_ptr()) };
299
300 Ok(())
301 }
302 }
303
304 unsafe impl<___E>
305 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::WlanChannel>, ___E>
306 for WlanChannel
307 where
308 ___E: ::fidl_next::Encoder + ?Sized,
309 WlanChannel: ::fidl_next::Encode<crate::wire::WlanChannel, ___E>,
310 {
311 #[inline]
312 fn encode_option(
313 this: ::core::option::Option<Self>,
314 encoder: &mut ___E,
315 out: &mut ::core::mem::MaybeUninit<
316 ::fidl_next::wire::Box<'static, crate::wire::WlanChannel>,
317 >,
318 _: (),
319 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
320 if let Some(inner) = this {
321 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
322 ::fidl_next::wire::Box::encode_present(out);
323 } else {
324 ::fidl_next::wire::Box::encode_absent(out);
325 }
326
327 Ok(())
328 }
329 }
330
331 unsafe impl<'a, ___E>
332 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::WlanChannel>, ___E>
333 for &'a WlanChannel
334 where
335 ___E: ::fidl_next::Encoder + ?Sized,
336 &'a WlanChannel: ::fidl_next::Encode<crate::wire::WlanChannel, ___E>,
337 {
338 #[inline]
339 fn encode_option(
340 this: ::core::option::Option<Self>,
341 encoder: &mut ___E,
342 out: &mut ::core::mem::MaybeUninit<
343 ::fidl_next::wire::Box<'static, crate::wire::WlanChannel>,
344 >,
345 _: (),
346 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
347 if let Some(inner) = this {
348 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
349 ::fidl_next::wire::Box::encode_present(out);
350 } else {
351 ::fidl_next::wire::Box::encode_absent(out);
352 }
353
354 Ok(())
355 }
356 }
357
358 impl ::fidl_next::FromWire<crate::wire::WlanChannel> for WlanChannel {
359 #[inline]
360 fn from_wire(wire: crate::wire::WlanChannel) -> Self {
361 Self {
362 primary: ::fidl_next::FromWire::from_wire(wire.primary),
363
364 cbw: ::fidl_next::FromWire::from_wire(wire.cbw),
365
366 secondary80: ::fidl_next::FromWire::from_wire(wire.secondary80),
367 }
368 }
369 }
370
371 impl ::fidl_next::FromWireRef<crate::wire::WlanChannel> for WlanChannel {
372 #[inline]
373 fn from_wire_ref(wire: &crate::wire::WlanChannel) -> Self {
374 Self {
375 primary: ::fidl_next::FromWireRef::from_wire_ref(&wire.primary),
376
377 cbw: ::fidl_next::FromWireRef::from_wire_ref(&wire.cbw),
378
379 secondary80: ::fidl_next::FromWireRef::from_wire_ref(&wire.secondary80),
380 }
381 }
382 }
383
384 #[doc = " Type corresponding to a BSSDescription defined by IEEE Std 802.11-2020 6.3.3.3.2\n\n This type only includes explicit fields for information frequently required\n from a BSSDescription. All other fields are left in a raw buffer of IEs as\n received in an advertisement from the AP, e.g., from a Beacon or Probe\n Response frame.\n\n The inclusion of a raw buffer of IEs ensures this type always includes all\n the information an AP advertises, no matter the version of Fuchsia the\n advertisement was received in.\n"]
385 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
386 pub struct BssDescription {
387 pub bssid: [u8; 6],
388
389 pub bss_type: crate::natural::BssType,
390
391 pub beacon_period: u16,
392
393 pub capability_info: u16,
394
395 pub ies: ::std::vec::Vec<u8>,
396
397 pub channel: crate::natural::WlanChannel,
398
399 pub rssi_dbm: i8,
400
401 pub snr_db: i8,
402 }
403
404 unsafe impl<___E> ::fidl_next::Encode<crate::wire::BssDescription<'static>, ___E> for BssDescription
405 where
406 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
407 ___E: ::fidl_next::Encoder,
408 {
409 #[inline]
410 fn encode(
411 self,
412 encoder_: &mut ___E,
413 out_: &mut ::core::mem::MaybeUninit<crate::wire::BssDescription<'static>>,
414 _: (),
415 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
416 ::fidl_next::munge! {
417 let crate::wire::BssDescription {
418 bssid,
419 bss_type,
420 beacon_period,
421 capability_info,
422 ies,
423 channel,
424 rssi_dbm,
425 snr_db,
426
427 } = out_;
428 }
429
430 ::fidl_next::Encode::encode(self.bssid, encoder_, bssid, ())?;
431
432 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bssid.as_mut_ptr()) };
433
434 ::fidl_next::Encode::encode(self.bss_type, encoder_, bss_type, ())?;
435
436 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bss_type.as_mut_ptr()) };
437
438 ::fidl_next::Encode::encode(self.beacon_period, encoder_, beacon_period, ())?;
439
440 let mut _field =
441 unsafe { ::fidl_next::Slot::new_unchecked(beacon_period.as_mut_ptr()) };
442
443 ::fidl_next::Encode::encode(self.capability_info, encoder_, capability_info, ())?;
444
445 let mut _field =
446 unsafe { ::fidl_next::Slot::new_unchecked(capability_info.as_mut_ptr()) };
447
448 ::fidl_next::Encode::encode(self.ies, encoder_, ies, (4294967295, ()))?;
449
450 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(ies.as_mut_ptr()) };
451 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
452
453 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
454
455 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(channel.as_mut_ptr()) };
456
457 ::fidl_next::Encode::encode(self.rssi_dbm, encoder_, rssi_dbm, ())?;
458
459 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(rssi_dbm.as_mut_ptr()) };
460
461 ::fidl_next::Encode::encode(self.snr_db, encoder_, snr_db, ())?;
462
463 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(snr_db.as_mut_ptr()) };
464
465 Ok(())
466 }
467 }
468
469 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::BssDescription<'static>, ___E>
470 for &'a BssDescription
471 where
472 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
473 ___E: ::fidl_next::Encoder,
474 {
475 #[inline]
476 fn encode(
477 self,
478 encoder_: &mut ___E,
479 out_: &mut ::core::mem::MaybeUninit<crate::wire::BssDescription<'static>>,
480 _: (),
481 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
482 ::fidl_next::munge! {
483 let crate::wire::BssDescription {
484 bssid,
485 bss_type,
486 beacon_period,
487 capability_info,
488 ies,
489 channel,
490 rssi_dbm,
491 snr_db,
492
493 } = out_;
494 }
495
496 ::fidl_next::Encode::encode(&self.bssid, encoder_, bssid, ())?;
497
498 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bssid.as_mut_ptr()) };
499
500 ::fidl_next::Encode::encode(&self.bss_type, encoder_, bss_type, ())?;
501
502 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bss_type.as_mut_ptr()) };
503
504 ::fidl_next::Encode::encode(&self.beacon_period, encoder_, beacon_period, ())?;
505
506 let mut _field =
507 unsafe { ::fidl_next::Slot::new_unchecked(beacon_period.as_mut_ptr()) };
508
509 ::fidl_next::Encode::encode(&self.capability_info, encoder_, capability_info, ())?;
510
511 let mut _field =
512 unsafe { ::fidl_next::Slot::new_unchecked(capability_info.as_mut_ptr()) };
513
514 ::fidl_next::Encode::encode(&self.ies, encoder_, ies, (4294967295, ()))?;
515
516 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(ies.as_mut_ptr()) };
517 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
518
519 ::fidl_next::Encode::encode(&self.channel, encoder_, channel, ())?;
520
521 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(channel.as_mut_ptr()) };
522
523 ::fidl_next::Encode::encode(&self.rssi_dbm, encoder_, rssi_dbm, ())?;
524
525 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(rssi_dbm.as_mut_ptr()) };
526
527 ::fidl_next::Encode::encode(&self.snr_db, encoder_, snr_db, ())?;
528
529 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(snr_db.as_mut_ptr()) };
530
531 Ok(())
532 }
533 }
534
535 unsafe impl<___E>
536 ::fidl_next::EncodeOption<
537 ::fidl_next::wire::Box<'static, crate::wire::BssDescription<'static>>,
538 ___E,
539 > for BssDescription
540 where
541 ___E: ::fidl_next::Encoder + ?Sized,
542 BssDescription: ::fidl_next::Encode<crate::wire::BssDescription<'static>, ___E>,
543 {
544 #[inline]
545 fn encode_option(
546 this: ::core::option::Option<Self>,
547 encoder: &mut ___E,
548 out: &mut ::core::mem::MaybeUninit<
549 ::fidl_next::wire::Box<'static, crate::wire::BssDescription<'static>>,
550 >,
551 _: (),
552 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
553 if let Some(inner) = this {
554 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
555 ::fidl_next::wire::Box::encode_present(out);
556 } else {
557 ::fidl_next::wire::Box::encode_absent(out);
558 }
559
560 Ok(())
561 }
562 }
563
564 unsafe impl<'a, ___E>
565 ::fidl_next::EncodeOption<
566 ::fidl_next::wire::Box<'static, crate::wire::BssDescription<'static>>,
567 ___E,
568 > for &'a BssDescription
569 where
570 ___E: ::fidl_next::Encoder + ?Sized,
571 &'a BssDescription: ::fidl_next::Encode<crate::wire::BssDescription<'static>, ___E>,
572 {
573 #[inline]
574 fn encode_option(
575 this: ::core::option::Option<Self>,
576 encoder: &mut ___E,
577 out: &mut ::core::mem::MaybeUninit<
578 ::fidl_next::wire::Box<'static, crate::wire::BssDescription<'static>>,
579 >,
580 _: (),
581 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
582 if let Some(inner) = this {
583 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
584 ::fidl_next::wire::Box::encode_present(out);
585 } else {
586 ::fidl_next::wire::Box::encode_absent(out);
587 }
588
589 Ok(())
590 }
591 }
592
593 impl<'de> ::fidl_next::FromWire<crate::wire::BssDescription<'de>> for BssDescription {
594 #[inline]
595 fn from_wire(wire: crate::wire::BssDescription<'de>) -> Self {
596 Self {
597 bssid: ::fidl_next::FromWire::from_wire(wire.bssid),
598
599 bss_type: ::fidl_next::FromWire::from_wire(wire.bss_type),
600
601 beacon_period: ::fidl_next::FromWire::from_wire(wire.beacon_period),
602
603 capability_info: ::fidl_next::FromWire::from_wire(wire.capability_info),
604
605 ies: ::fidl_next::FromWire::from_wire(wire.ies),
606
607 channel: ::fidl_next::FromWire::from_wire(wire.channel),
608
609 rssi_dbm: ::fidl_next::FromWire::from_wire(wire.rssi_dbm),
610
611 snr_db: ::fidl_next::FromWire::from_wire(wire.snr_db),
612 }
613 }
614 }
615
616 impl<'de> ::fidl_next::FromWireRef<crate::wire::BssDescription<'de>> for BssDescription {
617 #[inline]
618 fn from_wire_ref(wire: &crate::wire::BssDescription<'de>) -> Self {
619 Self {
620 bssid: ::fidl_next::FromWireRef::from_wire_ref(&wire.bssid),
621
622 bss_type: ::fidl_next::FromWireRef::from_wire_ref(&wire.bss_type),
623
624 beacon_period: ::fidl_next::FromWireRef::from_wire_ref(&wire.beacon_period),
625
626 capability_info: ::fidl_next::FromWireRef::from_wire_ref(&wire.capability_info),
627
628 ies: ::fidl_next::FromWireRef::from_wire_ref(&wire.ies),
629
630 channel: ::fidl_next::FromWireRef::from_wire_ref(&wire.channel),
631
632 rssi_dbm: ::fidl_next::FromWireRef::from_wire_ref(&wire.rssi_dbm),
633
634 snr_db: ::fidl_next::FromWireRef::from_wire_ref(&wire.snr_db),
635 }
636 }
637 }
638
639 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
640 #[repr(C)]
641 pub struct CSsid {
642 pub len: u8,
643
644 pub data: [u8; 32],
645 }
646
647 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CSsid, ___E> for CSsid
648 where
649 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
650 {
651 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::CSsid> = unsafe {
652 ::fidl_next::CopyOptimization::enable_if(
653 true && <u8 as ::fidl_next::Encode<u8, ___E>>::COPY_OPTIMIZATION.is_enabled()
654 && <[u8; 32] as ::fidl_next::Encode<[u8; 32], ___E>>::COPY_OPTIMIZATION
655 .is_enabled(),
656 )
657 };
658
659 #[inline]
660 fn encode(
661 self,
662 encoder_: &mut ___E,
663 out_: &mut ::core::mem::MaybeUninit<crate::wire::CSsid>,
664 _: (),
665 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
666 ::fidl_next::munge! {
667 let crate::wire::CSsid {
668 len,
669 data,
670
671 } = out_;
672 }
673
674 ::fidl_next::Encode::encode(self.len, encoder_, len, ())?;
675
676 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(len.as_mut_ptr()) };
677
678 ::fidl_next::Encode::encode(self.data, encoder_, data, ())?;
679
680 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
681
682 Ok(())
683 }
684 }
685
686 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CSsid, ___E> for &'a CSsid
687 where
688 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
689 {
690 #[inline]
691 fn encode(
692 self,
693 encoder_: &mut ___E,
694 out_: &mut ::core::mem::MaybeUninit<crate::wire::CSsid>,
695 _: (),
696 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
697 ::fidl_next::munge! {
698 let crate::wire::CSsid {
699 len,
700 data,
701
702 } = out_;
703 }
704
705 ::fidl_next::Encode::encode(&self.len, encoder_, len, ())?;
706
707 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(len.as_mut_ptr()) };
708
709 ::fidl_next::Encode::encode(&self.data, encoder_, data, ())?;
710
711 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
712
713 Ok(())
714 }
715 }
716
717 unsafe impl<___E>
718 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::CSsid>, ___E>
719 for CSsid
720 where
721 ___E: ::fidl_next::Encoder + ?Sized,
722 CSsid: ::fidl_next::Encode<crate::wire::CSsid, ___E>,
723 {
724 #[inline]
725 fn encode_option(
726 this: ::core::option::Option<Self>,
727 encoder: &mut ___E,
728 out: &mut ::core::mem::MaybeUninit<::fidl_next::wire::Box<'static, crate::wire::CSsid>>,
729 _: (),
730 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
731 if let Some(inner) = this {
732 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
733 ::fidl_next::wire::Box::encode_present(out);
734 } else {
735 ::fidl_next::wire::Box::encode_absent(out);
736 }
737
738 Ok(())
739 }
740 }
741
742 unsafe impl<'a, ___E>
743 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::CSsid>, ___E>
744 for &'a CSsid
745 where
746 ___E: ::fidl_next::Encoder + ?Sized,
747 &'a CSsid: ::fidl_next::Encode<crate::wire::CSsid, ___E>,
748 {
749 #[inline]
750 fn encode_option(
751 this: ::core::option::Option<Self>,
752 encoder: &mut ___E,
753 out: &mut ::core::mem::MaybeUninit<::fidl_next::wire::Box<'static, crate::wire::CSsid>>,
754 _: (),
755 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
756 if let Some(inner) = this {
757 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
758 ::fidl_next::wire::Box::encode_present(out);
759 } else {
760 ::fidl_next::wire::Box::encode_absent(out);
761 }
762
763 Ok(())
764 }
765 }
766
767 impl ::fidl_next::FromWire<crate::wire::CSsid> for CSsid {
768 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::CSsid, Self> = unsafe {
769 ::fidl_next::CopyOptimization::enable_if(
770 true && <u8 as ::fidl_next::FromWire<u8>>::COPY_OPTIMIZATION.is_enabled()
771 && <[u8; 32] as ::fidl_next::FromWire<[u8; 32]>>::COPY_OPTIMIZATION
772 .is_enabled(),
773 )
774 };
775
776 #[inline]
777 fn from_wire(wire: crate::wire::CSsid) -> Self {
778 Self {
779 len: ::fidl_next::FromWire::from_wire(wire.len),
780
781 data: ::fidl_next::FromWire::from_wire(wire.data),
782 }
783 }
784 }
785
786 impl ::fidl_next::FromWireRef<crate::wire::CSsid> for CSsid {
787 #[inline]
788 fn from_wire_ref(wire: &crate::wire::CSsid) -> Self {
789 Self {
790 len: ::fidl_next::FromWireRef::from_wire_ref(&wire.len),
791
792 data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data),
793 }
794 }
795 }
796
797 #[doc = " IEEE Std 802.11-2016, 9.4.2.25.2\n"]
798 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
799 #[repr(u32)]
800 pub enum CipherSuiteType {
801 UseGroup = 0,
802 Wep40 = 1,
803 Tkip = 2,
804 Reserved3 = 3,
805 Ccmp128 = 4,
806 Wep104 = 5,
807 BipCmac128 = 6,
808 GroupAddressedNotAllowed = 7,
809 Gcmp128 = 8,
810 Gcmp256 = 9,
811 Ccmp256 = 10,
812 BipGmac128 = 11,
813 BipGmac256 = 12,
814 BipCmac256 = 13,
815 Reserved14To255 = 14,
816 UnknownOrdinal_(u32) = 15,
817 }
818 impl ::std::convert::From<u32> for CipherSuiteType {
819 fn from(value: u32) -> Self {
820 match value {
821 0 => Self::UseGroup,
822 1 => Self::Wep40,
823 2 => Self::Tkip,
824 3 => Self::Reserved3,
825 4 => Self::Ccmp128,
826 5 => Self::Wep104,
827 6 => Self::BipCmac128,
828 7 => Self::GroupAddressedNotAllowed,
829 8 => Self::Gcmp128,
830 9 => Self::Gcmp256,
831 10 => Self::Ccmp256,
832 11 => Self::BipGmac128,
833 12 => Self::BipGmac256,
834 13 => Self::BipCmac256,
835 14 => Self::Reserved14To255,
836
837 _ => Self::UnknownOrdinal_(value),
838 }
839 }
840 }
841
842 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CipherSuiteType, ___E> for CipherSuiteType
843 where
844 ___E: ?Sized,
845 {
846 #[inline]
847 fn encode(
848 self,
849 encoder: &mut ___E,
850 out: &mut ::core::mem::MaybeUninit<crate::wire::CipherSuiteType>,
851 _: (),
852 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
853 ::fidl_next::Encode::encode(&self, encoder, out, ())
854 }
855 }
856
857 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CipherSuiteType, ___E>
858 for &'a CipherSuiteType
859 where
860 ___E: ?Sized,
861 {
862 #[inline]
863 fn encode(
864 self,
865 encoder: &mut ___E,
866 out: &mut ::core::mem::MaybeUninit<crate::wire::CipherSuiteType>,
867 _: (),
868 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
869 ::fidl_next::munge!(let crate::wire::CipherSuiteType { value } = out);
870 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
871 CipherSuiteType::UseGroup => 0,
872
873 CipherSuiteType::Wep40 => 1,
874
875 CipherSuiteType::Tkip => 2,
876
877 CipherSuiteType::Reserved3 => 3,
878
879 CipherSuiteType::Ccmp128 => 4,
880
881 CipherSuiteType::Wep104 => 5,
882
883 CipherSuiteType::BipCmac128 => 6,
884
885 CipherSuiteType::GroupAddressedNotAllowed => 7,
886
887 CipherSuiteType::Gcmp128 => 8,
888
889 CipherSuiteType::Gcmp256 => 9,
890
891 CipherSuiteType::Ccmp256 => 10,
892
893 CipherSuiteType::BipGmac128 => 11,
894
895 CipherSuiteType::BipGmac256 => 12,
896
897 CipherSuiteType::BipCmac256 => 13,
898
899 CipherSuiteType::Reserved14To255 => 14,
900
901 CipherSuiteType::UnknownOrdinal_(value) => value,
902 }));
903
904 Ok(())
905 }
906 }
907
908 impl ::core::convert::From<crate::wire::CipherSuiteType> for CipherSuiteType {
909 fn from(wire: crate::wire::CipherSuiteType) -> Self {
910 match u32::from(wire.value) {
911 0 => Self::UseGroup,
912
913 1 => Self::Wep40,
914
915 2 => Self::Tkip,
916
917 3 => Self::Reserved3,
918
919 4 => Self::Ccmp128,
920
921 5 => Self::Wep104,
922
923 6 => Self::BipCmac128,
924
925 7 => Self::GroupAddressedNotAllowed,
926
927 8 => Self::Gcmp128,
928
929 9 => Self::Gcmp256,
930
931 10 => Self::Ccmp256,
932
933 11 => Self::BipGmac128,
934
935 12 => Self::BipGmac256,
936
937 13 => Self::BipCmac256,
938
939 14 => Self::Reserved14To255,
940
941 value => Self::UnknownOrdinal_(value),
942 }
943 }
944 }
945
946 impl ::fidl_next::FromWire<crate::wire::CipherSuiteType> for CipherSuiteType {
947 #[inline]
948 fn from_wire(wire: crate::wire::CipherSuiteType) -> Self {
949 Self::from(wire)
950 }
951 }
952
953 impl ::fidl_next::FromWireRef<crate::wire::CipherSuiteType> for CipherSuiteType {
954 #[inline]
955 fn from_wire_ref(wire: &crate::wire::CipherSuiteType) -> Self {
956 Self::from(*wire)
957 }
958 }
959
960 #[doc = " HT and VHT guard interval.\n See IEEE 802.11-2016 Table 19-1 and Table 21-1.\n"]
961 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
962 #[repr(u8)]
963 pub enum GuardInterval {
964 LongGi = 1,
965 ShortGi = 2,
966 }
967 impl ::core::convert::TryFrom<u8> for GuardInterval {
968 type Error = ::fidl_next::UnknownStrictEnumMemberError;
969 fn try_from(
970 value: u8,
971 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
972 match value {
973 1 => Ok(Self::LongGi),
974 2 => Ok(Self::ShortGi),
975
976 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
977 }
978 }
979 }
980
981 unsafe impl<___E> ::fidl_next::Encode<crate::wire::GuardInterval, ___E> for GuardInterval
982 where
983 ___E: ?Sized,
984 {
985 #[inline]
986 fn encode(
987 self,
988 encoder: &mut ___E,
989 out: &mut ::core::mem::MaybeUninit<crate::wire::GuardInterval>,
990 _: (),
991 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
992 ::fidl_next::Encode::encode(&self, encoder, out, ())
993 }
994 }
995
996 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::GuardInterval, ___E> for &'a GuardInterval
997 where
998 ___E: ?Sized,
999 {
1000 #[inline]
1001 fn encode(
1002 self,
1003 encoder: &mut ___E,
1004 out: &mut ::core::mem::MaybeUninit<crate::wire::GuardInterval>,
1005 _: (),
1006 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1007 ::fidl_next::munge!(let crate::wire::GuardInterval { value } = out);
1008 let _ = value.write(u8::from(match *self {
1009 GuardInterval::LongGi => 1,
1010
1011 GuardInterval::ShortGi => 2,
1012 }));
1013
1014 Ok(())
1015 }
1016 }
1017
1018 impl ::core::convert::From<crate::wire::GuardInterval> for GuardInterval {
1019 fn from(wire: crate::wire::GuardInterval) -> Self {
1020 match u8::from(wire.value) {
1021 1 => Self::LongGi,
1022
1023 2 => Self::ShortGi,
1024
1025 _ => unsafe { ::core::hint::unreachable_unchecked() },
1026 }
1027 }
1028 }
1029
1030 impl ::fidl_next::FromWire<crate::wire::GuardInterval> for GuardInterval {
1031 #[inline]
1032 fn from_wire(wire: crate::wire::GuardInterval) -> Self {
1033 Self::from(wire)
1034 }
1035 }
1036
1037 impl ::fidl_next::FromWireRef<crate::wire::GuardInterval> for GuardInterval {
1038 #[inline]
1039 fn from_wire_ref(wire: &crate::wire::GuardInterval) -> Self {
1040 Self::from(*wire)
1041 }
1042 }
1043
1044 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1045 #[repr(C)]
1046 pub struct HtCapabilities {
1047 pub bytes: [u8; 26],
1048 }
1049
1050 unsafe impl<___E> ::fidl_next::Encode<crate::wire::HtCapabilities, ___E> for HtCapabilities
1051 where
1052 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1053 {
1054 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::HtCapabilities> = unsafe {
1055 ::fidl_next::CopyOptimization::enable_if(
1056 true && <[u8; 26] as ::fidl_next::Encode<[u8; 26], ___E>>::COPY_OPTIMIZATION
1057 .is_enabled(),
1058 )
1059 };
1060
1061 #[inline]
1062 fn encode(
1063 self,
1064 encoder_: &mut ___E,
1065 out_: &mut ::core::mem::MaybeUninit<crate::wire::HtCapabilities>,
1066 _: (),
1067 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1068 ::fidl_next::munge! {
1069 let crate::wire::HtCapabilities {
1070 bytes,
1071
1072 } = out_;
1073 }
1074
1075 ::fidl_next::Encode::encode(self.bytes, encoder_, bytes, ())?;
1076
1077 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bytes.as_mut_ptr()) };
1078
1079 Ok(())
1080 }
1081 }
1082
1083 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::HtCapabilities, ___E> for &'a HtCapabilities
1084 where
1085 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1086 {
1087 #[inline]
1088 fn encode(
1089 self,
1090 encoder_: &mut ___E,
1091 out_: &mut ::core::mem::MaybeUninit<crate::wire::HtCapabilities>,
1092 _: (),
1093 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1094 ::fidl_next::munge! {
1095 let crate::wire::HtCapabilities {
1096 bytes,
1097
1098 } = out_;
1099 }
1100
1101 ::fidl_next::Encode::encode(&self.bytes, encoder_, bytes, ())?;
1102
1103 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bytes.as_mut_ptr()) };
1104
1105 Ok(())
1106 }
1107 }
1108
1109 unsafe impl<___E>
1110 ::fidl_next::EncodeOption<
1111 ::fidl_next::wire::Box<'static, crate::wire::HtCapabilities>,
1112 ___E,
1113 > for HtCapabilities
1114 where
1115 ___E: ::fidl_next::Encoder + ?Sized,
1116 HtCapabilities: ::fidl_next::Encode<crate::wire::HtCapabilities, ___E>,
1117 {
1118 #[inline]
1119 fn encode_option(
1120 this: ::core::option::Option<Self>,
1121 encoder: &mut ___E,
1122 out: &mut ::core::mem::MaybeUninit<
1123 ::fidl_next::wire::Box<'static, crate::wire::HtCapabilities>,
1124 >,
1125 _: (),
1126 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1127 if let Some(inner) = this {
1128 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1129 ::fidl_next::wire::Box::encode_present(out);
1130 } else {
1131 ::fidl_next::wire::Box::encode_absent(out);
1132 }
1133
1134 Ok(())
1135 }
1136 }
1137
1138 unsafe impl<'a, ___E>
1139 ::fidl_next::EncodeOption<
1140 ::fidl_next::wire::Box<'static, crate::wire::HtCapabilities>,
1141 ___E,
1142 > for &'a HtCapabilities
1143 where
1144 ___E: ::fidl_next::Encoder + ?Sized,
1145 &'a HtCapabilities: ::fidl_next::Encode<crate::wire::HtCapabilities, ___E>,
1146 {
1147 #[inline]
1148 fn encode_option(
1149 this: ::core::option::Option<Self>,
1150 encoder: &mut ___E,
1151 out: &mut ::core::mem::MaybeUninit<
1152 ::fidl_next::wire::Box<'static, crate::wire::HtCapabilities>,
1153 >,
1154 _: (),
1155 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1156 if let Some(inner) = this {
1157 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1158 ::fidl_next::wire::Box::encode_present(out);
1159 } else {
1160 ::fidl_next::wire::Box::encode_absent(out);
1161 }
1162
1163 Ok(())
1164 }
1165 }
1166
1167 impl ::fidl_next::FromWire<crate::wire::HtCapabilities> for HtCapabilities {
1168 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::HtCapabilities, Self> = unsafe {
1169 ::fidl_next::CopyOptimization::enable_if(
1170 true && <[u8; 26] as ::fidl_next::FromWire<[u8; 26]>>::COPY_OPTIMIZATION
1171 .is_enabled(),
1172 )
1173 };
1174
1175 #[inline]
1176 fn from_wire(wire: crate::wire::HtCapabilities) -> Self {
1177 Self { bytes: ::fidl_next::FromWire::from_wire(wire.bytes) }
1178 }
1179 }
1180
1181 impl ::fidl_next::FromWireRef<crate::wire::HtCapabilities> for HtCapabilities {
1182 #[inline]
1183 fn from_wire_ref(wire: &crate::wire::HtCapabilities) -> Self {
1184 Self { bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.bytes) }
1185 }
1186 }
1187
1188 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1189 #[repr(C)]
1190 pub struct HtOperation {
1191 pub bytes: [u8; 22],
1192 }
1193
1194 unsafe impl<___E> ::fidl_next::Encode<crate::wire::HtOperation, ___E> for HtOperation
1195 where
1196 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1197 {
1198 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::HtOperation> = unsafe {
1199 ::fidl_next::CopyOptimization::enable_if(
1200 true && <[u8; 22] as ::fidl_next::Encode<[u8; 22], ___E>>::COPY_OPTIMIZATION
1201 .is_enabled(),
1202 )
1203 };
1204
1205 #[inline]
1206 fn encode(
1207 self,
1208 encoder_: &mut ___E,
1209 out_: &mut ::core::mem::MaybeUninit<crate::wire::HtOperation>,
1210 _: (),
1211 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1212 ::fidl_next::munge! {
1213 let crate::wire::HtOperation {
1214 bytes,
1215
1216 } = out_;
1217 }
1218
1219 ::fidl_next::Encode::encode(self.bytes, encoder_, bytes, ())?;
1220
1221 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bytes.as_mut_ptr()) };
1222
1223 Ok(())
1224 }
1225 }
1226
1227 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::HtOperation, ___E> for &'a HtOperation
1228 where
1229 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1230 {
1231 #[inline]
1232 fn encode(
1233 self,
1234 encoder_: &mut ___E,
1235 out_: &mut ::core::mem::MaybeUninit<crate::wire::HtOperation>,
1236 _: (),
1237 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1238 ::fidl_next::munge! {
1239 let crate::wire::HtOperation {
1240 bytes,
1241
1242 } = out_;
1243 }
1244
1245 ::fidl_next::Encode::encode(&self.bytes, encoder_, bytes, ())?;
1246
1247 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bytes.as_mut_ptr()) };
1248
1249 Ok(())
1250 }
1251 }
1252
1253 unsafe impl<___E>
1254 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::HtOperation>, ___E>
1255 for HtOperation
1256 where
1257 ___E: ::fidl_next::Encoder + ?Sized,
1258 HtOperation: ::fidl_next::Encode<crate::wire::HtOperation, ___E>,
1259 {
1260 #[inline]
1261 fn encode_option(
1262 this: ::core::option::Option<Self>,
1263 encoder: &mut ___E,
1264 out: &mut ::core::mem::MaybeUninit<
1265 ::fidl_next::wire::Box<'static, crate::wire::HtOperation>,
1266 >,
1267 _: (),
1268 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1269 if let Some(inner) = this {
1270 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1271 ::fidl_next::wire::Box::encode_present(out);
1272 } else {
1273 ::fidl_next::wire::Box::encode_absent(out);
1274 }
1275
1276 Ok(())
1277 }
1278 }
1279
1280 unsafe impl<'a, ___E>
1281 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::HtOperation>, ___E>
1282 for &'a HtOperation
1283 where
1284 ___E: ::fidl_next::Encoder + ?Sized,
1285 &'a HtOperation: ::fidl_next::Encode<crate::wire::HtOperation, ___E>,
1286 {
1287 #[inline]
1288 fn encode_option(
1289 this: ::core::option::Option<Self>,
1290 encoder: &mut ___E,
1291 out: &mut ::core::mem::MaybeUninit<
1292 ::fidl_next::wire::Box<'static, crate::wire::HtOperation>,
1293 >,
1294 _: (),
1295 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1296 if let Some(inner) = this {
1297 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1298 ::fidl_next::wire::Box::encode_present(out);
1299 } else {
1300 ::fidl_next::wire::Box::encode_absent(out);
1301 }
1302
1303 Ok(())
1304 }
1305 }
1306
1307 impl ::fidl_next::FromWire<crate::wire::HtOperation> for HtOperation {
1308 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::HtOperation, Self> = unsafe {
1309 ::fidl_next::CopyOptimization::enable_if(
1310 true && <[u8; 22] as ::fidl_next::FromWire<[u8; 22]>>::COPY_OPTIMIZATION
1311 .is_enabled(),
1312 )
1313 };
1314
1315 #[inline]
1316 fn from_wire(wire: crate::wire::HtOperation) -> Self {
1317 Self { bytes: ::fidl_next::FromWire::from_wire(wire.bytes) }
1318 }
1319 }
1320
1321 impl ::fidl_next::FromWireRef<crate::wire::HtOperation> for HtOperation {
1322 #[inline]
1323 fn from_wire_ref(wire: &crate::wire::HtOperation) -> Self {
1324 Self { bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.bytes) }
1325 }
1326 }
1327
1328 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1329 #[repr(u8)]
1330 pub enum KeyType {
1331 Pairwise = 1,
1332 Group = 2,
1333 Igtk = 3,
1334 Peer = 4,
1335 UnknownOrdinal_(u8) = 5,
1336 }
1337 impl ::std::convert::From<u8> for KeyType {
1338 fn from(value: u8) -> Self {
1339 match value {
1340 1 => Self::Pairwise,
1341 2 => Self::Group,
1342 3 => Self::Igtk,
1343 4 => Self::Peer,
1344
1345 _ => Self::UnknownOrdinal_(value),
1346 }
1347 }
1348 }
1349
1350 unsafe impl<___E> ::fidl_next::Encode<crate::wire::KeyType, ___E> for KeyType
1351 where
1352 ___E: ?Sized,
1353 {
1354 #[inline]
1355 fn encode(
1356 self,
1357 encoder: &mut ___E,
1358 out: &mut ::core::mem::MaybeUninit<crate::wire::KeyType>,
1359 _: (),
1360 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1361 ::fidl_next::Encode::encode(&self, encoder, out, ())
1362 }
1363 }
1364
1365 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::KeyType, ___E> for &'a KeyType
1366 where
1367 ___E: ?Sized,
1368 {
1369 #[inline]
1370 fn encode(
1371 self,
1372 encoder: &mut ___E,
1373 out: &mut ::core::mem::MaybeUninit<crate::wire::KeyType>,
1374 _: (),
1375 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1376 ::fidl_next::munge!(let crate::wire::KeyType { value } = out);
1377 let _ = value.write(u8::from(match *self {
1378 KeyType::Pairwise => 1,
1379
1380 KeyType::Group => 2,
1381
1382 KeyType::Igtk => 3,
1383
1384 KeyType::Peer => 4,
1385
1386 KeyType::UnknownOrdinal_(value) => value,
1387 }));
1388
1389 Ok(())
1390 }
1391 }
1392
1393 impl ::core::convert::From<crate::wire::KeyType> for KeyType {
1394 fn from(wire: crate::wire::KeyType) -> Self {
1395 match u8::from(wire.value) {
1396 1 => Self::Pairwise,
1397
1398 2 => Self::Group,
1399
1400 3 => Self::Igtk,
1401
1402 4 => Self::Peer,
1403
1404 value => Self::UnknownOrdinal_(value),
1405 }
1406 }
1407 }
1408
1409 impl ::fidl_next::FromWire<crate::wire::KeyType> for KeyType {
1410 #[inline]
1411 fn from_wire(wire: crate::wire::KeyType) -> Self {
1412 Self::from(wire)
1413 }
1414 }
1415
1416 impl ::fidl_next::FromWireRef<crate::wire::KeyType> for KeyType {
1417 #[inline]
1418 fn from_wire_ref(wire: &crate::wire::KeyType) -> Self {
1419 Self::from(*wire)
1420 }
1421 }
1422
1423 #[doc = " 802.11 reason codes. These values are common throughout the standard.\n IEEE Std 802.11-2016, 9.4.1.7, Table 9-45\n"]
1424 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1425 #[repr(u16)]
1426 pub enum ReasonCode {
1427 UnspecifiedReason = 1,
1428 InvalidAuthentication = 2,
1429 LeavingNetworkDeauth = 3,
1430 ReasonInactivity = 4,
1431 NoMoreStas = 5,
1432 InvalidClass2Frame = 6,
1433 InvalidClass3Frame = 7,
1434 LeavingNetworkDisassoc = 8,
1435 NotAuthenticated = 9,
1436 UnacceptablePowerCapability = 10,
1437 UnacceptableSupportedChannels = 11,
1438 BssTransitionDisassoc = 12,
1439 ReasonInvalidElement = 13,
1440 MicFailure = 14,
1441 FourwayHandshakeTimeout = 15,
1442 GkHandshakeTimeout = 16,
1443 HandshakeElementMismatch = 17,
1444 ReasonInvalidGroupCipher = 18,
1445 ReasonInvalidPairwiseCipher = 19,
1446 ReasonInvalidAkmp = 20,
1447 UnsupportedRsneVersion = 21,
1448 InvalidRsneCapabilities = 22,
1449 Ieee8021XAuthFailed = 23,
1450 ReasonCipherOutOfPolicy = 24,
1451 TdlsPeerUnreachable = 25,
1452 TdlsUnspecifiedReason = 26,
1453 SspRequestedDisassoc = 27,
1454 NoSspRoamingAgreement = 28,
1455 BadCipherOrAkm = 29,
1456 NotAuthorizedThisLocation = 30,
1457 ServiceChangePrecludesTs = 31,
1458 UnspecifiedQosReason = 32,
1459 NotEnoughBandwidth = 33,
1460 MissingAcks = 34,
1461 ExceededTxop = 35,
1462 StaLeaving = 36,
1463 EndTsBaDls = 37,
1464 UnknownTsBa = 38,
1465 Timeout = 39,
1466 PeerkeyMismatch = 45,
1467 PeerInitiated = 46,
1468 ApInitiated = 47,
1469 ReasonInvalidFtActionFrameCount = 48,
1470 ReasonInvalidPmkid = 49,
1471 ReasonInvalidMde = 50,
1472 ReasonInvalidFte = 51,
1473 MeshPeeringCanceled = 52,
1474 MeshMaxPeers = 53,
1475 MeshConfigurationPolicyViolation = 54,
1476 MeshCloseRcvd = 55,
1477 MeshMaxRetries = 56,
1478 MeshConfirmTimeout = 57,
1479 MeshInvalidGtk = 58,
1480 MeshInconsistentParameters = 59,
1481 MeshInvalidSecurityCapability = 60,
1482 MeshPathErrorNoProxyInformation = 61,
1483 MeshPathErrorNoForwardingInformation = 62,
1484 MeshPathErrorDestinationUnreachable = 63,
1485 MacAddressAlreadyExistsInMbss = 64,
1486 MeshChannelSwitchRegulatoryRequirements = 65,
1487 MeshChannelSwitchUnspecified = 66,
1488 MlmeLinkFailed = 128,
1489 FwRxStalled = 129,
1490 FwHighWmeRxErrRate = 130,
1491 UnknownOrdinal_(u16) = 131,
1492 }
1493 impl ::std::convert::From<u16> for ReasonCode {
1494 fn from(value: u16) -> Self {
1495 match value {
1496 1 => Self::UnspecifiedReason,
1497 2 => Self::InvalidAuthentication,
1498 3 => Self::LeavingNetworkDeauth,
1499 4 => Self::ReasonInactivity,
1500 5 => Self::NoMoreStas,
1501 6 => Self::InvalidClass2Frame,
1502 7 => Self::InvalidClass3Frame,
1503 8 => Self::LeavingNetworkDisassoc,
1504 9 => Self::NotAuthenticated,
1505 10 => Self::UnacceptablePowerCapability,
1506 11 => Self::UnacceptableSupportedChannels,
1507 12 => Self::BssTransitionDisassoc,
1508 13 => Self::ReasonInvalidElement,
1509 14 => Self::MicFailure,
1510 15 => Self::FourwayHandshakeTimeout,
1511 16 => Self::GkHandshakeTimeout,
1512 17 => Self::HandshakeElementMismatch,
1513 18 => Self::ReasonInvalidGroupCipher,
1514 19 => Self::ReasonInvalidPairwiseCipher,
1515 20 => Self::ReasonInvalidAkmp,
1516 21 => Self::UnsupportedRsneVersion,
1517 22 => Self::InvalidRsneCapabilities,
1518 23 => Self::Ieee8021XAuthFailed,
1519 24 => Self::ReasonCipherOutOfPolicy,
1520 25 => Self::TdlsPeerUnreachable,
1521 26 => Self::TdlsUnspecifiedReason,
1522 27 => Self::SspRequestedDisassoc,
1523 28 => Self::NoSspRoamingAgreement,
1524 29 => Self::BadCipherOrAkm,
1525 30 => Self::NotAuthorizedThisLocation,
1526 31 => Self::ServiceChangePrecludesTs,
1527 32 => Self::UnspecifiedQosReason,
1528 33 => Self::NotEnoughBandwidth,
1529 34 => Self::MissingAcks,
1530 35 => Self::ExceededTxop,
1531 36 => Self::StaLeaving,
1532 37 => Self::EndTsBaDls,
1533 38 => Self::UnknownTsBa,
1534 39 => Self::Timeout,
1535 45 => Self::PeerkeyMismatch,
1536 46 => Self::PeerInitiated,
1537 47 => Self::ApInitiated,
1538 48 => Self::ReasonInvalidFtActionFrameCount,
1539 49 => Self::ReasonInvalidPmkid,
1540 50 => Self::ReasonInvalidMde,
1541 51 => Self::ReasonInvalidFte,
1542 52 => Self::MeshPeeringCanceled,
1543 53 => Self::MeshMaxPeers,
1544 54 => Self::MeshConfigurationPolicyViolation,
1545 55 => Self::MeshCloseRcvd,
1546 56 => Self::MeshMaxRetries,
1547 57 => Self::MeshConfirmTimeout,
1548 58 => Self::MeshInvalidGtk,
1549 59 => Self::MeshInconsistentParameters,
1550 60 => Self::MeshInvalidSecurityCapability,
1551 61 => Self::MeshPathErrorNoProxyInformation,
1552 62 => Self::MeshPathErrorNoForwardingInformation,
1553 63 => Self::MeshPathErrorDestinationUnreachable,
1554 64 => Self::MacAddressAlreadyExistsInMbss,
1555 65 => Self::MeshChannelSwitchRegulatoryRequirements,
1556 66 => Self::MeshChannelSwitchUnspecified,
1557 128 => Self::MlmeLinkFailed,
1558 129 => Self::FwRxStalled,
1559 130 => Self::FwHighWmeRxErrRate,
1560
1561 _ => Self::UnknownOrdinal_(value),
1562 }
1563 }
1564 }
1565
1566 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ReasonCode, ___E> for ReasonCode
1567 where
1568 ___E: ?Sized,
1569 {
1570 #[inline]
1571 fn encode(
1572 self,
1573 encoder: &mut ___E,
1574 out: &mut ::core::mem::MaybeUninit<crate::wire::ReasonCode>,
1575 _: (),
1576 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1577 ::fidl_next::Encode::encode(&self, encoder, out, ())
1578 }
1579 }
1580
1581 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ReasonCode, ___E> for &'a ReasonCode
1582 where
1583 ___E: ?Sized,
1584 {
1585 #[inline]
1586 fn encode(
1587 self,
1588 encoder: &mut ___E,
1589 out: &mut ::core::mem::MaybeUninit<crate::wire::ReasonCode>,
1590 _: (),
1591 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1592 ::fidl_next::munge!(let crate::wire::ReasonCode { value } = out);
1593 let _ = value.write(::fidl_next::wire::Uint16::from(match *self {
1594 ReasonCode::UnspecifiedReason => 1,
1595
1596 ReasonCode::InvalidAuthentication => 2,
1597
1598 ReasonCode::LeavingNetworkDeauth => 3,
1599
1600 ReasonCode::ReasonInactivity => 4,
1601
1602 ReasonCode::NoMoreStas => 5,
1603
1604 ReasonCode::InvalidClass2Frame => 6,
1605
1606 ReasonCode::InvalidClass3Frame => 7,
1607
1608 ReasonCode::LeavingNetworkDisassoc => 8,
1609
1610 ReasonCode::NotAuthenticated => 9,
1611
1612 ReasonCode::UnacceptablePowerCapability => 10,
1613
1614 ReasonCode::UnacceptableSupportedChannels => 11,
1615
1616 ReasonCode::BssTransitionDisassoc => 12,
1617
1618 ReasonCode::ReasonInvalidElement => 13,
1619
1620 ReasonCode::MicFailure => 14,
1621
1622 ReasonCode::FourwayHandshakeTimeout => 15,
1623
1624 ReasonCode::GkHandshakeTimeout => 16,
1625
1626 ReasonCode::HandshakeElementMismatch => 17,
1627
1628 ReasonCode::ReasonInvalidGroupCipher => 18,
1629
1630 ReasonCode::ReasonInvalidPairwiseCipher => 19,
1631
1632 ReasonCode::ReasonInvalidAkmp => 20,
1633
1634 ReasonCode::UnsupportedRsneVersion => 21,
1635
1636 ReasonCode::InvalidRsneCapabilities => 22,
1637
1638 ReasonCode::Ieee8021XAuthFailed => 23,
1639
1640 ReasonCode::ReasonCipherOutOfPolicy => 24,
1641
1642 ReasonCode::TdlsPeerUnreachable => 25,
1643
1644 ReasonCode::TdlsUnspecifiedReason => 26,
1645
1646 ReasonCode::SspRequestedDisassoc => 27,
1647
1648 ReasonCode::NoSspRoamingAgreement => 28,
1649
1650 ReasonCode::BadCipherOrAkm => 29,
1651
1652 ReasonCode::NotAuthorizedThisLocation => 30,
1653
1654 ReasonCode::ServiceChangePrecludesTs => 31,
1655
1656 ReasonCode::UnspecifiedQosReason => 32,
1657
1658 ReasonCode::NotEnoughBandwidth => 33,
1659
1660 ReasonCode::MissingAcks => 34,
1661
1662 ReasonCode::ExceededTxop => 35,
1663
1664 ReasonCode::StaLeaving => 36,
1665
1666 ReasonCode::EndTsBaDls => 37,
1667
1668 ReasonCode::UnknownTsBa => 38,
1669
1670 ReasonCode::Timeout => 39,
1671
1672 ReasonCode::PeerkeyMismatch => 45,
1673
1674 ReasonCode::PeerInitiated => 46,
1675
1676 ReasonCode::ApInitiated => 47,
1677
1678 ReasonCode::ReasonInvalidFtActionFrameCount => 48,
1679
1680 ReasonCode::ReasonInvalidPmkid => 49,
1681
1682 ReasonCode::ReasonInvalidMde => 50,
1683
1684 ReasonCode::ReasonInvalidFte => 51,
1685
1686 ReasonCode::MeshPeeringCanceled => 52,
1687
1688 ReasonCode::MeshMaxPeers => 53,
1689
1690 ReasonCode::MeshConfigurationPolicyViolation => 54,
1691
1692 ReasonCode::MeshCloseRcvd => 55,
1693
1694 ReasonCode::MeshMaxRetries => 56,
1695
1696 ReasonCode::MeshConfirmTimeout => 57,
1697
1698 ReasonCode::MeshInvalidGtk => 58,
1699
1700 ReasonCode::MeshInconsistentParameters => 59,
1701
1702 ReasonCode::MeshInvalidSecurityCapability => 60,
1703
1704 ReasonCode::MeshPathErrorNoProxyInformation => 61,
1705
1706 ReasonCode::MeshPathErrorNoForwardingInformation => 62,
1707
1708 ReasonCode::MeshPathErrorDestinationUnreachable => 63,
1709
1710 ReasonCode::MacAddressAlreadyExistsInMbss => 64,
1711
1712 ReasonCode::MeshChannelSwitchRegulatoryRequirements => 65,
1713
1714 ReasonCode::MeshChannelSwitchUnspecified => 66,
1715
1716 ReasonCode::MlmeLinkFailed => 128,
1717
1718 ReasonCode::FwRxStalled => 129,
1719
1720 ReasonCode::FwHighWmeRxErrRate => 130,
1721
1722 ReasonCode::UnknownOrdinal_(value) => value,
1723 }));
1724
1725 Ok(())
1726 }
1727 }
1728
1729 impl ::core::convert::From<crate::wire::ReasonCode> for ReasonCode {
1730 fn from(wire: crate::wire::ReasonCode) -> Self {
1731 match u16::from(wire.value) {
1732 1 => Self::UnspecifiedReason,
1733
1734 2 => Self::InvalidAuthentication,
1735
1736 3 => Self::LeavingNetworkDeauth,
1737
1738 4 => Self::ReasonInactivity,
1739
1740 5 => Self::NoMoreStas,
1741
1742 6 => Self::InvalidClass2Frame,
1743
1744 7 => Self::InvalidClass3Frame,
1745
1746 8 => Self::LeavingNetworkDisassoc,
1747
1748 9 => Self::NotAuthenticated,
1749
1750 10 => Self::UnacceptablePowerCapability,
1751
1752 11 => Self::UnacceptableSupportedChannels,
1753
1754 12 => Self::BssTransitionDisassoc,
1755
1756 13 => Self::ReasonInvalidElement,
1757
1758 14 => Self::MicFailure,
1759
1760 15 => Self::FourwayHandshakeTimeout,
1761
1762 16 => Self::GkHandshakeTimeout,
1763
1764 17 => Self::HandshakeElementMismatch,
1765
1766 18 => Self::ReasonInvalidGroupCipher,
1767
1768 19 => Self::ReasonInvalidPairwiseCipher,
1769
1770 20 => Self::ReasonInvalidAkmp,
1771
1772 21 => Self::UnsupportedRsneVersion,
1773
1774 22 => Self::InvalidRsneCapabilities,
1775
1776 23 => Self::Ieee8021XAuthFailed,
1777
1778 24 => Self::ReasonCipherOutOfPolicy,
1779
1780 25 => Self::TdlsPeerUnreachable,
1781
1782 26 => Self::TdlsUnspecifiedReason,
1783
1784 27 => Self::SspRequestedDisassoc,
1785
1786 28 => Self::NoSspRoamingAgreement,
1787
1788 29 => Self::BadCipherOrAkm,
1789
1790 30 => Self::NotAuthorizedThisLocation,
1791
1792 31 => Self::ServiceChangePrecludesTs,
1793
1794 32 => Self::UnspecifiedQosReason,
1795
1796 33 => Self::NotEnoughBandwidth,
1797
1798 34 => Self::MissingAcks,
1799
1800 35 => Self::ExceededTxop,
1801
1802 36 => Self::StaLeaving,
1803
1804 37 => Self::EndTsBaDls,
1805
1806 38 => Self::UnknownTsBa,
1807
1808 39 => Self::Timeout,
1809
1810 45 => Self::PeerkeyMismatch,
1811
1812 46 => Self::PeerInitiated,
1813
1814 47 => Self::ApInitiated,
1815
1816 48 => Self::ReasonInvalidFtActionFrameCount,
1817
1818 49 => Self::ReasonInvalidPmkid,
1819
1820 50 => Self::ReasonInvalidMde,
1821
1822 51 => Self::ReasonInvalidFte,
1823
1824 52 => Self::MeshPeeringCanceled,
1825
1826 53 => Self::MeshMaxPeers,
1827
1828 54 => Self::MeshConfigurationPolicyViolation,
1829
1830 55 => Self::MeshCloseRcvd,
1831
1832 56 => Self::MeshMaxRetries,
1833
1834 57 => Self::MeshConfirmTimeout,
1835
1836 58 => Self::MeshInvalidGtk,
1837
1838 59 => Self::MeshInconsistentParameters,
1839
1840 60 => Self::MeshInvalidSecurityCapability,
1841
1842 61 => Self::MeshPathErrorNoProxyInformation,
1843
1844 62 => Self::MeshPathErrorNoForwardingInformation,
1845
1846 63 => Self::MeshPathErrorDestinationUnreachable,
1847
1848 64 => Self::MacAddressAlreadyExistsInMbss,
1849
1850 65 => Self::MeshChannelSwitchRegulatoryRequirements,
1851
1852 66 => Self::MeshChannelSwitchUnspecified,
1853
1854 128 => Self::MlmeLinkFailed,
1855
1856 129 => Self::FwRxStalled,
1857
1858 130 => Self::FwHighWmeRxErrRate,
1859
1860 value => Self::UnknownOrdinal_(value),
1861 }
1862 }
1863 }
1864
1865 impl ::fidl_next::FromWire<crate::wire::ReasonCode> for ReasonCode {
1866 #[inline]
1867 fn from_wire(wire: crate::wire::ReasonCode) -> Self {
1868 Self::from(wire)
1869 }
1870 }
1871
1872 impl ::fidl_next::FromWireRef<crate::wire::ReasonCode> for ReasonCode {
1873 #[inline]
1874 fn from_wire_ref(wire: &crate::wire::ReasonCode) -> Self {
1875 Self::from(*wire)
1876 }
1877 }
1878
1879 #[doc = " IEEE Std 802.11-2020 6.3.19.1.2\n"]
1880 #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1881 pub struct SetKeyDescriptor {
1882 pub key: ::core::option::Option<::std::vec::Vec<u8>>,
1883
1884 pub key_id: ::core::option::Option<u16>,
1885
1886 pub key_type: ::core::option::Option<crate::natural::KeyType>,
1887
1888 pub peer_addr: ::core::option::Option<[u8; 6]>,
1889
1890 pub rsc: ::core::option::Option<u64>,
1891
1892 pub cipher_oui: ::core::option::Option<[u8; 3]>,
1893
1894 pub cipher_type: ::core::option::Option<crate::natural::CipherSuiteType>,
1895 }
1896
1897 impl SetKeyDescriptor {
1898 fn __max_ordinal(&self) -> usize {
1899 if self.cipher_type.is_some() {
1900 return 7;
1901 }
1902
1903 if self.cipher_oui.is_some() {
1904 return 6;
1905 }
1906
1907 if self.rsc.is_some() {
1908 return 5;
1909 }
1910
1911 if self.peer_addr.is_some() {
1912 return 4;
1913 }
1914
1915 if self.key_type.is_some() {
1916 return 3;
1917 }
1918
1919 if self.key_id.is_some() {
1920 return 2;
1921 }
1922
1923 if self.key.is_some() {
1924 return 1;
1925 }
1926
1927 0
1928 }
1929 }
1930
1931 unsafe impl<___E> ::fidl_next::Encode<crate::wire::SetKeyDescriptor<'static>, ___E>
1932 for SetKeyDescriptor
1933 where
1934 ___E: ::fidl_next::Encoder + ?Sized,
1935 {
1936 #[inline]
1937 fn encode(
1938 mut self,
1939 encoder: &mut ___E,
1940 out: &mut ::core::mem::MaybeUninit<crate::wire::SetKeyDescriptor<'static>>,
1941 _: (),
1942 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1943 ::fidl_next::munge!(let crate::wire::SetKeyDescriptor { table } = out);
1944
1945 let max_ord = self.__max_ordinal();
1946
1947 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1948 ::fidl_next::Wire::zero_padding(&mut out);
1949
1950 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1951 ::fidl_next::wire::Envelope,
1952 >(encoder, max_ord);
1953
1954 for i in 1..=max_ord {
1955 match i {
1956 7 => {
1957 if let Some(value) = self.cipher_type.take() {
1958 ::fidl_next::wire::Envelope::encode_value::<
1959 crate::wire::CipherSuiteType,
1960 ___E,
1961 >(
1962 value, preallocated.encoder, &mut out, ()
1963 )?;
1964 } else {
1965 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1966 }
1967 }
1968
1969 6 => {
1970 if let Some(value) = self.cipher_oui.take() {
1971 ::fidl_next::wire::Envelope::encode_value::<[u8; 3], ___E>(
1972 value,
1973 preallocated.encoder,
1974 &mut out,
1975 (),
1976 )?;
1977 } else {
1978 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1979 }
1980 }
1981
1982 5 => {
1983 if let Some(value) = self.rsc.take() {
1984 ::fidl_next::wire::Envelope::encode_value::<
1985 ::fidl_next::wire::Uint64,
1986 ___E,
1987 >(
1988 value, preallocated.encoder, &mut out, ()
1989 )?;
1990 } else {
1991 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1992 }
1993 }
1994
1995 4 => {
1996 if let Some(value) = self.peer_addr.take() {
1997 ::fidl_next::wire::Envelope::encode_value::<[u8; 6], ___E>(
1998 value,
1999 preallocated.encoder,
2000 &mut out,
2001 (),
2002 )?;
2003 } else {
2004 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2005 }
2006 }
2007
2008 3 => {
2009 if let Some(value) = self.key_type.take() {
2010 ::fidl_next::wire::Envelope::encode_value::<crate::wire::KeyType, ___E>(
2011 value,
2012 preallocated.encoder,
2013 &mut out,
2014 (),
2015 )?;
2016 } else {
2017 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2018 }
2019 }
2020
2021 2 => {
2022 if let Some(value) = self.key_id.take() {
2023 ::fidl_next::wire::Envelope::encode_value::<
2024 ::fidl_next::wire::Uint16,
2025 ___E,
2026 >(
2027 value, preallocated.encoder, &mut out, ()
2028 )?;
2029 } else {
2030 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2031 }
2032 }
2033
2034 1 => {
2035 if let Some(value) = self.key.take() {
2036 ::fidl_next::wire::Envelope::encode_value::<
2037 ::fidl_next::wire::Vector<'static, u8>,
2038 ___E,
2039 >(
2040 value, preallocated.encoder, &mut out, (32, ())
2041 )?;
2042 } else {
2043 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2044 }
2045 }
2046
2047 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2048 }
2049 unsafe {
2050 preallocated.write_next(out.assume_init_ref());
2051 }
2052 }
2053
2054 ::fidl_next::wire::Table::encode_len(table, max_ord);
2055
2056 Ok(())
2057 }
2058 }
2059
2060 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SetKeyDescriptor<'static>, ___E>
2061 for &'a SetKeyDescriptor
2062 where
2063 ___E: ::fidl_next::Encoder + ?Sized,
2064 {
2065 #[inline]
2066 fn encode(
2067 self,
2068 encoder: &mut ___E,
2069 out: &mut ::core::mem::MaybeUninit<crate::wire::SetKeyDescriptor<'static>>,
2070 _: (),
2071 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2072 ::fidl_next::munge!(let crate::wire::SetKeyDescriptor { table } = out);
2073
2074 let max_ord = self.__max_ordinal();
2075
2076 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2077 ::fidl_next::Wire::zero_padding(&mut out);
2078
2079 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2080 ::fidl_next::wire::Envelope,
2081 >(encoder, max_ord);
2082
2083 for i in 1..=max_ord {
2084 match i {
2085 7 => {
2086 if let Some(value) = &self.cipher_type {
2087 ::fidl_next::wire::Envelope::encode_value::<
2088 crate::wire::CipherSuiteType,
2089 ___E,
2090 >(
2091 value, preallocated.encoder, &mut out, ()
2092 )?;
2093 } else {
2094 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2095 }
2096 }
2097
2098 6 => {
2099 if let Some(value) = &self.cipher_oui {
2100 ::fidl_next::wire::Envelope::encode_value::<[u8; 3], ___E>(
2101 value,
2102 preallocated.encoder,
2103 &mut out,
2104 (),
2105 )?;
2106 } else {
2107 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2108 }
2109 }
2110
2111 5 => {
2112 if let Some(value) = &self.rsc {
2113 ::fidl_next::wire::Envelope::encode_value::<
2114 ::fidl_next::wire::Uint64,
2115 ___E,
2116 >(
2117 value, preallocated.encoder, &mut out, ()
2118 )?;
2119 } else {
2120 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2121 }
2122 }
2123
2124 4 => {
2125 if let Some(value) = &self.peer_addr {
2126 ::fidl_next::wire::Envelope::encode_value::<[u8; 6], ___E>(
2127 value,
2128 preallocated.encoder,
2129 &mut out,
2130 (),
2131 )?;
2132 } else {
2133 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2134 }
2135 }
2136
2137 3 => {
2138 if let Some(value) = &self.key_type {
2139 ::fidl_next::wire::Envelope::encode_value::<crate::wire::KeyType, ___E>(
2140 value,
2141 preallocated.encoder,
2142 &mut out,
2143 (),
2144 )?;
2145 } else {
2146 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2147 }
2148 }
2149
2150 2 => {
2151 if let Some(value) = &self.key_id {
2152 ::fidl_next::wire::Envelope::encode_value::<
2153 ::fidl_next::wire::Uint16,
2154 ___E,
2155 >(
2156 value, preallocated.encoder, &mut out, ()
2157 )?;
2158 } else {
2159 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2160 }
2161 }
2162
2163 1 => {
2164 if let Some(value) = &self.key {
2165 ::fidl_next::wire::Envelope::encode_value::<
2166 ::fidl_next::wire::Vector<'static, u8>,
2167 ___E,
2168 >(
2169 value, preallocated.encoder, &mut out, (32, ())
2170 )?;
2171 } else {
2172 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2173 }
2174 }
2175
2176 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2177 }
2178 unsafe {
2179 preallocated.write_next(out.assume_init_ref());
2180 }
2181 }
2182
2183 ::fidl_next::wire::Table::encode_len(table, max_ord);
2184
2185 Ok(())
2186 }
2187 }
2188
2189 impl<'de> ::fidl_next::FromWire<crate::wire::SetKeyDescriptor<'de>> for SetKeyDescriptor {
2190 #[inline]
2191 fn from_wire(wire_: crate::wire::SetKeyDescriptor<'de>) -> Self {
2192 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
2193
2194 let key = wire_.table.get(1);
2195
2196 let key_id = wire_.table.get(2);
2197
2198 let key_type = wire_.table.get(3);
2199
2200 let peer_addr = wire_.table.get(4);
2201
2202 let rsc = wire_.table.get(5);
2203
2204 let cipher_oui = wire_.table.get(6);
2205
2206 let cipher_type = wire_.table.get(7);
2207
2208 Self {
2209 key: key.map(|envelope| {
2210 ::fidl_next::FromWire::from_wire(unsafe {
2211 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
2212 })
2213 }),
2214
2215 key_id: key_id.map(|envelope| {
2216 ::fidl_next::FromWire::from_wire(unsafe {
2217 envelope.read_unchecked::<::fidl_next::wire::Uint16>()
2218 })
2219 }),
2220
2221 key_type: key_type.map(|envelope| {
2222 ::fidl_next::FromWire::from_wire(unsafe {
2223 envelope.read_unchecked::<crate::wire::KeyType>()
2224 })
2225 }),
2226
2227 peer_addr: peer_addr.map(|envelope| {
2228 ::fidl_next::FromWire::from_wire(unsafe {
2229 envelope.read_unchecked::<[u8; 6]>()
2230 })
2231 }),
2232
2233 rsc: rsc.map(|envelope| {
2234 ::fidl_next::FromWire::from_wire(unsafe {
2235 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
2236 })
2237 }),
2238
2239 cipher_oui: cipher_oui.map(|envelope| {
2240 ::fidl_next::FromWire::from_wire(unsafe {
2241 envelope.read_unchecked::<[u8; 3]>()
2242 })
2243 }),
2244
2245 cipher_type: cipher_type.map(|envelope| {
2246 ::fidl_next::FromWire::from_wire(unsafe {
2247 envelope.read_unchecked::<crate::wire::CipherSuiteType>()
2248 })
2249 }),
2250 }
2251 }
2252 }
2253
2254 impl<'de> ::fidl_next::FromWireRef<crate::wire::SetKeyDescriptor<'de>> for SetKeyDescriptor {
2255 #[inline]
2256 fn from_wire_ref(wire: &crate::wire::SetKeyDescriptor<'de>) -> Self {
2257 Self {
2258 key: wire.table.get(1).map(|envelope| {
2259 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2260 envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
2261 })
2262 }),
2263
2264 key_id: wire.table.get(2).map(|envelope| {
2265 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2266 envelope.deref_unchecked::<::fidl_next::wire::Uint16>()
2267 })
2268 }),
2269
2270 key_type: wire.table.get(3).map(|envelope| {
2271 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2272 envelope.deref_unchecked::<crate::wire::KeyType>()
2273 })
2274 }),
2275
2276 peer_addr: wire.table.get(4).map(|envelope| {
2277 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2278 envelope.deref_unchecked::<[u8; 6]>()
2279 })
2280 }),
2281
2282 rsc: wire.table.get(5).map(|envelope| {
2283 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2284 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
2285 })
2286 }),
2287
2288 cipher_oui: wire.table.get(6).map(|envelope| {
2289 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2290 envelope.deref_unchecked::<[u8; 3]>()
2291 })
2292 }),
2293
2294 cipher_type: wire.table.get(7).map(|envelope| {
2295 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2296 envelope.deref_unchecked::<crate::wire::CipherSuiteType>()
2297 })
2298 }),
2299 }
2300 }
2301 }
2302
2303 pub type Ssid = ::std::vec::Vec<u8>;
2304
2305 #[doc = " 802.11 status codes. These values are common throughout the standard.\n IEEE Std 802.11-2016, 9.4.1.9, Table 9-46\n"]
2306 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2307 #[repr(u16)]
2308 pub enum StatusCode {
2309 Success = 0,
2310 RefusedReasonUnspecified = 1,
2311 TdlsRejectedAlternativeProvided = 2,
2312 TdlsRejected = 3,
2313 SecurityDisabled = 5,
2314 UnacceptableLifetime = 6,
2315 NotInSameBss = 7,
2316 RefusedCapabilitiesMismatch = 10,
2317 DeniedNoAssociationExists = 11,
2318 DeniedOtherReason = 12,
2319 UnsupportedAuthAlgorithm = 13,
2320 TransactionSequenceError = 14,
2321 ChallengeFailure = 15,
2322 RejectedSequenceTimeout = 16,
2323 DeniedNoMoreStas = 17,
2324 RefusedBasicRatesMismatch = 18,
2325 DeniedNoShortPreambleSupport = 19,
2326 RejectedSpectrumManagementRequired = 22,
2327 RejectedBadPowerCapability = 23,
2328 RejectedBadSupportedChannels = 24,
2329 DeniedNoShortSlotTimeSupport = 25,
2330 DeniedNoHtSupport = 27,
2331 R0KhUnreachable = 28,
2332 DeniedPcoTimeNotSupported = 29,
2333 RefusedTemporarily = 30,
2334 RobustManagementPolicyViolation = 31,
2335 UnspecifiedQosFailure = 32,
2336 DeniedInsufficientBandwidth = 33,
2337 DeniedPoorChannelConditions = 34,
2338 DeniedQosNotSupported = 35,
2339 RequestDeclined = 37,
2340 InvalidParameters = 38,
2341 RejectedWithSuggestedChanges = 39,
2342 StatusInvalidElement = 40,
2343 StatusInvalidGroupCipher = 41,
2344 StatusInvalidPairwiseCipher = 42,
2345 StatusInvalidAkmp = 43,
2346 UnsupportedRsneVersion = 44,
2347 InvalidRsneCapabilities = 45,
2348 StatusCipherOutOfPolicy = 46,
2349 RejectedForDelayPeriod = 47,
2350 DlsNotAllowed = 48,
2351 NotPresent = 49,
2352 NotQosSta = 50,
2353 DeniedListenIntervalTooLarge = 51,
2354 StatusInvalidFtActionFrameCount = 52,
2355 StatusInvalidPmkid = 53,
2356 StatusInvalidMde = 54,
2357 StatusInvalidFte = 55,
2358 RequestedTclasNotSupportedByAp = 56,
2359 InsufficientTclasProcessingResources = 57,
2360 TryAnotherBss = 58,
2361 GasAdvertisementProtocolNotSupported = 59,
2362 NoOutstandingGasRequest = 60,
2363 GasResponseNotReceivedFromServer = 61,
2364 GasQueryTimeout = 62,
2365 GasQueryResponseTooLarge = 63,
2366 RejectedHomeWithSuggestedChanges = 64,
2367 ServerUnreachable = 65,
2368 RejectedForSspPermissions = 67,
2369 RefusedUnauthenticatedAccessNotSupported = 68,
2370 InvalidRsne = 72,
2371 UApsdCoexistanceNotSupported = 73,
2372 UApsdCoexModeNotSupported = 74,
2373 BadIntervalWithUApsdCoex = 75,
2374 AntiCloggingTokenRequired = 76,
2375 UnsupportedFiniteCyclicGroup = 77,
2376 CannotFindAlternativeTbtt = 78,
2377 TransmissionFailure = 79,
2378 RequestedTclasNotSupported = 80,
2379 TclasResourcesExhausted = 81,
2380 RejectedWithSuggestedBssTransition = 82,
2381 RejectWithSchedule = 83,
2382 RejectNoWakeupSpecified = 84,
2383 SuccessPowerSaveMode = 85,
2384 PendingAdmittingFstSession = 86,
2385 PerformingFstNow = 87,
2386 PendingGapInBaWindow = 88,
2387 RejectUPidSetting = 89,
2388 RefusedExternalReason = 92,
2389 RefusedApOutOfMemory = 93,
2390 RejectedEmergencyServicesNotSupported = 94,
2391 QueryResponseOutstanding = 95,
2392 RejectDseBand = 96,
2393 TclasProcessingTerminated = 97,
2394 TsScheduleConflict = 98,
2395 DeniedWithSuggestedBandAndChannel = 99,
2396 MccaopReservationConflict = 100,
2397 MafLimitExceeded = 101,
2398 MccaTrackLimitExceeded = 102,
2399 DeniedDueToSpectrumManagement = 103,
2400 DeniedVhtNotSupported = 104,
2401 EnablementDenied = 105,
2402 RestrictionFromAuthorizedGdb = 106,
2403 AuthorizationDeenabled = 107,
2404 EnergyLimitedOperationNotSupported = 108,
2405 RejectedNdpBlockAckSuggested = 109,
2406 RejectedMaxAwayDurationUnacceptable = 110,
2407 FlowControlOperationSupported = 111,
2408 FilsAuthenticationFailure = 112,
2409 UnknownAuthenticationServer = 113,
2410 DeniedNotificationPeriodAllocation = 116,
2411 DeniedChannelSplitting = 117,
2412 DeniedAllocation = 118,
2413 CmmgFeaturesNotSupported = 119,
2414 GasFragmentNotAvailable = 120,
2415 SuccessCagVersionsMatch = 121,
2416 GlkNotAuthorized = 122,
2417 UnknownPasswordIdentifier = 123,
2418 DeniedLocalMacAddressPolicyViolation = 125,
2419 SaeHashToElement = 126,
2420 TclasProcessingTerminatedInsufficientQos = 128,
2421 TclasProcessingTerminatedPolicyConflict = 129,
2422 JoinFailure = 256,
2423 SpuriousDeauthOrDisassoc = 257,
2424 Canceled = 258,
2425 EstablishRsnaFailure = 259,
2426 OweHandshakeFailure = 260,
2427 UnknownOrdinal_(u16) = 261,
2428 }
2429 impl ::std::convert::From<u16> for StatusCode {
2430 fn from(value: u16) -> Self {
2431 match value {
2432 0 => Self::Success,
2433 1 => Self::RefusedReasonUnspecified,
2434 2 => Self::TdlsRejectedAlternativeProvided,
2435 3 => Self::TdlsRejected,
2436 5 => Self::SecurityDisabled,
2437 6 => Self::UnacceptableLifetime,
2438 7 => Self::NotInSameBss,
2439 10 => Self::RefusedCapabilitiesMismatch,
2440 11 => Self::DeniedNoAssociationExists,
2441 12 => Self::DeniedOtherReason,
2442 13 => Self::UnsupportedAuthAlgorithm,
2443 14 => Self::TransactionSequenceError,
2444 15 => Self::ChallengeFailure,
2445 16 => Self::RejectedSequenceTimeout,
2446 17 => Self::DeniedNoMoreStas,
2447 18 => Self::RefusedBasicRatesMismatch,
2448 19 => Self::DeniedNoShortPreambleSupport,
2449 22 => Self::RejectedSpectrumManagementRequired,
2450 23 => Self::RejectedBadPowerCapability,
2451 24 => Self::RejectedBadSupportedChannels,
2452 25 => Self::DeniedNoShortSlotTimeSupport,
2453 27 => Self::DeniedNoHtSupport,
2454 28 => Self::R0KhUnreachable,
2455 29 => Self::DeniedPcoTimeNotSupported,
2456 30 => Self::RefusedTemporarily,
2457 31 => Self::RobustManagementPolicyViolation,
2458 32 => Self::UnspecifiedQosFailure,
2459 33 => Self::DeniedInsufficientBandwidth,
2460 34 => Self::DeniedPoorChannelConditions,
2461 35 => Self::DeniedQosNotSupported,
2462 37 => Self::RequestDeclined,
2463 38 => Self::InvalidParameters,
2464 39 => Self::RejectedWithSuggestedChanges,
2465 40 => Self::StatusInvalidElement,
2466 41 => Self::StatusInvalidGroupCipher,
2467 42 => Self::StatusInvalidPairwiseCipher,
2468 43 => Self::StatusInvalidAkmp,
2469 44 => Self::UnsupportedRsneVersion,
2470 45 => Self::InvalidRsneCapabilities,
2471 46 => Self::StatusCipherOutOfPolicy,
2472 47 => Self::RejectedForDelayPeriod,
2473 48 => Self::DlsNotAllowed,
2474 49 => Self::NotPresent,
2475 50 => Self::NotQosSta,
2476 51 => Self::DeniedListenIntervalTooLarge,
2477 52 => Self::StatusInvalidFtActionFrameCount,
2478 53 => Self::StatusInvalidPmkid,
2479 54 => Self::StatusInvalidMde,
2480 55 => Self::StatusInvalidFte,
2481 56 => Self::RequestedTclasNotSupportedByAp,
2482 57 => Self::InsufficientTclasProcessingResources,
2483 58 => Self::TryAnotherBss,
2484 59 => Self::GasAdvertisementProtocolNotSupported,
2485 60 => Self::NoOutstandingGasRequest,
2486 61 => Self::GasResponseNotReceivedFromServer,
2487 62 => Self::GasQueryTimeout,
2488 63 => Self::GasQueryResponseTooLarge,
2489 64 => Self::RejectedHomeWithSuggestedChanges,
2490 65 => Self::ServerUnreachable,
2491 67 => Self::RejectedForSspPermissions,
2492 68 => Self::RefusedUnauthenticatedAccessNotSupported,
2493 72 => Self::InvalidRsne,
2494 73 => Self::UApsdCoexistanceNotSupported,
2495 74 => Self::UApsdCoexModeNotSupported,
2496 75 => Self::BadIntervalWithUApsdCoex,
2497 76 => Self::AntiCloggingTokenRequired,
2498 77 => Self::UnsupportedFiniteCyclicGroup,
2499 78 => Self::CannotFindAlternativeTbtt,
2500 79 => Self::TransmissionFailure,
2501 80 => Self::RequestedTclasNotSupported,
2502 81 => Self::TclasResourcesExhausted,
2503 82 => Self::RejectedWithSuggestedBssTransition,
2504 83 => Self::RejectWithSchedule,
2505 84 => Self::RejectNoWakeupSpecified,
2506 85 => Self::SuccessPowerSaveMode,
2507 86 => Self::PendingAdmittingFstSession,
2508 87 => Self::PerformingFstNow,
2509 88 => Self::PendingGapInBaWindow,
2510 89 => Self::RejectUPidSetting,
2511 92 => Self::RefusedExternalReason,
2512 93 => Self::RefusedApOutOfMemory,
2513 94 => Self::RejectedEmergencyServicesNotSupported,
2514 95 => Self::QueryResponseOutstanding,
2515 96 => Self::RejectDseBand,
2516 97 => Self::TclasProcessingTerminated,
2517 98 => Self::TsScheduleConflict,
2518 99 => Self::DeniedWithSuggestedBandAndChannel,
2519 100 => Self::MccaopReservationConflict,
2520 101 => Self::MafLimitExceeded,
2521 102 => Self::MccaTrackLimitExceeded,
2522 103 => Self::DeniedDueToSpectrumManagement,
2523 104 => Self::DeniedVhtNotSupported,
2524 105 => Self::EnablementDenied,
2525 106 => Self::RestrictionFromAuthorizedGdb,
2526 107 => Self::AuthorizationDeenabled,
2527 108 => Self::EnergyLimitedOperationNotSupported,
2528 109 => Self::RejectedNdpBlockAckSuggested,
2529 110 => Self::RejectedMaxAwayDurationUnacceptable,
2530 111 => Self::FlowControlOperationSupported,
2531 112 => Self::FilsAuthenticationFailure,
2532 113 => Self::UnknownAuthenticationServer,
2533 116 => Self::DeniedNotificationPeriodAllocation,
2534 117 => Self::DeniedChannelSplitting,
2535 118 => Self::DeniedAllocation,
2536 119 => Self::CmmgFeaturesNotSupported,
2537 120 => Self::GasFragmentNotAvailable,
2538 121 => Self::SuccessCagVersionsMatch,
2539 122 => Self::GlkNotAuthorized,
2540 123 => Self::UnknownPasswordIdentifier,
2541 125 => Self::DeniedLocalMacAddressPolicyViolation,
2542 126 => Self::SaeHashToElement,
2543 128 => Self::TclasProcessingTerminatedInsufficientQos,
2544 129 => Self::TclasProcessingTerminatedPolicyConflict,
2545 256 => Self::JoinFailure,
2546 257 => Self::SpuriousDeauthOrDisassoc,
2547 258 => Self::Canceled,
2548 259 => Self::EstablishRsnaFailure,
2549 260 => Self::OweHandshakeFailure,
2550
2551 _ => Self::UnknownOrdinal_(value),
2552 }
2553 }
2554 }
2555
2556 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StatusCode, ___E> for StatusCode
2557 where
2558 ___E: ?Sized,
2559 {
2560 #[inline]
2561 fn encode(
2562 self,
2563 encoder: &mut ___E,
2564 out: &mut ::core::mem::MaybeUninit<crate::wire::StatusCode>,
2565 _: (),
2566 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2567 ::fidl_next::Encode::encode(&self, encoder, out, ())
2568 }
2569 }
2570
2571 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::StatusCode, ___E> for &'a StatusCode
2572 where
2573 ___E: ?Sized,
2574 {
2575 #[inline]
2576 fn encode(
2577 self,
2578 encoder: &mut ___E,
2579 out: &mut ::core::mem::MaybeUninit<crate::wire::StatusCode>,
2580 _: (),
2581 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2582 ::fidl_next::munge!(let crate::wire::StatusCode { value } = out);
2583 let _ = value.write(::fidl_next::wire::Uint16::from(match *self {
2584 StatusCode::Success => 0,
2585
2586 StatusCode::RefusedReasonUnspecified => 1,
2587
2588 StatusCode::TdlsRejectedAlternativeProvided => 2,
2589
2590 StatusCode::TdlsRejected => 3,
2591
2592 StatusCode::SecurityDisabled => 5,
2593
2594 StatusCode::UnacceptableLifetime => 6,
2595
2596 StatusCode::NotInSameBss => 7,
2597
2598 StatusCode::RefusedCapabilitiesMismatch => 10,
2599
2600 StatusCode::DeniedNoAssociationExists => 11,
2601
2602 StatusCode::DeniedOtherReason => 12,
2603
2604 StatusCode::UnsupportedAuthAlgorithm => 13,
2605
2606 StatusCode::TransactionSequenceError => 14,
2607
2608 StatusCode::ChallengeFailure => 15,
2609
2610 StatusCode::RejectedSequenceTimeout => 16,
2611
2612 StatusCode::DeniedNoMoreStas => 17,
2613
2614 StatusCode::RefusedBasicRatesMismatch => 18,
2615
2616 StatusCode::DeniedNoShortPreambleSupport => 19,
2617
2618 StatusCode::RejectedSpectrumManagementRequired => 22,
2619
2620 StatusCode::RejectedBadPowerCapability => 23,
2621
2622 StatusCode::RejectedBadSupportedChannels => 24,
2623
2624 StatusCode::DeniedNoShortSlotTimeSupport => 25,
2625
2626 StatusCode::DeniedNoHtSupport => 27,
2627
2628 StatusCode::R0KhUnreachable => 28,
2629
2630 StatusCode::DeniedPcoTimeNotSupported => 29,
2631
2632 StatusCode::RefusedTemporarily => 30,
2633
2634 StatusCode::RobustManagementPolicyViolation => 31,
2635
2636 StatusCode::UnspecifiedQosFailure => 32,
2637
2638 StatusCode::DeniedInsufficientBandwidth => 33,
2639
2640 StatusCode::DeniedPoorChannelConditions => 34,
2641
2642 StatusCode::DeniedQosNotSupported => 35,
2643
2644 StatusCode::RequestDeclined => 37,
2645
2646 StatusCode::InvalidParameters => 38,
2647
2648 StatusCode::RejectedWithSuggestedChanges => 39,
2649
2650 StatusCode::StatusInvalidElement => 40,
2651
2652 StatusCode::StatusInvalidGroupCipher => 41,
2653
2654 StatusCode::StatusInvalidPairwiseCipher => 42,
2655
2656 StatusCode::StatusInvalidAkmp => 43,
2657
2658 StatusCode::UnsupportedRsneVersion => 44,
2659
2660 StatusCode::InvalidRsneCapabilities => 45,
2661
2662 StatusCode::StatusCipherOutOfPolicy => 46,
2663
2664 StatusCode::RejectedForDelayPeriod => 47,
2665
2666 StatusCode::DlsNotAllowed => 48,
2667
2668 StatusCode::NotPresent => 49,
2669
2670 StatusCode::NotQosSta => 50,
2671
2672 StatusCode::DeniedListenIntervalTooLarge => 51,
2673
2674 StatusCode::StatusInvalidFtActionFrameCount => 52,
2675
2676 StatusCode::StatusInvalidPmkid => 53,
2677
2678 StatusCode::StatusInvalidMde => 54,
2679
2680 StatusCode::StatusInvalidFte => 55,
2681
2682 StatusCode::RequestedTclasNotSupportedByAp => 56,
2683
2684 StatusCode::InsufficientTclasProcessingResources => 57,
2685
2686 StatusCode::TryAnotherBss => 58,
2687
2688 StatusCode::GasAdvertisementProtocolNotSupported => 59,
2689
2690 StatusCode::NoOutstandingGasRequest => 60,
2691
2692 StatusCode::GasResponseNotReceivedFromServer => 61,
2693
2694 StatusCode::GasQueryTimeout => 62,
2695
2696 StatusCode::GasQueryResponseTooLarge => 63,
2697
2698 StatusCode::RejectedHomeWithSuggestedChanges => 64,
2699
2700 StatusCode::ServerUnreachable => 65,
2701
2702 StatusCode::RejectedForSspPermissions => 67,
2703
2704 StatusCode::RefusedUnauthenticatedAccessNotSupported => 68,
2705
2706 StatusCode::InvalidRsne => 72,
2707
2708 StatusCode::UApsdCoexistanceNotSupported => 73,
2709
2710 StatusCode::UApsdCoexModeNotSupported => 74,
2711
2712 StatusCode::BadIntervalWithUApsdCoex => 75,
2713
2714 StatusCode::AntiCloggingTokenRequired => 76,
2715
2716 StatusCode::UnsupportedFiniteCyclicGroup => 77,
2717
2718 StatusCode::CannotFindAlternativeTbtt => 78,
2719
2720 StatusCode::TransmissionFailure => 79,
2721
2722 StatusCode::RequestedTclasNotSupported => 80,
2723
2724 StatusCode::TclasResourcesExhausted => 81,
2725
2726 StatusCode::RejectedWithSuggestedBssTransition => 82,
2727
2728 StatusCode::RejectWithSchedule => 83,
2729
2730 StatusCode::RejectNoWakeupSpecified => 84,
2731
2732 StatusCode::SuccessPowerSaveMode => 85,
2733
2734 StatusCode::PendingAdmittingFstSession => 86,
2735
2736 StatusCode::PerformingFstNow => 87,
2737
2738 StatusCode::PendingGapInBaWindow => 88,
2739
2740 StatusCode::RejectUPidSetting => 89,
2741
2742 StatusCode::RefusedExternalReason => 92,
2743
2744 StatusCode::RefusedApOutOfMemory => 93,
2745
2746 StatusCode::RejectedEmergencyServicesNotSupported => 94,
2747
2748 StatusCode::QueryResponseOutstanding => 95,
2749
2750 StatusCode::RejectDseBand => 96,
2751
2752 StatusCode::TclasProcessingTerminated => 97,
2753
2754 StatusCode::TsScheduleConflict => 98,
2755
2756 StatusCode::DeniedWithSuggestedBandAndChannel => 99,
2757
2758 StatusCode::MccaopReservationConflict => 100,
2759
2760 StatusCode::MafLimitExceeded => 101,
2761
2762 StatusCode::MccaTrackLimitExceeded => 102,
2763
2764 StatusCode::DeniedDueToSpectrumManagement => 103,
2765
2766 StatusCode::DeniedVhtNotSupported => 104,
2767
2768 StatusCode::EnablementDenied => 105,
2769
2770 StatusCode::RestrictionFromAuthorizedGdb => 106,
2771
2772 StatusCode::AuthorizationDeenabled => 107,
2773
2774 StatusCode::EnergyLimitedOperationNotSupported => 108,
2775
2776 StatusCode::RejectedNdpBlockAckSuggested => 109,
2777
2778 StatusCode::RejectedMaxAwayDurationUnacceptable => 110,
2779
2780 StatusCode::FlowControlOperationSupported => 111,
2781
2782 StatusCode::FilsAuthenticationFailure => 112,
2783
2784 StatusCode::UnknownAuthenticationServer => 113,
2785
2786 StatusCode::DeniedNotificationPeriodAllocation => 116,
2787
2788 StatusCode::DeniedChannelSplitting => 117,
2789
2790 StatusCode::DeniedAllocation => 118,
2791
2792 StatusCode::CmmgFeaturesNotSupported => 119,
2793
2794 StatusCode::GasFragmentNotAvailable => 120,
2795
2796 StatusCode::SuccessCagVersionsMatch => 121,
2797
2798 StatusCode::GlkNotAuthorized => 122,
2799
2800 StatusCode::UnknownPasswordIdentifier => 123,
2801
2802 StatusCode::DeniedLocalMacAddressPolicyViolation => 125,
2803
2804 StatusCode::SaeHashToElement => 126,
2805
2806 StatusCode::TclasProcessingTerminatedInsufficientQos => 128,
2807
2808 StatusCode::TclasProcessingTerminatedPolicyConflict => 129,
2809
2810 StatusCode::JoinFailure => 256,
2811
2812 StatusCode::SpuriousDeauthOrDisassoc => 257,
2813
2814 StatusCode::Canceled => 258,
2815
2816 StatusCode::EstablishRsnaFailure => 259,
2817
2818 StatusCode::OweHandshakeFailure => 260,
2819
2820 StatusCode::UnknownOrdinal_(value) => value,
2821 }));
2822
2823 Ok(())
2824 }
2825 }
2826
2827 impl ::core::convert::From<crate::wire::StatusCode> for StatusCode {
2828 fn from(wire: crate::wire::StatusCode) -> Self {
2829 match u16::from(wire.value) {
2830 0 => Self::Success,
2831
2832 1 => Self::RefusedReasonUnspecified,
2833
2834 2 => Self::TdlsRejectedAlternativeProvided,
2835
2836 3 => Self::TdlsRejected,
2837
2838 5 => Self::SecurityDisabled,
2839
2840 6 => Self::UnacceptableLifetime,
2841
2842 7 => Self::NotInSameBss,
2843
2844 10 => Self::RefusedCapabilitiesMismatch,
2845
2846 11 => Self::DeniedNoAssociationExists,
2847
2848 12 => Self::DeniedOtherReason,
2849
2850 13 => Self::UnsupportedAuthAlgorithm,
2851
2852 14 => Self::TransactionSequenceError,
2853
2854 15 => Self::ChallengeFailure,
2855
2856 16 => Self::RejectedSequenceTimeout,
2857
2858 17 => Self::DeniedNoMoreStas,
2859
2860 18 => Self::RefusedBasicRatesMismatch,
2861
2862 19 => Self::DeniedNoShortPreambleSupport,
2863
2864 22 => Self::RejectedSpectrumManagementRequired,
2865
2866 23 => Self::RejectedBadPowerCapability,
2867
2868 24 => Self::RejectedBadSupportedChannels,
2869
2870 25 => Self::DeniedNoShortSlotTimeSupport,
2871
2872 27 => Self::DeniedNoHtSupport,
2873
2874 28 => Self::R0KhUnreachable,
2875
2876 29 => Self::DeniedPcoTimeNotSupported,
2877
2878 30 => Self::RefusedTemporarily,
2879
2880 31 => Self::RobustManagementPolicyViolation,
2881
2882 32 => Self::UnspecifiedQosFailure,
2883
2884 33 => Self::DeniedInsufficientBandwidth,
2885
2886 34 => Self::DeniedPoorChannelConditions,
2887
2888 35 => Self::DeniedQosNotSupported,
2889
2890 37 => Self::RequestDeclined,
2891
2892 38 => Self::InvalidParameters,
2893
2894 39 => Self::RejectedWithSuggestedChanges,
2895
2896 40 => Self::StatusInvalidElement,
2897
2898 41 => Self::StatusInvalidGroupCipher,
2899
2900 42 => Self::StatusInvalidPairwiseCipher,
2901
2902 43 => Self::StatusInvalidAkmp,
2903
2904 44 => Self::UnsupportedRsneVersion,
2905
2906 45 => Self::InvalidRsneCapabilities,
2907
2908 46 => Self::StatusCipherOutOfPolicy,
2909
2910 47 => Self::RejectedForDelayPeriod,
2911
2912 48 => Self::DlsNotAllowed,
2913
2914 49 => Self::NotPresent,
2915
2916 50 => Self::NotQosSta,
2917
2918 51 => Self::DeniedListenIntervalTooLarge,
2919
2920 52 => Self::StatusInvalidFtActionFrameCount,
2921
2922 53 => Self::StatusInvalidPmkid,
2923
2924 54 => Self::StatusInvalidMde,
2925
2926 55 => Self::StatusInvalidFte,
2927
2928 56 => Self::RequestedTclasNotSupportedByAp,
2929
2930 57 => Self::InsufficientTclasProcessingResources,
2931
2932 58 => Self::TryAnotherBss,
2933
2934 59 => Self::GasAdvertisementProtocolNotSupported,
2935
2936 60 => Self::NoOutstandingGasRequest,
2937
2938 61 => Self::GasResponseNotReceivedFromServer,
2939
2940 62 => Self::GasQueryTimeout,
2941
2942 63 => Self::GasQueryResponseTooLarge,
2943
2944 64 => Self::RejectedHomeWithSuggestedChanges,
2945
2946 65 => Self::ServerUnreachable,
2947
2948 67 => Self::RejectedForSspPermissions,
2949
2950 68 => Self::RefusedUnauthenticatedAccessNotSupported,
2951
2952 72 => Self::InvalidRsne,
2953
2954 73 => Self::UApsdCoexistanceNotSupported,
2955
2956 74 => Self::UApsdCoexModeNotSupported,
2957
2958 75 => Self::BadIntervalWithUApsdCoex,
2959
2960 76 => Self::AntiCloggingTokenRequired,
2961
2962 77 => Self::UnsupportedFiniteCyclicGroup,
2963
2964 78 => Self::CannotFindAlternativeTbtt,
2965
2966 79 => Self::TransmissionFailure,
2967
2968 80 => Self::RequestedTclasNotSupported,
2969
2970 81 => Self::TclasResourcesExhausted,
2971
2972 82 => Self::RejectedWithSuggestedBssTransition,
2973
2974 83 => Self::RejectWithSchedule,
2975
2976 84 => Self::RejectNoWakeupSpecified,
2977
2978 85 => Self::SuccessPowerSaveMode,
2979
2980 86 => Self::PendingAdmittingFstSession,
2981
2982 87 => Self::PerformingFstNow,
2983
2984 88 => Self::PendingGapInBaWindow,
2985
2986 89 => Self::RejectUPidSetting,
2987
2988 92 => Self::RefusedExternalReason,
2989
2990 93 => Self::RefusedApOutOfMemory,
2991
2992 94 => Self::RejectedEmergencyServicesNotSupported,
2993
2994 95 => Self::QueryResponseOutstanding,
2995
2996 96 => Self::RejectDseBand,
2997
2998 97 => Self::TclasProcessingTerminated,
2999
3000 98 => Self::TsScheduleConflict,
3001
3002 99 => Self::DeniedWithSuggestedBandAndChannel,
3003
3004 100 => Self::MccaopReservationConflict,
3005
3006 101 => Self::MafLimitExceeded,
3007
3008 102 => Self::MccaTrackLimitExceeded,
3009
3010 103 => Self::DeniedDueToSpectrumManagement,
3011
3012 104 => Self::DeniedVhtNotSupported,
3013
3014 105 => Self::EnablementDenied,
3015
3016 106 => Self::RestrictionFromAuthorizedGdb,
3017
3018 107 => Self::AuthorizationDeenabled,
3019
3020 108 => Self::EnergyLimitedOperationNotSupported,
3021
3022 109 => Self::RejectedNdpBlockAckSuggested,
3023
3024 110 => Self::RejectedMaxAwayDurationUnacceptable,
3025
3026 111 => Self::FlowControlOperationSupported,
3027
3028 112 => Self::FilsAuthenticationFailure,
3029
3030 113 => Self::UnknownAuthenticationServer,
3031
3032 116 => Self::DeniedNotificationPeriodAllocation,
3033
3034 117 => Self::DeniedChannelSplitting,
3035
3036 118 => Self::DeniedAllocation,
3037
3038 119 => Self::CmmgFeaturesNotSupported,
3039
3040 120 => Self::GasFragmentNotAvailable,
3041
3042 121 => Self::SuccessCagVersionsMatch,
3043
3044 122 => Self::GlkNotAuthorized,
3045
3046 123 => Self::UnknownPasswordIdentifier,
3047
3048 125 => Self::DeniedLocalMacAddressPolicyViolation,
3049
3050 126 => Self::SaeHashToElement,
3051
3052 128 => Self::TclasProcessingTerminatedInsufficientQos,
3053
3054 129 => Self::TclasProcessingTerminatedPolicyConflict,
3055
3056 256 => Self::JoinFailure,
3057
3058 257 => Self::SpuriousDeauthOrDisassoc,
3059
3060 258 => Self::Canceled,
3061
3062 259 => Self::EstablishRsnaFailure,
3063
3064 260 => Self::OweHandshakeFailure,
3065
3066 value => Self::UnknownOrdinal_(value),
3067 }
3068 }
3069 }
3070
3071 impl ::fidl_next::FromWire<crate::wire::StatusCode> for StatusCode {
3072 #[inline]
3073 fn from_wire(wire: crate::wire::StatusCode) -> Self {
3074 Self::from(wire)
3075 }
3076 }
3077
3078 impl ::fidl_next::FromWireRef<crate::wire::StatusCode> for StatusCode {
3079 #[inline]
3080 fn from_wire_ref(wire: &crate::wire::StatusCode) -> Self {
3081 Self::from(*wire)
3082 }
3083 }
3084
3085 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3086 #[repr(C)]
3087 pub struct VhtCapabilities {
3088 pub bytes: [u8; 12],
3089 }
3090
3091 unsafe impl<___E> ::fidl_next::Encode<crate::wire::VhtCapabilities, ___E> for VhtCapabilities
3092 where
3093 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3094 {
3095 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::VhtCapabilities> = unsafe {
3096 ::fidl_next::CopyOptimization::enable_if(
3097 true && <[u8; 12] as ::fidl_next::Encode<[u8; 12], ___E>>::COPY_OPTIMIZATION
3098 .is_enabled(),
3099 )
3100 };
3101
3102 #[inline]
3103 fn encode(
3104 self,
3105 encoder_: &mut ___E,
3106 out_: &mut ::core::mem::MaybeUninit<crate::wire::VhtCapabilities>,
3107 _: (),
3108 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3109 ::fidl_next::munge! {
3110 let crate::wire::VhtCapabilities {
3111 bytes,
3112
3113 } = out_;
3114 }
3115
3116 ::fidl_next::Encode::encode(self.bytes, encoder_, bytes, ())?;
3117
3118 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bytes.as_mut_ptr()) };
3119
3120 Ok(())
3121 }
3122 }
3123
3124 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::VhtCapabilities, ___E>
3125 for &'a VhtCapabilities
3126 where
3127 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3128 {
3129 #[inline]
3130 fn encode(
3131 self,
3132 encoder_: &mut ___E,
3133 out_: &mut ::core::mem::MaybeUninit<crate::wire::VhtCapabilities>,
3134 _: (),
3135 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3136 ::fidl_next::munge! {
3137 let crate::wire::VhtCapabilities {
3138 bytes,
3139
3140 } = out_;
3141 }
3142
3143 ::fidl_next::Encode::encode(&self.bytes, encoder_, bytes, ())?;
3144
3145 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bytes.as_mut_ptr()) };
3146
3147 Ok(())
3148 }
3149 }
3150
3151 unsafe impl<___E>
3152 ::fidl_next::EncodeOption<
3153 ::fidl_next::wire::Box<'static, crate::wire::VhtCapabilities>,
3154 ___E,
3155 > for VhtCapabilities
3156 where
3157 ___E: ::fidl_next::Encoder + ?Sized,
3158 VhtCapabilities: ::fidl_next::Encode<crate::wire::VhtCapabilities, ___E>,
3159 {
3160 #[inline]
3161 fn encode_option(
3162 this: ::core::option::Option<Self>,
3163 encoder: &mut ___E,
3164 out: &mut ::core::mem::MaybeUninit<
3165 ::fidl_next::wire::Box<'static, crate::wire::VhtCapabilities>,
3166 >,
3167 _: (),
3168 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3169 if let Some(inner) = this {
3170 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3171 ::fidl_next::wire::Box::encode_present(out);
3172 } else {
3173 ::fidl_next::wire::Box::encode_absent(out);
3174 }
3175
3176 Ok(())
3177 }
3178 }
3179
3180 unsafe impl<'a, ___E>
3181 ::fidl_next::EncodeOption<
3182 ::fidl_next::wire::Box<'static, crate::wire::VhtCapabilities>,
3183 ___E,
3184 > for &'a VhtCapabilities
3185 where
3186 ___E: ::fidl_next::Encoder + ?Sized,
3187 &'a VhtCapabilities: ::fidl_next::Encode<crate::wire::VhtCapabilities, ___E>,
3188 {
3189 #[inline]
3190 fn encode_option(
3191 this: ::core::option::Option<Self>,
3192 encoder: &mut ___E,
3193 out: &mut ::core::mem::MaybeUninit<
3194 ::fidl_next::wire::Box<'static, crate::wire::VhtCapabilities>,
3195 >,
3196 _: (),
3197 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3198 if let Some(inner) = this {
3199 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3200 ::fidl_next::wire::Box::encode_present(out);
3201 } else {
3202 ::fidl_next::wire::Box::encode_absent(out);
3203 }
3204
3205 Ok(())
3206 }
3207 }
3208
3209 impl ::fidl_next::FromWire<crate::wire::VhtCapabilities> for VhtCapabilities {
3210 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::VhtCapabilities, Self> = unsafe {
3211 ::fidl_next::CopyOptimization::enable_if(
3212 true && <[u8; 12] as ::fidl_next::FromWire<[u8; 12]>>::COPY_OPTIMIZATION
3213 .is_enabled(),
3214 )
3215 };
3216
3217 #[inline]
3218 fn from_wire(wire: crate::wire::VhtCapabilities) -> Self {
3219 Self { bytes: ::fidl_next::FromWire::from_wire(wire.bytes) }
3220 }
3221 }
3222
3223 impl ::fidl_next::FromWireRef<crate::wire::VhtCapabilities> for VhtCapabilities {
3224 #[inline]
3225 fn from_wire_ref(wire: &crate::wire::VhtCapabilities) -> Self {
3226 Self { bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.bytes) }
3227 }
3228 }
3229
3230 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3231 #[repr(C)]
3232 pub struct VhtOperation {
3233 pub bytes: [u8; 5],
3234 }
3235
3236 unsafe impl<___E> ::fidl_next::Encode<crate::wire::VhtOperation, ___E> for VhtOperation
3237 where
3238 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3239 {
3240 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::VhtOperation> = unsafe {
3241 ::fidl_next::CopyOptimization::enable_if(
3242 true && <[u8; 5] as ::fidl_next::Encode<[u8; 5], ___E>>::COPY_OPTIMIZATION
3243 .is_enabled(),
3244 )
3245 };
3246
3247 #[inline]
3248 fn encode(
3249 self,
3250 encoder_: &mut ___E,
3251 out_: &mut ::core::mem::MaybeUninit<crate::wire::VhtOperation>,
3252 _: (),
3253 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3254 ::fidl_next::munge! {
3255 let crate::wire::VhtOperation {
3256 bytes,
3257
3258 } = out_;
3259 }
3260
3261 ::fidl_next::Encode::encode(self.bytes, encoder_, bytes, ())?;
3262
3263 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bytes.as_mut_ptr()) };
3264
3265 Ok(())
3266 }
3267 }
3268
3269 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::VhtOperation, ___E> for &'a VhtOperation
3270 where
3271 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3272 {
3273 #[inline]
3274 fn encode(
3275 self,
3276 encoder_: &mut ___E,
3277 out_: &mut ::core::mem::MaybeUninit<crate::wire::VhtOperation>,
3278 _: (),
3279 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3280 ::fidl_next::munge! {
3281 let crate::wire::VhtOperation {
3282 bytes,
3283
3284 } = out_;
3285 }
3286
3287 ::fidl_next::Encode::encode(&self.bytes, encoder_, bytes, ())?;
3288
3289 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(bytes.as_mut_ptr()) };
3290
3291 Ok(())
3292 }
3293 }
3294
3295 unsafe impl<___E>
3296 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::VhtOperation>, ___E>
3297 for VhtOperation
3298 where
3299 ___E: ::fidl_next::Encoder + ?Sized,
3300 VhtOperation: ::fidl_next::Encode<crate::wire::VhtOperation, ___E>,
3301 {
3302 #[inline]
3303 fn encode_option(
3304 this: ::core::option::Option<Self>,
3305 encoder: &mut ___E,
3306 out: &mut ::core::mem::MaybeUninit<
3307 ::fidl_next::wire::Box<'static, crate::wire::VhtOperation>,
3308 >,
3309 _: (),
3310 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3311 if let Some(inner) = this {
3312 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3313 ::fidl_next::wire::Box::encode_present(out);
3314 } else {
3315 ::fidl_next::wire::Box::encode_absent(out);
3316 }
3317
3318 Ok(())
3319 }
3320 }
3321
3322 unsafe impl<'a, ___E>
3323 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::VhtOperation>, ___E>
3324 for &'a VhtOperation
3325 where
3326 ___E: ::fidl_next::Encoder + ?Sized,
3327 &'a VhtOperation: ::fidl_next::Encode<crate::wire::VhtOperation, ___E>,
3328 {
3329 #[inline]
3330 fn encode_option(
3331 this: ::core::option::Option<Self>,
3332 encoder: &mut ___E,
3333 out: &mut ::core::mem::MaybeUninit<
3334 ::fidl_next::wire::Box<'static, crate::wire::VhtOperation>,
3335 >,
3336 _: (),
3337 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3338 if let Some(inner) = this {
3339 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3340 ::fidl_next::wire::Box::encode_present(out);
3341 } else {
3342 ::fidl_next::wire::Box::encode_absent(out);
3343 }
3344
3345 Ok(())
3346 }
3347 }
3348
3349 impl ::fidl_next::FromWire<crate::wire::VhtOperation> for VhtOperation {
3350 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::VhtOperation, Self> = unsafe {
3351 ::fidl_next::CopyOptimization::enable_if(
3352 true && <[u8; 5] as ::fidl_next::FromWire<[u8; 5]>>::COPY_OPTIMIZATION.is_enabled(),
3353 )
3354 };
3355
3356 #[inline]
3357 fn from_wire(wire: crate::wire::VhtOperation) -> Self {
3358 Self { bytes: ::fidl_next::FromWire::from_wire(wire.bytes) }
3359 }
3360 }
3361
3362 impl ::fidl_next::FromWireRef<crate::wire::VhtOperation> for VhtOperation {
3363 #[inline]
3364 fn from_wire_ref(wire: &crate::wire::VhtOperation) -> Self {
3365 Self { bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.bytes) }
3366 }
3367 }
3368
3369 #[doc = " IEEE Std 802.11-2020 9.4.2.173\n"]
3370 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3371 #[repr(u32)]
3372 pub enum WlanAccessCategory {
3373 Background = 1,
3374 BestEffort = 2,
3375 Video = 3,
3376 Voice = 4,
3377 }
3378 impl ::core::convert::TryFrom<u32> for WlanAccessCategory {
3379 type Error = ::fidl_next::UnknownStrictEnumMemberError;
3380 fn try_from(
3381 value: u32,
3382 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
3383 match value {
3384 1 => Ok(Self::Background),
3385 2 => Ok(Self::BestEffort),
3386 3 => Ok(Self::Video),
3387 4 => Ok(Self::Voice),
3388
3389 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
3390 }
3391 }
3392 }
3393
3394 unsafe impl<___E> ::fidl_next::Encode<crate::wire::WlanAccessCategory, ___E> for WlanAccessCategory
3395 where
3396 ___E: ?Sized,
3397 {
3398 #[inline]
3399 fn encode(
3400 self,
3401 encoder: &mut ___E,
3402 out: &mut ::core::mem::MaybeUninit<crate::wire::WlanAccessCategory>,
3403 _: (),
3404 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3405 ::fidl_next::Encode::encode(&self, encoder, out, ())
3406 }
3407 }
3408
3409 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WlanAccessCategory, ___E>
3410 for &'a WlanAccessCategory
3411 where
3412 ___E: ?Sized,
3413 {
3414 #[inline]
3415 fn encode(
3416 self,
3417 encoder: &mut ___E,
3418 out: &mut ::core::mem::MaybeUninit<crate::wire::WlanAccessCategory>,
3419 _: (),
3420 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3421 ::fidl_next::munge!(let crate::wire::WlanAccessCategory { value } = out);
3422 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
3423 WlanAccessCategory::Background => 1,
3424
3425 WlanAccessCategory::BestEffort => 2,
3426
3427 WlanAccessCategory::Video => 3,
3428
3429 WlanAccessCategory::Voice => 4,
3430 }));
3431
3432 Ok(())
3433 }
3434 }
3435
3436 impl ::core::convert::From<crate::wire::WlanAccessCategory> for WlanAccessCategory {
3437 fn from(wire: crate::wire::WlanAccessCategory) -> Self {
3438 match u32::from(wire.value) {
3439 1 => Self::Background,
3440
3441 2 => Self::BestEffort,
3442
3443 3 => Self::Video,
3444
3445 4 => Self::Voice,
3446
3447 _ => unsafe { ::core::hint::unreachable_unchecked() },
3448 }
3449 }
3450 }
3451
3452 impl ::fidl_next::FromWire<crate::wire::WlanAccessCategory> for WlanAccessCategory {
3453 #[inline]
3454 fn from_wire(wire: crate::wire::WlanAccessCategory) -> Self {
3455 Self::from(wire)
3456 }
3457 }
3458
3459 impl ::fidl_next::FromWireRef<crate::wire::WlanAccessCategory> for WlanAccessCategory {
3460 #[inline]
3461 fn from_wire_ref(wire: &crate::wire::WlanAccessCategory) -> Self {
3462 Self::from(*wire)
3463 }
3464 }
3465
3466 #[doc = " Identifies a frequency band in metadata of various operations.\n\n Examples of this enum in use are labeling scan results or reporting\n a driver capabilities from various frequency bands.\n\n NOTE: This enum is similar to the Band ID field defined in\n IEEE Std 802.11-2016 9.4.1.46, but its values are not the same.\n\n TODO(https://fxbug.dev/376442944): Create a spec-compliant Band ID type\n and migrate the platform to use it.\n"]
3467 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3468 #[repr(u8)]
3469 pub enum WlanBand {
3470 TwoGhz = 0,
3471 FiveGhz = 1,
3472 UnknownOrdinal_(u8) = 2,
3473 }
3474 impl ::std::convert::From<u8> for WlanBand {
3475 fn from(value: u8) -> Self {
3476 match value {
3477 0 => Self::TwoGhz,
3478 1 => Self::FiveGhz,
3479
3480 _ => Self::UnknownOrdinal_(value),
3481 }
3482 }
3483 }
3484
3485 unsafe impl<___E> ::fidl_next::Encode<crate::wire::WlanBand, ___E> for WlanBand
3486 where
3487 ___E: ?Sized,
3488 {
3489 #[inline]
3490 fn encode(
3491 self,
3492 encoder: &mut ___E,
3493 out: &mut ::core::mem::MaybeUninit<crate::wire::WlanBand>,
3494 _: (),
3495 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3496 ::fidl_next::Encode::encode(&self, encoder, out, ())
3497 }
3498 }
3499
3500 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WlanBand, ___E> for &'a WlanBand
3501 where
3502 ___E: ?Sized,
3503 {
3504 #[inline]
3505 fn encode(
3506 self,
3507 encoder: &mut ___E,
3508 out: &mut ::core::mem::MaybeUninit<crate::wire::WlanBand>,
3509 _: (),
3510 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3511 ::fidl_next::munge!(let crate::wire::WlanBand { value } = out);
3512 let _ = value.write(u8::from(match *self {
3513 WlanBand::TwoGhz => 0,
3514
3515 WlanBand::FiveGhz => 1,
3516
3517 WlanBand::UnknownOrdinal_(value) => value,
3518 }));
3519
3520 Ok(())
3521 }
3522 }
3523
3524 impl ::core::convert::From<crate::wire::WlanBand> for WlanBand {
3525 fn from(wire: crate::wire::WlanBand) -> Self {
3526 match u8::from(wire.value) {
3527 0 => Self::TwoGhz,
3528
3529 1 => Self::FiveGhz,
3530
3531 value => Self::UnknownOrdinal_(value),
3532 }
3533 }
3534 }
3535
3536 impl ::fidl_next::FromWire<crate::wire::WlanBand> for WlanBand {
3537 #[inline]
3538 fn from_wire(wire: crate::wire::WlanBand) -> Self {
3539 Self::from(wire)
3540 }
3541 }
3542
3543 impl ::fidl_next::FromWireRef<crate::wire::WlanBand> for WlanBand {
3544 #[inline]
3545 fn from_wire_ref(wire: &crate::wire::WlanBand) -> Self {
3546 Self::from(*wire)
3547 }
3548 }
3549
3550 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3551 #[repr(u32)]
3552 pub enum WlanPhyType {
3553 Dsss = 1,
3554 Hr = 2,
3555 Ofdm = 3,
3556 Erp = 4,
3557 Ht = 5,
3558 Dmg = 6,
3559 Vht = 7,
3560 Tvht = 8,
3561 S1G = 9,
3562 Cdmg = 10,
3563 Cmmg = 11,
3564 He = 12,
3565 UnknownOrdinal_(u32) = 13,
3566 }
3567 impl ::std::convert::From<u32> for WlanPhyType {
3568 fn from(value: u32) -> Self {
3569 match value {
3570 1 => Self::Dsss,
3571 2 => Self::Hr,
3572 3 => Self::Ofdm,
3573 4 => Self::Erp,
3574 5 => Self::Ht,
3575 6 => Self::Dmg,
3576 7 => Self::Vht,
3577 8 => Self::Tvht,
3578 9 => Self::S1G,
3579 10 => Self::Cdmg,
3580 11 => Self::Cmmg,
3581 12 => Self::He,
3582
3583 _ => Self::UnknownOrdinal_(value),
3584 }
3585 }
3586 }
3587
3588 unsafe impl<___E> ::fidl_next::Encode<crate::wire::WlanPhyType, ___E> for WlanPhyType
3589 where
3590 ___E: ?Sized,
3591 {
3592 #[inline]
3593 fn encode(
3594 self,
3595 encoder: &mut ___E,
3596 out: &mut ::core::mem::MaybeUninit<crate::wire::WlanPhyType>,
3597 _: (),
3598 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3599 ::fidl_next::Encode::encode(&self, encoder, out, ())
3600 }
3601 }
3602
3603 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WlanPhyType, ___E> for &'a WlanPhyType
3604 where
3605 ___E: ?Sized,
3606 {
3607 #[inline]
3608 fn encode(
3609 self,
3610 encoder: &mut ___E,
3611 out: &mut ::core::mem::MaybeUninit<crate::wire::WlanPhyType>,
3612 _: (),
3613 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3614 ::fidl_next::munge!(let crate::wire::WlanPhyType { value } = out);
3615 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
3616 WlanPhyType::Dsss => 1,
3617
3618 WlanPhyType::Hr => 2,
3619
3620 WlanPhyType::Ofdm => 3,
3621
3622 WlanPhyType::Erp => 4,
3623
3624 WlanPhyType::Ht => 5,
3625
3626 WlanPhyType::Dmg => 6,
3627
3628 WlanPhyType::Vht => 7,
3629
3630 WlanPhyType::Tvht => 8,
3631
3632 WlanPhyType::S1G => 9,
3633
3634 WlanPhyType::Cdmg => 10,
3635
3636 WlanPhyType::Cmmg => 11,
3637
3638 WlanPhyType::He => 12,
3639
3640 WlanPhyType::UnknownOrdinal_(value) => value,
3641 }));
3642
3643 Ok(())
3644 }
3645 }
3646
3647 impl ::core::convert::From<crate::wire::WlanPhyType> for WlanPhyType {
3648 fn from(wire: crate::wire::WlanPhyType) -> Self {
3649 match u32::from(wire.value) {
3650 1 => Self::Dsss,
3651
3652 2 => Self::Hr,
3653
3654 3 => Self::Ofdm,
3655
3656 4 => Self::Erp,
3657
3658 5 => Self::Ht,
3659
3660 6 => Self::Dmg,
3661
3662 7 => Self::Vht,
3663
3664 8 => Self::Tvht,
3665
3666 9 => Self::S1G,
3667
3668 10 => Self::Cdmg,
3669
3670 11 => Self::Cmmg,
3671
3672 12 => Self::He,
3673
3674 value => Self::UnknownOrdinal_(value),
3675 }
3676 }
3677 }
3678
3679 impl ::fidl_next::FromWire<crate::wire::WlanPhyType> for WlanPhyType {
3680 #[inline]
3681 fn from_wire(wire: crate::wire::WlanPhyType) -> Self {
3682 Self::from(wire)
3683 }
3684 }
3685
3686 impl ::fidl_next::FromWireRef<crate::wire::WlanPhyType> for WlanPhyType {
3687 #[inline]
3688 fn from_wire_ref(wire: &crate::wire::WlanPhyType) -> Self {
3689 Self::from(*wire)
3690 }
3691 }
3692}
3693
3694pub mod wire {
3695
3696 pub type MacAddr = [u8; 6];
3698
3699 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
3701 #[repr(transparent)]
3702 pub struct BssType {
3703 pub(crate) value: ::fidl_next::wire::Uint32,
3704 }
3705
3706 impl ::fidl_next::Constrained for BssType {
3707 type Constraint = ();
3708
3709 fn validate(
3710 _: ::fidl_next::Slot<'_, Self>,
3711 _: Self::Constraint,
3712 ) -> Result<(), ::fidl_next::ValidationError> {
3713 Ok(())
3714 }
3715 }
3716
3717 unsafe impl ::fidl_next::Wire for BssType {
3718 type Narrowed<'de> = Self;
3719
3720 #[inline]
3721 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
3722 }
3724 }
3725
3726 impl BssType {
3727 pub const UNKNOWN: BssType = BssType { value: ::fidl_next::wire::Uint32(0) };
3728
3729 pub const INFRASTRUCTURE: BssType = BssType { value: ::fidl_next::wire::Uint32(1) };
3730
3731 pub const INDEPENDENT: BssType = BssType { value: ::fidl_next::wire::Uint32(2) };
3732
3733 pub const MESH: BssType = BssType { value: ::fidl_next::wire::Uint32(3) };
3734
3735 pub const PERSONAL: BssType = BssType { value: ::fidl_next::wire::Uint32(4) };
3736 }
3737
3738 unsafe impl<___D> ::fidl_next::Decode<___D> for BssType
3739 where
3740 ___D: ?Sized,
3741 {
3742 fn decode(
3743 slot: ::fidl_next::Slot<'_, Self>,
3744 _: &mut ___D,
3745 _: (),
3746 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3747 Ok(())
3748 }
3749 }
3750
3751 impl ::core::convert::From<crate::natural::BssType> for BssType {
3752 fn from(natural: crate::natural::BssType) -> Self {
3753 match natural {
3754 crate::natural::BssType::Unknown => BssType::UNKNOWN,
3755
3756 crate::natural::BssType::Infrastructure => BssType::INFRASTRUCTURE,
3757
3758 crate::natural::BssType::Independent => BssType::INDEPENDENT,
3759
3760 crate::natural::BssType::Mesh => BssType::MESH,
3761
3762 crate::natural::BssType::Personal => BssType::PERSONAL,
3763
3764 crate::natural::BssType::UnknownOrdinal_(value) => {
3765 BssType { value: ::fidl_next::wire::Uint32::from(value) }
3766 }
3767 }
3768 }
3769 }
3770
3771 impl ::fidl_next::IntoNatural for BssType {
3772 type Natural = crate::natural::BssType;
3773 }
3774
3775 pub type CapabilityInfo = ::fidl_next::wire::Uint16;
3777
3778 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
3780 #[repr(transparent)]
3781 pub struct ChannelBandwidth {
3782 pub(crate) value: ::fidl_next::wire::Uint32,
3783 }
3784
3785 impl ::fidl_next::Constrained for ChannelBandwidth {
3786 type Constraint = ();
3787
3788 fn validate(
3789 _: ::fidl_next::Slot<'_, Self>,
3790 _: Self::Constraint,
3791 ) -> Result<(), ::fidl_next::ValidationError> {
3792 Ok(())
3793 }
3794 }
3795
3796 unsafe impl ::fidl_next::Wire for ChannelBandwidth {
3797 type Narrowed<'de> = Self;
3798
3799 #[inline]
3800 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
3801 }
3803 }
3804
3805 impl ChannelBandwidth {
3806 pub const CBW20: ChannelBandwidth =
3807 ChannelBandwidth { value: ::fidl_next::wire::Uint32(1) };
3808
3809 pub const CBW40: ChannelBandwidth =
3810 ChannelBandwidth { value: ::fidl_next::wire::Uint32(2) };
3811
3812 pub const CBW40_BELOW: ChannelBandwidth =
3813 ChannelBandwidth { value: ::fidl_next::wire::Uint32(3) };
3814
3815 pub const CBW80: ChannelBandwidth =
3816 ChannelBandwidth { value: ::fidl_next::wire::Uint32(4) };
3817
3818 pub const CBW160: ChannelBandwidth =
3819 ChannelBandwidth { value: ::fidl_next::wire::Uint32(5) };
3820
3821 pub const CBW80_P80: ChannelBandwidth =
3822 ChannelBandwidth { value: ::fidl_next::wire::Uint32(6) };
3823 }
3824
3825 unsafe impl<___D> ::fidl_next::Decode<___D> for ChannelBandwidth
3826 where
3827 ___D: ?Sized,
3828 {
3829 fn decode(
3830 slot: ::fidl_next::Slot<'_, Self>,
3831 _: &mut ___D,
3832 _: (),
3833 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3834 Ok(())
3835 }
3836 }
3837
3838 impl ::core::convert::From<crate::natural::ChannelBandwidth> for ChannelBandwidth {
3839 fn from(natural: crate::natural::ChannelBandwidth) -> Self {
3840 match natural {
3841 crate::natural::ChannelBandwidth::Cbw20 => ChannelBandwidth::CBW20,
3842
3843 crate::natural::ChannelBandwidth::Cbw40 => ChannelBandwidth::CBW40,
3844
3845 crate::natural::ChannelBandwidth::Cbw40Below => ChannelBandwidth::CBW40_BELOW,
3846
3847 crate::natural::ChannelBandwidth::Cbw80 => ChannelBandwidth::CBW80,
3848
3849 crate::natural::ChannelBandwidth::Cbw160 => ChannelBandwidth::CBW160,
3850
3851 crate::natural::ChannelBandwidth::Cbw80P80 => ChannelBandwidth::CBW80_P80,
3852
3853 crate::natural::ChannelBandwidth::UnknownOrdinal_(value) => {
3854 ChannelBandwidth { value: ::fidl_next::wire::Uint32::from(value) }
3855 }
3856 }
3857 }
3858 }
3859
3860 impl ::fidl_next::IntoNatural for ChannelBandwidth {
3861 type Natural = crate::natural::ChannelBandwidth;
3862 }
3863
3864 #[derive(Clone, Debug)]
3866 #[repr(C)]
3867 pub struct WlanChannel {
3868 pub primary: u8,
3869
3870 pub cbw: crate::wire::ChannelBandwidth,
3871
3872 pub secondary80: u8,
3873 }
3874
3875 static_assertions::const_assert_eq!(std::mem::size_of::<WlanChannel>(), 12);
3876 static_assertions::const_assert_eq!(std::mem::align_of::<WlanChannel>(), 4);
3877
3878 static_assertions::const_assert_eq!(std::mem::offset_of!(WlanChannel, primary), 0);
3879
3880 static_assertions::const_assert_eq!(std::mem::offset_of!(WlanChannel, cbw), 4);
3881
3882 static_assertions::const_assert_eq!(std::mem::offset_of!(WlanChannel, secondary80), 8);
3883
3884 impl ::fidl_next::Constrained for WlanChannel {
3885 type Constraint = ();
3886
3887 fn validate(
3888 _: ::fidl_next::Slot<'_, Self>,
3889 _: Self::Constraint,
3890 ) -> Result<(), ::fidl_next::ValidationError> {
3891 Ok(())
3892 }
3893 }
3894
3895 unsafe impl ::fidl_next::Wire for WlanChannel {
3896 type Narrowed<'de> = WlanChannel;
3897
3898 #[inline]
3899 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3900 ::fidl_next::munge! {
3901 let Self {
3902 primary,
3903 cbw,
3904 secondary80,
3905
3906 } = &mut *out_;
3907 }
3908
3909 ::fidl_next::Wire::zero_padding(primary);
3910
3911 ::fidl_next::Wire::zero_padding(cbw);
3912
3913 ::fidl_next::Wire::zero_padding(secondary80);
3914
3915 unsafe {
3916 out_.as_mut_ptr().cast::<u8>().add(9).write_bytes(0, 3);
3917 }
3918
3919 unsafe {
3920 out_.as_mut_ptr().cast::<u8>().add(1).write_bytes(0, 3);
3921 }
3922 }
3923 }
3924
3925 unsafe impl<___D> ::fidl_next::Decode<___D> for WlanChannel
3926 where
3927 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3928 {
3929 fn decode(
3930 slot_: ::fidl_next::Slot<'_, Self>,
3931 decoder_: &mut ___D,
3932 _: (),
3933 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3934 if slot_.as_bytes()[9..12] != [0u8; 3] {
3935 return Err(::fidl_next::DecodeError::InvalidPadding);
3936 }
3937
3938 if slot_.as_bytes()[1..4] != [0u8; 3] {
3939 return Err(::fidl_next::DecodeError::InvalidPadding);
3940 }
3941
3942 ::fidl_next::munge! {
3943 let Self {
3944 mut primary,
3945 mut cbw,
3946 mut secondary80,
3947
3948 } = slot_;
3949 }
3950
3951 let _field = primary.as_mut();
3952
3953 ::fidl_next::Decode::decode(primary.as_mut(), decoder_, ())?;
3954
3955 let _field = cbw.as_mut();
3956
3957 ::fidl_next::Decode::decode(cbw.as_mut(), decoder_, ())?;
3958
3959 let _field = secondary80.as_mut();
3960
3961 ::fidl_next::Decode::decode(secondary80.as_mut(), decoder_, ())?;
3962
3963 Ok(())
3964 }
3965 }
3966
3967 impl ::fidl_next::IntoNatural for WlanChannel {
3968 type Natural = crate::natural::WlanChannel;
3969 }
3970
3971 #[derive(Debug)]
3973 #[repr(C)]
3974 pub struct BssDescription<'de> {
3975 pub bssid: [u8; 6],
3976
3977 pub bss_type: crate::wire::BssType,
3978
3979 pub beacon_period: ::fidl_next::wire::Uint16,
3980
3981 pub capability_info: ::fidl_next::wire::Uint16,
3982
3983 pub ies: ::fidl_next::wire::Vector<'de, u8>,
3984
3985 pub channel: crate::wire::WlanChannel,
3986
3987 pub rssi_dbm: i8,
3988
3989 pub snr_db: i8,
3990 }
3991
3992 static_assertions::const_assert_eq!(std::mem::size_of::<BssDescription<'_>>(), 48);
3993 static_assertions::const_assert_eq!(std::mem::align_of::<BssDescription<'_>>(), 8);
3994
3995 static_assertions::const_assert_eq!(std::mem::offset_of!(BssDescription<'_>, bssid), 0);
3996
3997 static_assertions::const_assert_eq!(std::mem::offset_of!(BssDescription<'_>, bss_type), 8);
3998
3999 static_assertions::const_assert_eq!(
4000 std::mem::offset_of!(BssDescription<'_>, beacon_period),
4001 12
4002 );
4003
4004 static_assertions::const_assert_eq!(
4005 std::mem::offset_of!(BssDescription<'_>, capability_info),
4006 14
4007 );
4008
4009 static_assertions::const_assert_eq!(std::mem::offset_of!(BssDescription<'_>, ies), 16);
4010
4011 static_assertions::const_assert_eq!(std::mem::offset_of!(BssDescription<'_>, channel), 32);
4012
4013 static_assertions::const_assert_eq!(std::mem::offset_of!(BssDescription<'_>, rssi_dbm), 44);
4014
4015 static_assertions::const_assert_eq!(std::mem::offset_of!(BssDescription<'_>, snr_db), 45);
4016
4017 impl ::fidl_next::Constrained for BssDescription<'_> {
4018 type Constraint = ();
4019
4020 fn validate(
4021 _: ::fidl_next::Slot<'_, Self>,
4022 _: Self::Constraint,
4023 ) -> Result<(), ::fidl_next::ValidationError> {
4024 Ok(())
4025 }
4026 }
4027
4028 unsafe impl ::fidl_next::Wire for BssDescription<'static> {
4029 type Narrowed<'de> = BssDescription<'de>;
4030
4031 #[inline]
4032 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4033 ::fidl_next::munge! {
4034 let Self {
4035 bssid,
4036 bss_type,
4037 beacon_period,
4038 capability_info,
4039 ies,
4040 channel,
4041 rssi_dbm,
4042 snr_db,
4043
4044 } = &mut *out_;
4045 }
4046
4047 ::fidl_next::Wire::zero_padding(bssid);
4048
4049 ::fidl_next::Wire::zero_padding(bss_type);
4050
4051 ::fidl_next::Wire::zero_padding(beacon_period);
4052
4053 ::fidl_next::Wire::zero_padding(capability_info);
4054
4055 ::fidl_next::Wire::zero_padding(ies);
4056
4057 ::fidl_next::Wire::zero_padding(channel);
4058
4059 ::fidl_next::Wire::zero_padding(rssi_dbm);
4060
4061 ::fidl_next::Wire::zero_padding(snr_db);
4062
4063 unsafe {
4064 out_.as_mut_ptr().cast::<u8>().add(46).write_bytes(0, 2);
4065 }
4066
4067 unsafe {
4068 out_.as_mut_ptr().cast::<u8>().add(6).write_bytes(0, 2);
4069 }
4070 }
4071 }
4072
4073 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for BssDescription<'de>
4074 where
4075 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4076 ___D: ::fidl_next::Decoder<'de>,
4077 {
4078 fn decode(
4079 slot_: ::fidl_next::Slot<'_, Self>,
4080 decoder_: &mut ___D,
4081 _: (),
4082 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4083 if slot_.as_bytes()[46..48] != [0u8; 2] {
4084 return Err(::fidl_next::DecodeError::InvalidPadding);
4085 }
4086
4087 if slot_.as_bytes()[6..8] != [0u8; 2] {
4088 return Err(::fidl_next::DecodeError::InvalidPadding);
4089 }
4090
4091 ::fidl_next::munge! {
4092 let Self {
4093 mut bssid,
4094 mut bss_type,
4095 mut beacon_period,
4096 mut capability_info,
4097 mut ies,
4098 mut channel,
4099 mut rssi_dbm,
4100 mut snr_db,
4101
4102 } = slot_;
4103 }
4104
4105 let _field = bssid.as_mut();
4106
4107 ::fidl_next::Decode::decode(bssid.as_mut(), decoder_, ())?;
4108
4109 let _field = bss_type.as_mut();
4110
4111 ::fidl_next::Decode::decode(bss_type.as_mut(), decoder_, ())?;
4112
4113 let _field = beacon_period.as_mut();
4114
4115 ::fidl_next::Decode::decode(beacon_period.as_mut(), decoder_, ())?;
4116
4117 let _field = capability_info.as_mut();
4118
4119 ::fidl_next::Decode::decode(capability_info.as_mut(), decoder_, ())?;
4120
4121 let _field = ies.as_mut();
4122 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
4123 ::fidl_next::Decode::decode(ies.as_mut(), decoder_, (4294967295, ()))?;
4124
4125 let _field = channel.as_mut();
4126
4127 ::fidl_next::Decode::decode(channel.as_mut(), decoder_, ())?;
4128
4129 let _field = rssi_dbm.as_mut();
4130
4131 ::fidl_next::Decode::decode(rssi_dbm.as_mut(), decoder_, ())?;
4132
4133 let _field = snr_db.as_mut();
4134
4135 ::fidl_next::Decode::decode(snr_db.as_mut(), decoder_, ())?;
4136
4137 Ok(())
4138 }
4139 }
4140
4141 impl<'de> ::fidl_next::IntoNatural for BssDescription<'de> {
4142 type Natural = crate::natural::BssDescription;
4143 }
4144
4145 #[derive(Clone, Debug)]
4147 #[repr(C)]
4148 pub struct CSsid {
4149 pub len: u8,
4150
4151 pub data: [u8; 32],
4152 }
4153
4154 static_assertions::const_assert_eq!(std::mem::size_of::<CSsid>(), 33);
4155 static_assertions::const_assert_eq!(std::mem::align_of::<CSsid>(), 1);
4156
4157 static_assertions::const_assert_eq!(std::mem::offset_of!(CSsid, len), 0);
4158
4159 static_assertions::const_assert_eq!(std::mem::offset_of!(CSsid, data), 1);
4160
4161 impl ::fidl_next::Constrained for CSsid {
4162 type Constraint = ();
4163
4164 fn validate(
4165 _: ::fidl_next::Slot<'_, Self>,
4166 _: Self::Constraint,
4167 ) -> Result<(), ::fidl_next::ValidationError> {
4168 Ok(())
4169 }
4170 }
4171
4172 unsafe impl ::fidl_next::Wire for CSsid {
4173 type Narrowed<'de> = CSsid;
4174
4175 #[inline]
4176 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4177 ::fidl_next::munge! {
4178 let Self {
4179 len,
4180 data,
4181
4182 } = &mut *out_;
4183 }
4184
4185 ::fidl_next::Wire::zero_padding(len);
4186
4187 ::fidl_next::Wire::zero_padding(data);
4188 }
4189 }
4190
4191 unsafe impl<___D> ::fidl_next::Decode<___D> for CSsid
4192 where
4193 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4194 {
4195 fn decode(
4196 slot_: ::fidl_next::Slot<'_, Self>,
4197 decoder_: &mut ___D,
4198 _: (),
4199 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4200 ::fidl_next::munge! {
4201 let Self {
4202 mut len,
4203 mut data,
4204
4205 } = slot_;
4206 }
4207
4208 let _field = len.as_mut();
4209
4210 ::fidl_next::Decode::decode(len.as_mut(), decoder_, ())?;
4211
4212 let _field = data.as_mut();
4213
4214 ::fidl_next::Decode::decode(data.as_mut(), decoder_, ())?;
4215
4216 Ok(())
4217 }
4218 }
4219
4220 impl ::fidl_next::IntoNatural for CSsid {
4221 type Natural = crate::natural::CSsid;
4222 }
4223
4224 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
4226 #[repr(transparent)]
4227 pub struct CipherSuiteType {
4228 pub(crate) value: ::fidl_next::wire::Uint32,
4229 }
4230
4231 impl ::fidl_next::Constrained for CipherSuiteType {
4232 type Constraint = ();
4233
4234 fn validate(
4235 _: ::fidl_next::Slot<'_, Self>,
4236 _: Self::Constraint,
4237 ) -> Result<(), ::fidl_next::ValidationError> {
4238 Ok(())
4239 }
4240 }
4241
4242 unsafe impl ::fidl_next::Wire for CipherSuiteType {
4243 type Narrowed<'de> = Self;
4244
4245 #[inline]
4246 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
4247 }
4249 }
4250
4251 impl CipherSuiteType {
4252 pub const USE_GROUP: CipherSuiteType =
4253 CipherSuiteType { value: ::fidl_next::wire::Uint32(0) };
4254
4255 pub const WEP_40: CipherSuiteType = CipherSuiteType { value: ::fidl_next::wire::Uint32(1) };
4256
4257 pub const TKIP: CipherSuiteType = CipherSuiteType { value: ::fidl_next::wire::Uint32(2) };
4258
4259 pub const RESERVED_3: CipherSuiteType =
4260 CipherSuiteType { value: ::fidl_next::wire::Uint32(3) };
4261
4262 pub const CCMP_128: CipherSuiteType =
4263 CipherSuiteType { value: ::fidl_next::wire::Uint32(4) };
4264
4265 pub const WEP_104: CipherSuiteType =
4266 CipherSuiteType { value: ::fidl_next::wire::Uint32(5) };
4267
4268 pub const BIP_CMAC_128: CipherSuiteType =
4269 CipherSuiteType { value: ::fidl_next::wire::Uint32(6) };
4270
4271 pub const GROUP_ADDRESSED_NOT_ALLOWED: CipherSuiteType =
4272 CipherSuiteType { value: ::fidl_next::wire::Uint32(7) };
4273
4274 pub const GCMP_128: CipherSuiteType =
4275 CipherSuiteType { value: ::fidl_next::wire::Uint32(8) };
4276
4277 pub const GCMP_256: CipherSuiteType =
4278 CipherSuiteType { value: ::fidl_next::wire::Uint32(9) };
4279
4280 pub const CCMP_256: CipherSuiteType =
4281 CipherSuiteType { value: ::fidl_next::wire::Uint32(10) };
4282
4283 pub const BIP_GMAC_128: CipherSuiteType =
4284 CipherSuiteType { value: ::fidl_next::wire::Uint32(11) };
4285
4286 pub const BIP_GMAC_256: CipherSuiteType =
4287 CipherSuiteType { value: ::fidl_next::wire::Uint32(12) };
4288
4289 pub const BIP_CMAC_256: CipherSuiteType =
4290 CipherSuiteType { value: ::fidl_next::wire::Uint32(13) };
4291
4292 pub const RESERVED_14_TO_255: CipherSuiteType =
4293 CipherSuiteType { value: ::fidl_next::wire::Uint32(14) };
4294 }
4295
4296 unsafe impl<___D> ::fidl_next::Decode<___D> for CipherSuiteType
4297 where
4298 ___D: ?Sized,
4299 {
4300 fn decode(
4301 slot: ::fidl_next::Slot<'_, Self>,
4302 _: &mut ___D,
4303 _: (),
4304 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4305 Ok(())
4306 }
4307 }
4308
4309 impl ::core::convert::From<crate::natural::CipherSuiteType> for CipherSuiteType {
4310 fn from(natural: crate::natural::CipherSuiteType) -> Self {
4311 match natural {
4312 crate::natural::CipherSuiteType::UseGroup => CipherSuiteType::USE_GROUP,
4313
4314 crate::natural::CipherSuiteType::Wep40 => CipherSuiteType::WEP_40,
4315
4316 crate::natural::CipherSuiteType::Tkip => CipherSuiteType::TKIP,
4317
4318 crate::natural::CipherSuiteType::Reserved3 => CipherSuiteType::RESERVED_3,
4319
4320 crate::natural::CipherSuiteType::Ccmp128 => CipherSuiteType::CCMP_128,
4321
4322 crate::natural::CipherSuiteType::Wep104 => CipherSuiteType::WEP_104,
4323
4324 crate::natural::CipherSuiteType::BipCmac128 => CipherSuiteType::BIP_CMAC_128,
4325
4326 crate::natural::CipherSuiteType::GroupAddressedNotAllowed => {
4327 CipherSuiteType::GROUP_ADDRESSED_NOT_ALLOWED
4328 }
4329
4330 crate::natural::CipherSuiteType::Gcmp128 => CipherSuiteType::GCMP_128,
4331
4332 crate::natural::CipherSuiteType::Gcmp256 => CipherSuiteType::GCMP_256,
4333
4334 crate::natural::CipherSuiteType::Ccmp256 => CipherSuiteType::CCMP_256,
4335
4336 crate::natural::CipherSuiteType::BipGmac128 => CipherSuiteType::BIP_GMAC_128,
4337
4338 crate::natural::CipherSuiteType::BipGmac256 => CipherSuiteType::BIP_GMAC_256,
4339
4340 crate::natural::CipherSuiteType::BipCmac256 => CipherSuiteType::BIP_CMAC_256,
4341
4342 crate::natural::CipherSuiteType::Reserved14To255 => {
4343 CipherSuiteType::RESERVED_14_TO_255
4344 }
4345
4346 crate::natural::CipherSuiteType::UnknownOrdinal_(value) => {
4347 CipherSuiteType { value: ::fidl_next::wire::Uint32::from(value) }
4348 }
4349 }
4350 }
4351 }
4352
4353 impl ::fidl_next::IntoNatural for CipherSuiteType {
4354 type Natural = crate::natural::CipherSuiteType;
4355 }
4356
4357 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
4359 #[repr(transparent)]
4360 pub struct GuardInterval {
4361 pub(crate) value: u8,
4362 }
4363
4364 impl ::fidl_next::Constrained for GuardInterval {
4365 type Constraint = ();
4366
4367 fn validate(
4368 _: ::fidl_next::Slot<'_, Self>,
4369 _: Self::Constraint,
4370 ) -> Result<(), ::fidl_next::ValidationError> {
4371 Ok(())
4372 }
4373 }
4374
4375 unsafe impl ::fidl_next::Wire for GuardInterval {
4376 type Narrowed<'de> = Self;
4377
4378 #[inline]
4379 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
4380 }
4382 }
4383
4384 impl GuardInterval {
4385 pub const LONG_GI: GuardInterval = GuardInterval { value: 1 };
4386
4387 pub const SHORT_GI: GuardInterval = GuardInterval { value: 2 };
4388 }
4389
4390 unsafe impl<___D> ::fidl_next::Decode<___D> for GuardInterval
4391 where
4392 ___D: ?Sized,
4393 {
4394 fn decode(
4395 slot: ::fidl_next::Slot<'_, Self>,
4396 _: &mut ___D,
4397 _: (),
4398 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4399 ::fidl_next::munge!(let Self { value } = slot);
4400
4401 match u8::from(*value) {
4402 1 | 2 => (),
4403 unknown => {
4404 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
4405 }
4406 }
4407
4408 Ok(())
4409 }
4410 }
4411
4412 impl ::core::convert::From<crate::natural::GuardInterval> for GuardInterval {
4413 fn from(natural: crate::natural::GuardInterval) -> Self {
4414 match natural {
4415 crate::natural::GuardInterval::LongGi => GuardInterval::LONG_GI,
4416
4417 crate::natural::GuardInterval::ShortGi => GuardInterval::SHORT_GI,
4418 }
4419 }
4420 }
4421
4422 impl ::fidl_next::IntoNatural for GuardInterval {
4423 type Natural = crate::natural::GuardInterval;
4424 }
4425
4426 #[derive(Clone, Debug)]
4428 #[repr(C)]
4429 pub struct HtCapabilities {
4430 pub bytes: [u8; 26],
4431 }
4432
4433 static_assertions::const_assert_eq!(std::mem::size_of::<HtCapabilities>(), 26);
4434 static_assertions::const_assert_eq!(std::mem::align_of::<HtCapabilities>(), 1);
4435
4436 static_assertions::const_assert_eq!(std::mem::offset_of!(HtCapabilities, bytes), 0);
4437
4438 impl ::fidl_next::Constrained for HtCapabilities {
4439 type Constraint = ();
4440
4441 fn validate(
4442 _: ::fidl_next::Slot<'_, Self>,
4443 _: Self::Constraint,
4444 ) -> Result<(), ::fidl_next::ValidationError> {
4445 Ok(())
4446 }
4447 }
4448
4449 unsafe impl ::fidl_next::Wire for HtCapabilities {
4450 type Narrowed<'de> = HtCapabilities;
4451
4452 #[inline]
4453 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4454 ::fidl_next::munge! {
4455 let Self {
4456 bytes,
4457
4458 } = &mut *out_;
4459 }
4460
4461 ::fidl_next::Wire::zero_padding(bytes);
4462 }
4463 }
4464
4465 unsafe impl<___D> ::fidl_next::Decode<___D> for HtCapabilities
4466 where
4467 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4468 {
4469 fn decode(
4470 slot_: ::fidl_next::Slot<'_, Self>,
4471 decoder_: &mut ___D,
4472 _: (),
4473 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4474 ::fidl_next::munge! {
4475 let Self {
4476 mut bytes,
4477
4478 } = slot_;
4479 }
4480
4481 let _field = bytes.as_mut();
4482
4483 ::fidl_next::Decode::decode(bytes.as_mut(), decoder_, ())?;
4484
4485 Ok(())
4486 }
4487 }
4488
4489 impl ::fidl_next::IntoNatural for HtCapabilities {
4490 type Natural = crate::natural::HtCapabilities;
4491 }
4492
4493 #[derive(Clone, Debug)]
4495 #[repr(C)]
4496 pub struct HtOperation {
4497 pub bytes: [u8; 22],
4498 }
4499
4500 static_assertions::const_assert_eq!(std::mem::size_of::<HtOperation>(), 22);
4501 static_assertions::const_assert_eq!(std::mem::align_of::<HtOperation>(), 1);
4502
4503 static_assertions::const_assert_eq!(std::mem::offset_of!(HtOperation, bytes), 0);
4504
4505 impl ::fidl_next::Constrained for HtOperation {
4506 type Constraint = ();
4507
4508 fn validate(
4509 _: ::fidl_next::Slot<'_, Self>,
4510 _: Self::Constraint,
4511 ) -> Result<(), ::fidl_next::ValidationError> {
4512 Ok(())
4513 }
4514 }
4515
4516 unsafe impl ::fidl_next::Wire for HtOperation {
4517 type Narrowed<'de> = HtOperation;
4518
4519 #[inline]
4520 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4521 ::fidl_next::munge! {
4522 let Self {
4523 bytes,
4524
4525 } = &mut *out_;
4526 }
4527
4528 ::fidl_next::Wire::zero_padding(bytes);
4529 }
4530 }
4531
4532 unsafe impl<___D> ::fidl_next::Decode<___D> for HtOperation
4533 where
4534 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4535 {
4536 fn decode(
4537 slot_: ::fidl_next::Slot<'_, Self>,
4538 decoder_: &mut ___D,
4539 _: (),
4540 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4541 ::fidl_next::munge! {
4542 let Self {
4543 mut bytes,
4544
4545 } = slot_;
4546 }
4547
4548 let _field = bytes.as_mut();
4549
4550 ::fidl_next::Decode::decode(bytes.as_mut(), decoder_, ())?;
4551
4552 Ok(())
4553 }
4554 }
4555
4556 impl ::fidl_next::IntoNatural for HtOperation {
4557 type Natural = crate::natural::HtOperation;
4558 }
4559
4560 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
4562 #[repr(transparent)]
4563 pub struct KeyType {
4564 pub(crate) value: u8,
4565 }
4566
4567 impl ::fidl_next::Constrained for KeyType {
4568 type Constraint = ();
4569
4570 fn validate(
4571 _: ::fidl_next::Slot<'_, Self>,
4572 _: Self::Constraint,
4573 ) -> Result<(), ::fidl_next::ValidationError> {
4574 Ok(())
4575 }
4576 }
4577
4578 unsafe impl ::fidl_next::Wire for KeyType {
4579 type Narrowed<'de> = Self;
4580
4581 #[inline]
4582 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
4583 }
4585 }
4586
4587 impl KeyType {
4588 pub const PAIRWISE: KeyType = KeyType { value: 1 };
4589
4590 pub const GROUP: KeyType = KeyType { value: 2 };
4591
4592 pub const IGTK: KeyType = KeyType { value: 3 };
4593
4594 pub const PEER: KeyType = KeyType { value: 4 };
4595 }
4596
4597 unsafe impl<___D> ::fidl_next::Decode<___D> for KeyType
4598 where
4599 ___D: ?Sized,
4600 {
4601 fn decode(
4602 slot: ::fidl_next::Slot<'_, Self>,
4603 _: &mut ___D,
4604 _: (),
4605 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4606 Ok(())
4607 }
4608 }
4609
4610 impl ::core::convert::From<crate::natural::KeyType> for KeyType {
4611 fn from(natural: crate::natural::KeyType) -> Self {
4612 match natural {
4613 crate::natural::KeyType::Pairwise => KeyType::PAIRWISE,
4614
4615 crate::natural::KeyType::Group => KeyType::GROUP,
4616
4617 crate::natural::KeyType::Igtk => KeyType::IGTK,
4618
4619 crate::natural::KeyType::Peer => KeyType::PEER,
4620
4621 crate::natural::KeyType::UnknownOrdinal_(value) => {
4622 KeyType { value: u8::from(value) }
4623 }
4624 }
4625 }
4626 }
4627
4628 impl ::fidl_next::IntoNatural for KeyType {
4629 type Natural = crate::natural::KeyType;
4630 }
4631
4632 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
4634 #[repr(transparent)]
4635 pub struct ReasonCode {
4636 pub(crate) value: ::fidl_next::wire::Uint16,
4637 }
4638
4639 impl ::fidl_next::Constrained for ReasonCode {
4640 type Constraint = ();
4641
4642 fn validate(
4643 _: ::fidl_next::Slot<'_, Self>,
4644 _: Self::Constraint,
4645 ) -> Result<(), ::fidl_next::ValidationError> {
4646 Ok(())
4647 }
4648 }
4649
4650 unsafe impl ::fidl_next::Wire for ReasonCode {
4651 type Narrowed<'de> = Self;
4652
4653 #[inline]
4654 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
4655 }
4657 }
4658
4659 impl ReasonCode {
4660 pub const UNSPECIFIED_REASON: ReasonCode =
4661 ReasonCode { value: ::fidl_next::wire::Uint16(1) };
4662
4663 pub const INVALID_AUTHENTICATION: ReasonCode =
4664 ReasonCode { value: ::fidl_next::wire::Uint16(2) };
4665
4666 pub const LEAVING_NETWORK_DEAUTH: ReasonCode =
4667 ReasonCode { value: ::fidl_next::wire::Uint16(3) };
4668
4669 pub const REASON_INACTIVITY: ReasonCode =
4670 ReasonCode { value: ::fidl_next::wire::Uint16(4) };
4671
4672 pub const NO_MORE_STAS: ReasonCode = ReasonCode { value: ::fidl_next::wire::Uint16(5) };
4673
4674 pub const INVALID_CLASS2_FRAME: ReasonCode =
4675 ReasonCode { value: ::fidl_next::wire::Uint16(6) };
4676
4677 pub const INVALID_CLASS3_FRAME: ReasonCode =
4678 ReasonCode { value: ::fidl_next::wire::Uint16(7) };
4679
4680 pub const LEAVING_NETWORK_DISASSOC: ReasonCode =
4681 ReasonCode { value: ::fidl_next::wire::Uint16(8) };
4682
4683 pub const NOT_AUTHENTICATED: ReasonCode =
4684 ReasonCode { value: ::fidl_next::wire::Uint16(9) };
4685
4686 pub const UNACCEPTABLE_POWER_CAPABILITY: ReasonCode =
4687 ReasonCode { value: ::fidl_next::wire::Uint16(10) };
4688
4689 pub const UNACCEPTABLE_SUPPORTED_CHANNELS: ReasonCode =
4690 ReasonCode { value: ::fidl_next::wire::Uint16(11) };
4691
4692 pub const BSS_TRANSITION_DISASSOC: ReasonCode =
4693 ReasonCode { value: ::fidl_next::wire::Uint16(12) };
4694
4695 pub const REASON_INVALID_ELEMENT: ReasonCode =
4696 ReasonCode { value: ::fidl_next::wire::Uint16(13) };
4697
4698 pub const MIC_FAILURE: ReasonCode = ReasonCode { value: ::fidl_next::wire::Uint16(14) };
4699
4700 pub const FOURWAY_HANDSHAKE_TIMEOUT: ReasonCode =
4701 ReasonCode { value: ::fidl_next::wire::Uint16(15) };
4702
4703 pub const GK_HANDSHAKE_TIMEOUT: ReasonCode =
4704 ReasonCode { value: ::fidl_next::wire::Uint16(16) };
4705
4706 pub const HANDSHAKE_ELEMENT_MISMATCH: ReasonCode =
4707 ReasonCode { value: ::fidl_next::wire::Uint16(17) };
4708
4709 pub const REASON_INVALID_GROUP_CIPHER: ReasonCode =
4710 ReasonCode { value: ::fidl_next::wire::Uint16(18) };
4711
4712 pub const REASON_INVALID_PAIRWISE_CIPHER: ReasonCode =
4713 ReasonCode { value: ::fidl_next::wire::Uint16(19) };
4714
4715 pub const REASON_INVALID_AKMP: ReasonCode =
4716 ReasonCode { value: ::fidl_next::wire::Uint16(20) };
4717
4718 pub const UNSUPPORTED_RSNE_VERSION: ReasonCode =
4719 ReasonCode { value: ::fidl_next::wire::Uint16(21) };
4720
4721 pub const INVALID_RSNE_CAPABILITIES: ReasonCode =
4722 ReasonCode { value: ::fidl_next::wire::Uint16(22) };
4723
4724 pub const IEEE802_1_X_AUTH_FAILED: ReasonCode =
4725 ReasonCode { value: ::fidl_next::wire::Uint16(23) };
4726
4727 pub const REASON_CIPHER_OUT_OF_POLICY: ReasonCode =
4728 ReasonCode { value: ::fidl_next::wire::Uint16(24) };
4729
4730 pub const TDLS_PEER_UNREACHABLE: ReasonCode =
4731 ReasonCode { value: ::fidl_next::wire::Uint16(25) };
4732
4733 pub const TDLS_UNSPECIFIED_REASON: ReasonCode =
4734 ReasonCode { value: ::fidl_next::wire::Uint16(26) };
4735
4736 pub const SSP_REQUESTED_DISASSOC: ReasonCode =
4737 ReasonCode { value: ::fidl_next::wire::Uint16(27) };
4738
4739 pub const NO_SSP_ROAMING_AGREEMENT: ReasonCode =
4740 ReasonCode { value: ::fidl_next::wire::Uint16(28) };
4741
4742 pub const BAD_CIPHER_OR_AKM: ReasonCode =
4743 ReasonCode { value: ::fidl_next::wire::Uint16(29) };
4744
4745 pub const NOT_AUTHORIZED_THIS_LOCATION: ReasonCode =
4746 ReasonCode { value: ::fidl_next::wire::Uint16(30) };
4747
4748 pub const SERVICE_CHANGE_PRECLUDES_TS: ReasonCode =
4749 ReasonCode { value: ::fidl_next::wire::Uint16(31) };
4750
4751 pub const UNSPECIFIED_QOS_REASON: ReasonCode =
4752 ReasonCode { value: ::fidl_next::wire::Uint16(32) };
4753
4754 pub const NOT_ENOUGH_BANDWIDTH: ReasonCode =
4755 ReasonCode { value: ::fidl_next::wire::Uint16(33) };
4756
4757 pub const MISSING_ACKS: ReasonCode = ReasonCode { value: ::fidl_next::wire::Uint16(34) };
4758
4759 pub const EXCEEDED_TXOP: ReasonCode = ReasonCode { value: ::fidl_next::wire::Uint16(35) };
4760
4761 pub const STA_LEAVING: ReasonCode = ReasonCode { value: ::fidl_next::wire::Uint16(36) };
4762
4763 pub const END_TS_BA_DLS: ReasonCode = ReasonCode { value: ::fidl_next::wire::Uint16(37) };
4764
4765 pub const UNKNOWN_TS_BA: ReasonCode = ReasonCode { value: ::fidl_next::wire::Uint16(38) };
4766
4767 pub const TIMEOUT: ReasonCode = ReasonCode { value: ::fidl_next::wire::Uint16(39) };
4768
4769 pub const PEERKEY_MISMATCH: ReasonCode =
4770 ReasonCode { value: ::fidl_next::wire::Uint16(45) };
4771
4772 pub const PEER_INITIATED: ReasonCode = ReasonCode { value: ::fidl_next::wire::Uint16(46) };
4773
4774 pub const AP_INITIATED: ReasonCode = ReasonCode { value: ::fidl_next::wire::Uint16(47) };
4775
4776 pub const REASON_INVALID_FT_ACTION_FRAME_COUNT: ReasonCode =
4777 ReasonCode { value: ::fidl_next::wire::Uint16(48) };
4778
4779 pub const REASON_INVALID_PMKID: ReasonCode =
4780 ReasonCode { value: ::fidl_next::wire::Uint16(49) };
4781
4782 pub const REASON_INVALID_MDE: ReasonCode =
4783 ReasonCode { value: ::fidl_next::wire::Uint16(50) };
4784
4785 pub const REASON_INVALID_FTE: ReasonCode =
4786 ReasonCode { value: ::fidl_next::wire::Uint16(51) };
4787
4788 pub const MESH_PEERING_CANCELED: ReasonCode =
4789 ReasonCode { value: ::fidl_next::wire::Uint16(52) };
4790
4791 pub const MESH_MAX_PEERS: ReasonCode = ReasonCode { value: ::fidl_next::wire::Uint16(53) };
4792
4793 pub const MESH_CONFIGURATION_POLICY_VIOLATION: ReasonCode =
4794 ReasonCode { value: ::fidl_next::wire::Uint16(54) };
4795
4796 pub const MESH_CLOSE_RCVD: ReasonCode = ReasonCode { value: ::fidl_next::wire::Uint16(55) };
4797
4798 pub const MESH_MAX_RETRIES: ReasonCode =
4799 ReasonCode { value: ::fidl_next::wire::Uint16(56) };
4800
4801 pub const MESH_CONFIRM_TIMEOUT: ReasonCode =
4802 ReasonCode { value: ::fidl_next::wire::Uint16(57) };
4803
4804 pub const MESH_INVALID_GTK: ReasonCode =
4805 ReasonCode { value: ::fidl_next::wire::Uint16(58) };
4806
4807 pub const MESH_INCONSISTENT_PARAMETERS: ReasonCode =
4808 ReasonCode { value: ::fidl_next::wire::Uint16(59) };
4809
4810 pub const MESH_INVALID_SECURITY_CAPABILITY: ReasonCode =
4811 ReasonCode { value: ::fidl_next::wire::Uint16(60) };
4812
4813 pub const MESH_PATH_ERROR_NO_PROXY_INFORMATION: ReasonCode =
4814 ReasonCode { value: ::fidl_next::wire::Uint16(61) };
4815
4816 pub const MESH_PATH_ERROR_NO_FORWARDING_INFORMATION: ReasonCode =
4817 ReasonCode { value: ::fidl_next::wire::Uint16(62) };
4818
4819 pub const MESH_PATH_ERROR_DESTINATION_UNREACHABLE: ReasonCode =
4820 ReasonCode { value: ::fidl_next::wire::Uint16(63) };
4821
4822 pub const MAC_ADDRESS_ALREADY_EXISTS_IN_MBSS: ReasonCode =
4823 ReasonCode { value: ::fidl_next::wire::Uint16(64) };
4824
4825 pub const MESH_CHANNEL_SWITCH_REGULATORY_REQUIREMENTS: ReasonCode =
4826 ReasonCode { value: ::fidl_next::wire::Uint16(65) };
4827
4828 pub const MESH_CHANNEL_SWITCH_UNSPECIFIED: ReasonCode =
4829 ReasonCode { value: ::fidl_next::wire::Uint16(66) };
4830
4831 pub const MLME_LINK_FAILED: ReasonCode =
4832 ReasonCode { value: ::fidl_next::wire::Uint16(128) };
4833
4834 pub const FW_RX_STALLED: ReasonCode = ReasonCode { value: ::fidl_next::wire::Uint16(129) };
4835
4836 pub const FW_HIGH_WME_RX_ERR_RATE: ReasonCode =
4837 ReasonCode { value: ::fidl_next::wire::Uint16(130) };
4838 }
4839
4840 unsafe impl<___D> ::fidl_next::Decode<___D> for ReasonCode
4841 where
4842 ___D: ?Sized,
4843 {
4844 fn decode(
4845 slot: ::fidl_next::Slot<'_, Self>,
4846 _: &mut ___D,
4847 _: (),
4848 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4849 Ok(())
4850 }
4851 }
4852
4853 impl ::core::convert::From<crate::natural::ReasonCode> for ReasonCode {
4854 fn from(natural: crate::natural::ReasonCode) -> Self {
4855 match natural {
4856 crate::natural::ReasonCode::UnspecifiedReason => ReasonCode::UNSPECIFIED_REASON,
4857
4858 crate::natural::ReasonCode::InvalidAuthentication => {
4859 ReasonCode::INVALID_AUTHENTICATION
4860 }
4861
4862 crate::natural::ReasonCode::LeavingNetworkDeauth => {
4863 ReasonCode::LEAVING_NETWORK_DEAUTH
4864 }
4865
4866 crate::natural::ReasonCode::ReasonInactivity => ReasonCode::REASON_INACTIVITY,
4867
4868 crate::natural::ReasonCode::NoMoreStas => ReasonCode::NO_MORE_STAS,
4869
4870 crate::natural::ReasonCode::InvalidClass2Frame => ReasonCode::INVALID_CLASS2_FRAME,
4871
4872 crate::natural::ReasonCode::InvalidClass3Frame => ReasonCode::INVALID_CLASS3_FRAME,
4873
4874 crate::natural::ReasonCode::LeavingNetworkDisassoc => {
4875 ReasonCode::LEAVING_NETWORK_DISASSOC
4876 }
4877
4878 crate::natural::ReasonCode::NotAuthenticated => ReasonCode::NOT_AUTHENTICATED,
4879
4880 crate::natural::ReasonCode::UnacceptablePowerCapability => {
4881 ReasonCode::UNACCEPTABLE_POWER_CAPABILITY
4882 }
4883
4884 crate::natural::ReasonCode::UnacceptableSupportedChannels => {
4885 ReasonCode::UNACCEPTABLE_SUPPORTED_CHANNELS
4886 }
4887
4888 crate::natural::ReasonCode::BssTransitionDisassoc => {
4889 ReasonCode::BSS_TRANSITION_DISASSOC
4890 }
4891
4892 crate::natural::ReasonCode::ReasonInvalidElement => {
4893 ReasonCode::REASON_INVALID_ELEMENT
4894 }
4895
4896 crate::natural::ReasonCode::MicFailure => ReasonCode::MIC_FAILURE,
4897
4898 crate::natural::ReasonCode::FourwayHandshakeTimeout => {
4899 ReasonCode::FOURWAY_HANDSHAKE_TIMEOUT
4900 }
4901
4902 crate::natural::ReasonCode::GkHandshakeTimeout => ReasonCode::GK_HANDSHAKE_TIMEOUT,
4903
4904 crate::natural::ReasonCode::HandshakeElementMismatch => {
4905 ReasonCode::HANDSHAKE_ELEMENT_MISMATCH
4906 }
4907
4908 crate::natural::ReasonCode::ReasonInvalidGroupCipher => {
4909 ReasonCode::REASON_INVALID_GROUP_CIPHER
4910 }
4911
4912 crate::natural::ReasonCode::ReasonInvalidPairwiseCipher => {
4913 ReasonCode::REASON_INVALID_PAIRWISE_CIPHER
4914 }
4915
4916 crate::natural::ReasonCode::ReasonInvalidAkmp => ReasonCode::REASON_INVALID_AKMP,
4917
4918 crate::natural::ReasonCode::UnsupportedRsneVersion => {
4919 ReasonCode::UNSUPPORTED_RSNE_VERSION
4920 }
4921
4922 crate::natural::ReasonCode::InvalidRsneCapabilities => {
4923 ReasonCode::INVALID_RSNE_CAPABILITIES
4924 }
4925
4926 crate::natural::ReasonCode::Ieee8021XAuthFailed => {
4927 ReasonCode::IEEE802_1_X_AUTH_FAILED
4928 }
4929
4930 crate::natural::ReasonCode::ReasonCipherOutOfPolicy => {
4931 ReasonCode::REASON_CIPHER_OUT_OF_POLICY
4932 }
4933
4934 crate::natural::ReasonCode::TdlsPeerUnreachable => {
4935 ReasonCode::TDLS_PEER_UNREACHABLE
4936 }
4937
4938 crate::natural::ReasonCode::TdlsUnspecifiedReason => {
4939 ReasonCode::TDLS_UNSPECIFIED_REASON
4940 }
4941
4942 crate::natural::ReasonCode::SspRequestedDisassoc => {
4943 ReasonCode::SSP_REQUESTED_DISASSOC
4944 }
4945
4946 crate::natural::ReasonCode::NoSspRoamingAgreement => {
4947 ReasonCode::NO_SSP_ROAMING_AGREEMENT
4948 }
4949
4950 crate::natural::ReasonCode::BadCipherOrAkm => ReasonCode::BAD_CIPHER_OR_AKM,
4951
4952 crate::natural::ReasonCode::NotAuthorizedThisLocation => {
4953 ReasonCode::NOT_AUTHORIZED_THIS_LOCATION
4954 }
4955
4956 crate::natural::ReasonCode::ServiceChangePrecludesTs => {
4957 ReasonCode::SERVICE_CHANGE_PRECLUDES_TS
4958 }
4959
4960 crate::natural::ReasonCode::UnspecifiedQosReason => {
4961 ReasonCode::UNSPECIFIED_QOS_REASON
4962 }
4963
4964 crate::natural::ReasonCode::NotEnoughBandwidth => ReasonCode::NOT_ENOUGH_BANDWIDTH,
4965
4966 crate::natural::ReasonCode::MissingAcks => ReasonCode::MISSING_ACKS,
4967
4968 crate::natural::ReasonCode::ExceededTxop => ReasonCode::EXCEEDED_TXOP,
4969
4970 crate::natural::ReasonCode::StaLeaving => ReasonCode::STA_LEAVING,
4971
4972 crate::natural::ReasonCode::EndTsBaDls => ReasonCode::END_TS_BA_DLS,
4973
4974 crate::natural::ReasonCode::UnknownTsBa => ReasonCode::UNKNOWN_TS_BA,
4975
4976 crate::natural::ReasonCode::Timeout => ReasonCode::TIMEOUT,
4977
4978 crate::natural::ReasonCode::PeerkeyMismatch => ReasonCode::PEERKEY_MISMATCH,
4979
4980 crate::natural::ReasonCode::PeerInitiated => ReasonCode::PEER_INITIATED,
4981
4982 crate::natural::ReasonCode::ApInitiated => ReasonCode::AP_INITIATED,
4983
4984 crate::natural::ReasonCode::ReasonInvalidFtActionFrameCount => {
4985 ReasonCode::REASON_INVALID_FT_ACTION_FRAME_COUNT
4986 }
4987
4988 crate::natural::ReasonCode::ReasonInvalidPmkid => ReasonCode::REASON_INVALID_PMKID,
4989
4990 crate::natural::ReasonCode::ReasonInvalidMde => ReasonCode::REASON_INVALID_MDE,
4991
4992 crate::natural::ReasonCode::ReasonInvalidFte => ReasonCode::REASON_INVALID_FTE,
4993
4994 crate::natural::ReasonCode::MeshPeeringCanceled => {
4995 ReasonCode::MESH_PEERING_CANCELED
4996 }
4997
4998 crate::natural::ReasonCode::MeshMaxPeers => ReasonCode::MESH_MAX_PEERS,
4999
5000 crate::natural::ReasonCode::MeshConfigurationPolicyViolation => {
5001 ReasonCode::MESH_CONFIGURATION_POLICY_VIOLATION
5002 }
5003
5004 crate::natural::ReasonCode::MeshCloseRcvd => ReasonCode::MESH_CLOSE_RCVD,
5005
5006 crate::natural::ReasonCode::MeshMaxRetries => ReasonCode::MESH_MAX_RETRIES,
5007
5008 crate::natural::ReasonCode::MeshConfirmTimeout => ReasonCode::MESH_CONFIRM_TIMEOUT,
5009
5010 crate::natural::ReasonCode::MeshInvalidGtk => ReasonCode::MESH_INVALID_GTK,
5011
5012 crate::natural::ReasonCode::MeshInconsistentParameters => {
5013 ReasonCode::MESH_INCONSISTENT_PARAMETERS
5014 }
5015
5016 crate::natural::ReasonCode::MeshInvalidSecurityCapability => {
5017 ReasonCode::MESH_INVALID_SECURITY_CAPABILITY
5018 }
5019
5020 crate::natural::ReasonCode::MeshPathErrorNoProxyInformation => {
5021 ReasonCode::MESH_PATH_ERROR_NO_PROXY_INFORMATION
5022 }
5023
5024 crate::natural::ReasonCode::MeshPathErrorNoForwardingInformation => {
5025 ReasonCode::MESH_PATH_ERROR_NO_FORWARDING_INFORMATION
5026 }
5027
5028 crate::natural::ReasonCode::MeshPathErrorDestinationUnreachable => {
5029 ReasonCode::MESH_PATH_ERROR_DESTINATION_UNREACHABLE
5030 }
5031
5032 crate::natural::ReasonCode::MacAddressAlreadyExistsInMbss => {
5033 ReasonCode::MAC_ADDRESS_ALREADY_EXISTS_IN_MBSS
5034 }
5035
5036 crate::natural::ReasonCode::MeshChannelSwitchRegulatoryRequirements => {
5037 ReasonCode::MESH_CHANNEL_SWITCH_REGULATORY_REQUIREMENTS
5038 }
5039
5040 crate::natural::ReasonCode::MeshChannelSwitchUnspecified => {
5041 ReasonCode::MESH_CHANNEL_SWITCH_UNSPECIFIED
5042 }
5043
5044 crate::natural::ReasonCode::MlmeLinkFailed => ReasonCode::MLME_LINK_FAILED,
5045
5046 crate::natural::ReasonCode::FwRxStalled => ReasonCode::FW_RX_STALLED,
5047
5048 crate::natural::ReasonCode::FwHighWmeRxErrRate => {
5049 ReasonCode::FW_HIGH_WME_RX_ERR_RATE
5050 }
5051
5052 crate::natural::ReasonCode::UnknownOrdinal_(value) => {
5053 ReasonCode { value: ::fidl_next::wire::Uint16::from(value) }
5054 }
5055 }
5056 }
5057 }
5058
5059 impl ::fidl_next::IntoNatural for ReasonCode {
5060 type Natural = crate::natural::ReasonCode;
5061 }
5062
5063 #[repr(C)]
5065 pub struct SetKeyDescriptor<'de> {
5066 pub(crate) table: ::fidl_next::wire::Table<'de>,
5067 }
5068
5069 impl<'de> Drop for SetKeyDescriptor<'de> {
5070 fn drop(&mut self) {
5071 let _ = self.table.get(1).map(|envelope| unsafe {
5072 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
5073 });
5074
5075 let _ = self
5076 .table
5077 .get(2)
5078 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint16>() });
5079
5080 let _ = self
5081 .table
5082 .get(3)
5083 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::KeyType>() });
5084
5085 let _ =
5086 self.table.get(4).map(|envelope| unsafe { envelope.read_unchecked::<[u8; 6]>() });
5087
5088 let _ = self
5089 .table
5090 .get(5)
5091 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
5092
5093 let _ =
5094 self.table.get(6).map(|envelope| unsafe { envelope.read_unchecked::<[u8; 3]>() });
5095
5096 let _ = self.table.get(7).map(|envelope| unsafe {
5097 envelope.read_unchecked::<crate::wire::CipherSuiteType>()
5098 });
5099 }
5100 }
5101
5102 impl ::fidl_next::Constrained for SetKeyDescriptor<'_> {
5103 type Constraint = ();
5104
5105 fn validate(
5106 _: ::fidl_next::Slot<'_, Self>,
5107 _: Self::Constraint,
5108 ) -> Result<(), ::fidl_next::ValidationError> {
5109 Ok(())
5110 }
5111 }
5112
5113 unsafe impl ::fidl_next::Wire for SetKeyDescriptor<'static> {
5114 type Narrowed<'de> = SetKeyDescriptor<'de>;
5115
5116 #[inline]
5117 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
5118 ::fidl_next::munge!(let Self { table } = out);
5119 ::fidl_next::wire::Table::zero_padding(table);
5120 }
5121 }
5122
5123 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SetKeyDescriptor<'de>
5124 where
5125 ___D: ::fidl_next::Decoder<'de> + ?Sized,
5126 {
5127 fn decode(
5128 slot: ::fidl_next::Slot<'_, Self>,
5129 decoder: &mut ___D,
5130 _: (),
5131 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5132 ::fidl_next::munge!(let Self { table } = slot);
5133
5134 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
5135 match ordinal {
5136 0 => unsafe { ::core::hint::unreachable_unchecked() },
5137
5138 1 => {
5139 ::fidl_next::wire::Envelope::decode_as::<
5140 ___D,
5141 ::fidl_next::wire::Vector<'de, u8>,
5142 >(slot.as_mut(), decoder, (32, ()))?;
5143
5144 let value = unsafe {
5145 slot.deref_unchecked()
5146 .deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
5147 };
5148
5149 if value.len() > 32 {
5150 return Err(::fidl_next::DecodeError::VectorTooLong {
5151 size: value.len() as u64,
5152 limit: 32,
5153 });
5154 }
5155
5156 Ok(())
5157 }
5158
5159 2 => {
5160 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint16>(
5161 slot.as_mut(),
5162 decoder,
5163 (),
5164 )?;
5165
5166 Ok(())
5167 }
5168
5169 3 => {
5170 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::KeyType>(
5171 slot.as_mut(),
5172 decoder,
5173 (),
5174 )?;
5175
5176 Ok(())
5177 }
5178
5179 4 => {
5180 ::fidl_next::wire::Envelope::decode_as::<___D, [u8; 6]>(
5181 slot.as_mut(),
5182 decoder,
5183 (),
5184 )?;
5185
5186 Ok(())
5187 }
5188
5189 5 => {
5190 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
5191 slot.as_mut(),
5192 decoder,
5193 (),
5194 )?;
5195
5196 Ok(())
5197 }
5198
5199 6 => {
5200 ::fidl_next::wire::Envelope::decode_as::<___D, [u8; 3]>(
5201 slot.as_mut(),
5202 decoder,
5203 (),
5204 )?;
5205
5206 Ok(())
5207 }
5208
5209 7 => {
5210 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::CipherSuiteType>(
5211 slot.as_mut(),
5212 decoder,
5213 (),
5214 )?;
5215
5216 Ok(())
5217 }
5218
5219 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
5220 }
5221 })
5222 }
5223 }
5224
5225 impl<'de> SetKeyDescriptor<'de> {
5226 pub fn key(&self) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, u8>> {
5227 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
5228 }
5229
5230 pub fn take_key(&mut self) -> ::core::option::Option<::fidl_next::wire::Vector<'de, u8>> {
5231 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
5232 }
5233
5234 pub fn key_id(&self) -> ::core::option::Option<&::fidl_next::wire::Uint16> {
5235 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
5236 }
5237
5238 pub fn take_key_id(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint16> {
5239 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
5240 }
5241
5242 pub fn key_type(&self) -> ::core::option::Option<&crate::wire::KeyType> {
5243 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
5244 }
5245
5246 pub fn take_key_type(&mut self) -> ::core::option::Option<crate::wire::KeyType> {
5247 unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
5248 }
5249
5250 pub fn peer_addr(&self) -> ::core::option::Option<&[u8; 6]> {
5251 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
5252 }
5253
5254 pub fn take_peer_addr(&mut self) -> ::core::option::Option<[u8; 6]> {
5255 unsafe { Some(self.table.get_mut(4)?.take_unchecked()) }
5256 }
5257
5258 pub fn rsc(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
5259 unsafe { Some(self.table.get(5)?.deref_unchecked()) }
5260 }
5261
5262 pub fn take_rsc(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
5263 unsafe { Some(self.table.get_mut(5)?.take_unchecked()) }
5264 }
5265
5266 pub fn cipher_oui(&self) -> ::core::option::Option<&[u8; 3]> {
5267 unsafe { Some(self.table.get(6)?.deref_unchecked()) }
5268 }
5269
5270 pub fn take_cipher_oui(&mut self) -> ::core::option::Option<[u8; 3]> {
5271 unsafe { Some(self.table.get_mut(6)?.take_unchecked()) }
5272 }
5273
5274 pub fn cipher_type(&self) -> ::core::option::Option<&crate::wire::CipherSuiteType> {
5275 unsafe { Some(self.table.get(7)?.deref_unchecked()) }
5276 }
5277
5278 pub fn take_cipher_type(&mut self) -> ::core::option::Option<crate::wire::CipherSuiteType> {
5279 unsafe { Some(self.table.get_mut(7)?.take_unchecked()) }
5280 }
5281 }
5282
5283 impl<'de> ::core::fmt::Debug for SetKeyDescriptor<'de> {
5284 fn fmt(
5285 &self,
5286 f: &mut ::core::fmt::Formatter<'_>,
5287 ) -> ::core::result::Result<(), ::core::fmt::Error> {
5288 f.debug_struct("SetKeyDescriptor")
5289 .field("key", &self.key())
5290 .field("key_id", &self.key_id())
5291 .field("key_type", &self.key_type())
5292 .field("peer_addr", &self.peer_addr())
5293 .field("rsc", &self.rsc())
5294 .field("cipher_oui", &self.cipher_oui())
5295 .field("cipher_type", &self.cipher_type())
5296 .finish()
5297 }
5298 }
5299
5300 impl<'de> ::fidl_next::IntoNatural for SetKeyDescriptor<'de> {
5301 type Natural = crate::natural::SetKeyDescriptor;
5302 }
5303
5304 pub type Ssid<'de> = ::fidl_next::wire::Vector<'de, u8>;
5306
5307 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
5309 #[repr(transparent)]
5310 pub struct StatusCode {
5311 pub(crate) value: ::fidl_next::wire::Uint16,
5312 }
5313
5314 impl ::fidl_next::Constrained for StatusCode {
5315 type Constraint = ();
5316
5317 fn validate(
5318 _: ::fidl_next::Slot<'_, Self>,
5319 _: Self::Constraint,
5320 ) -> Result<(), ::fidl_next::ValidationError> {
5321 Ok(())
5322 }
5323 }
5324
5325 unsafe impl ::fidl_next::Wire for StatusCode {
5326 type Narrowed<'de> = Self;
5327
5328 #[inline]
5329 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
5330 }
5332 }
5333
5334 impl StatusCode {
5335 pub const SUCCESS: StatusCode = StatusCode { value: ::fidl_next::wire::Uint16(0) };
5336
5337 pub const REFUSED_REASON_UNSPECIFIED: StatusCode =
5338 StatusCode { value: ::fidl_next::wire::Uint16(1) };
5339
5340 pub const TDLS_REJECTED_ALTERNATIVE_PROVIDED: StatusCode =
5341 StatusCode { value: ::fidl_next::wire::Uint16(2) };
5342
5343 pub const TDLS_REJECTED: StatusCode = StatusCode { value: ::fidl_next::wire::Uint16(3) };
5344
5345 pub const SECURITY_DISABLED: StatusCode =
5346 StatusCode { value: ::fidl_next::wire::Uint16(5) };
5347
5348 pub const UNACCEPTABLE_LIFETIME: StatusCode =
5349 StatusCode { value: ::fidl_next::wire::Uint16(6) };
5350
5351 pub const NOT_IN_SAME_BSS: StatusCode = StatusCode { value: ::fidl_next::wire::Uint16(7) };
5352
5353 pub const REFUSED_CAPABILITIES_MISMATCH: StatusCode =
5354 StatusCode { value: ::fidl_next::wire::Uint16(10) };
5355
5356 pub const DENIED_NO_ASSOCIATION_EXISTS: StatusCode =
5357 StatusCode { value: ::fidl_next::wire::Uint16(11) };
5358
5359 pub const DENIED_OTHER_REASON: StatusCode =
5360 StatusCode { value: ::fidl_next::wire::Uint16(12) };
5361
5362 pub const UNSUPPORTED_AUTH_ALGORITHM: StatusCode =
5363 StatusCode { value: ::fidl_next::wire::Uint16(13) };
5364
5365 pub const TRANSACTION_SEQUENCE_ERROR: StatusCode =
5366 StatusCode { value: ::fidl_next::wire::Uint16(14) };
5367
5368 pub const CHALLENGE_FAILURE: StatusCode =
5369 StatusCode { value: ::fidl_next::wire::Uint16(15) };
5370
5371 pub const REJECTED_SEQUENCE_TIMEOUT: StatusCode =
5372 StatusCode { value: ::fidl_next::wire::Uint16(16) };
5373
5374 pub const DENIED_NO_MORE_STAS: StatusCode =
5375 StatusCode { value: ::fidl_next::wire::Uint16(17) };
5376
5377 pub const REFUSED_BASIC_RATES_MISMATCH: StatusCode =
5378 StatusCode { value: ::fidl_next::wire::Uint16(18) };
5379
5380 pub const DENIED_NO_SHORT_PREAMBLE_SUPPORT: StatusCode =
5381 StatusCode { value: ::fidl_next::wire::Uint16(19) };
5382
5383 pub const REJECTED_SPECTRUM_MANAGEMENT_REQUIRED: StatusCode =
5384 StatusCode { value: ::fidl_next::wire::Uint16(22) };
5385
5386 pub const REJECTED_BAD_POWER_CAPABILITY: StatusCode =
5387 StatusCode { value: ::fidl_next::wire::Uint16(23) };
5388
5389 pub const REJECTED_BAD_SUPPORTED_CHANNELS: StatusCode =
5390 StatusCode { value: ::fidl_next::wire::Uint16(24) };
5391
5392 pub const DENIED_NO_SHORT_SLOT_TIME_SUPPORT: StatusCode =
5393 StatusCode { value: ::fidl_next::wire::Uint16(25) };
5394
5395 pub const DENIED_NO_HT_SUPPORT: StatusCode =
5396 StatusCode { value: ::fidl_next::wire::Uint16(27) };
5397
5398 pub const R0_KH_UNREACHABLE: StatusCode =
5399 StatusCode { value: ::fidl_next::wire::Uint16(28) };
5400
5401 pub const DENIED_PCO_TIME_NOT_SUPPORTED: StatusCode =
5402 StatusCode { value: ::fidl_next::wire::Uint16(29) };
5403
5404 pub const REFUSED_TEMPORARILY: StatusCode =
5405 StatusCode { value: ::fidl_next::wire::Uint16(30) };
5406
5407 pub const ROBUST_MANAGEMENT_POLICY_VIOLATION: StatusCode =
5408 StatusCode { value: ::fidl_next::wire::Uint16(31) };
5409
5410 pub const UNSPECIFIED_QOS_FAILURE: StatusCode =
5411 StatusCode { value: ::fidl_next::wire::Uint16(32) };
5412
5413 pub const DENIED_INSUFFICIENT_BANDWIDTH: StatusCode =
5414 StatusCode { value: ::fidl_next::wire::Uint16(33) };
5415
5416 pub const DENIED_POOR_CHANNEL_CONDITIONS: StatusCode =
5417 StatusCode { value: ::fidl_next::wire::Uint16(34) };
5418
5419 pub const DENIED_QOS_NOT_SUPPORTED: StatusCode =
5420 StatusCode { value: ::fidl_next::wire::Uint16(35) };
5421
5422 pub const REQUEST_DECLINED: StatusCode =
5423 StatusCode { value: ::fidl_next::wire::Uint16(37) };
5424
5425 pub const INVALID_PARAMETERS: StatusCode =
5426 StatusCode { value: ::fidl_next::wire::Uint16(38) };
5427
5428 pub const REJECTED_WITH_SUGGESTED_CHANGES: StatusCode =
5429 StatusCode { value: ::fidl_next::wire::Uint16(39) };
5430
5431 pub const STATUS_INVALID_ELEMENT: StatusCode =
5432 StatusCode { value: ::fidl_next::wire::Uint16(40) };
5433
5434 pub const STATUS_INVALID_GROUP_CIPHER: StatusCode =
5435 StatusCode { value: ::fidl_next::wire::Uint16(41) };
5436
5437 pub const STATUS_INVALID_PAIRWISE_CIPHER: StatusCode =
5438 StatusCode { value: ::fidl_next::wire::Uint16(42) };
5439
5440 pub const STATUS_INVALID_AKMP: StatusCode =
5441 StatusCode { value: ::fidl_next::wire::Uint16(43) };
5442
5443 pub const UNSUPPORTED_RSNE_VERSION: StatusCode =
5444 StatusCode { value: ::fidl_next::wire::Uint16(44) };
5445
5446 pub const INVALID_RSNE_CAPABILITIES: StatusCode =
5447 StatusCode { value: ::fidl_next::wire::Uint16(45) };
5448
5449 pub const STATUS_CIPHER_OUT_OF_POLICY: StatusCode =
5450 StatusCode { value: ::fidl_next::wire::Uint16(46) };
5451
5452 pub const REJECTED_FOR_DELAY_PERIOD: StatusCode =
5453 StatusCode { value: ::fidl_next::wire::Uint16(47) };
5454
5455 pub const DLS_NOT_ALLOWED: StatusCode = StatusCode { value: ::fidl_next::wire::Uint16(48) };
5456
5457 pub const NOT_PRESENT: StatusCode = StatusCode { value: ::fidl_next::wire::Uint16(49) };
5458
5459 pub const NOT_QOS_STA: StatusCode = StatusCode { value: ::fidl_next::wire::Uint16(50) };
5460
5461 pub const DENIED_LISTEN_INTERVAL_TOO_LARGE: StatusCode =
5462 StatusCode { value: ::fidl_next::wire::Uint16(51) };
5463
5464 pub const STATUS_INVALID_FT_ACTION_FRAME_COUNT: StatusCode =
5465 StatusCode { value: ::fidl_next::wire::Uint16(52) };
5466
5467 pub const STATUS_INVALID_PMKID: StatusCode =
5468 StatusCode { value: ::fidl_next::wire::Uint16(53) };
5469
5470 pub const STATUS_INVALID_MDE: StatusCode =
5471 StatusCode { value: ::fidl_next::wire::Uint16(54) };
5472
5473 pub const STATUS_INVALID_FTE: StatusCode =
5474 StatusCode { value: ::fidl_next::wire::Uint16(55) };
5475
5476 pub const REQUESTED_TCLAS_NOT_SUPPORTED_BY_AP: StatusCode =
5477 StatusCode { value: ::fidl_next::wire::Uint16(56) };
5478
5479 pub const INSUFFICIENT_TCLAS_PROCESSING_RESOURCES: StatusCode =
5480 StatusCode { value: ::fidl_next::wire::Uint16(57) };
5481
5482 pub const TRY_ANOTHER_BSS: StatusCode = StatusCode { value: ::fidl_next::wire::Uint16(58) };
5483
5484 pub const GAS_ADVERTISEMENT_PROTOCOL_NOT_SUPPORTED: StatusCode =
5485 StatusCode { value: ::fidl_next::wire::Uint16(59) };
5486
5487 pub const NO_OUTSTANDING_GAS_REQUEST: StatusCode =
5488 StatusCode { value: ::fidl_next::wire::Uint16(60) };
5489
5490 pub const GAS_RESPONSE_NOT_RECEIVED_FROM_SERVER: StatusCode =
5491 StatusCode { value: ::fidl_next::wire::Uint16(61) };
5492
5493 pub const GAS_QUERY_TIMEOUT: StatusCode =
5494 StatusCode { value: ::fidl_next::wire::Uint16(62) };
5495
5496 pub const GAS_QUERY_RESPONSE_TOO_LARGE: StatusCode =
5497 StatusCode { value: ::fidl_next::wire::Uint16(63) };
5498
5499 pub const REJECTED_HOME_WITH_SUGGESTED_CHANGES: StatusCode =
5500 StatusCode { value: ::fidl_next::wire::Uint16(64) };
5501
5502 pub const SERVER_UNREACHABLE: StatusCode =
5503 StatusCode { value: ::fidl_next::wire::Uint16(65) };
5504
5505 pub const REJECTED_FOR_SSP_PERMISSIONS: StatusCode =
5506 StatusCode { value: ::fidl_next::wire::Uint16(67) };
5507
5508 pub const REFUSED_UNAUTHENTICATED_ACCESS_NOT_SUPPORTED: StatusCode =
5509 StatusCode { value: ::fidl_next::wire::Uint16(68) };
5510
5511 pub const INVALID_RSNE: StatusCode = StatusCode { value: ::fidl_next::wire::Uint16(72) };
5512
5513 pub const U_APSD_COEXISTANCE_NOT_SUPPORTED: StatusCode =
5514 StatusCode { value: ::fidl_next::wire::Uint16(73) };
5515
5516 pub const U_APSD_COEX_MODE_NOT_SUPPORTED: StatusCode =
5517 StatusCode { value: ::fidl_next::wire::Uint16(74) };
5518
5519 pub const BAD_INTERVAL_WITH_U_APSD_COEX: StatusCode =
5520 StatusCode { value: ::fidl_next::wire::Uint16(75) };
5521
5522 pub const ANTI_CLOGGING_TOKEN_REQUIRED: StatusCode =
5523 StatusCode { value: ::fidl_next::wire::Uint16(76) };
5524
5525 pub const UNSUPPORTED_FINITE_CYCLIC_GROUP: StatusCode =
5526 StatusCode { value: ::fidl_next::wire::Uint16(77) };
5527
5528 pub const CANNOT_FIND_ALTERNATIVE_TBTT: StatusCode =
5529 StatusCode { value: ::fidl_next::wire::Uint16(78) };
5530
5531 pub const TRANSMISSION_FAILURE: StatusCode =
5532 StatusCode { value: ::fidl_next::wire::Uint16(79) };
5533
5534 pub const REQUESTED_TCLAS_NOT_SUPPORTED: StatusCode =
5535 StatusCode { value: ::fidl_next::wire::Uint16(80) };
5536
5537 pub const TCLAS_RESOURCES_EXHAUSTED: StatusCode =
5538 StatusCode { value: ::fidl_next::wire::Uint16(81) };
5539
5540 pub const REJECTED_WITH_SUGGESTED_BSS_TRANSITION: StatusCode =
5541 StatusCode { value: ::fidl_next::wire::Uint16(82) };
5542
5543 pub const REJECT_WITH_SCHEDULE: StatusCode =
5544 StatusCode { value: ::fidl_next::wire::Uint16(83) };
5545
5546 pub const REJECT_NO_WAKEUP_SPECIFIED: StatusCode =
5547 StatusCode { value: ::fidl_next::wire::Uint16(84) };
5548
5549 pub const SUCCESS_POWER_SAVE_MODE: StatusCode =
5550 StatusCode { value: ::fidl_next::wire::Uint16(85) };
5551
5552 pub const PENDING_ADMITTING_FST_SESSION: StatusCode =
5553 StatusCode { value: ::fidl_next::wire::Uint16(86) };
5554
5555 pub const PERFORMING_FST_NOW: StatusCode =
5556 StatusCode { value: ::fidl_next::wire::Uint16(87) };
5557
5558 pub const PENDING_GAP_IN_BA_WINDOW: StatusCode =
5559 StatusCode { value: ::fidl_next::wire::Uint16(88) };
5560
5561 pub const REJECT_U_PID_SETTING: StatusCode =
5562 StatusCode { value: ::fidl_next::wire::Uint16(89) };
5563
5564 pub const REFUSED_EXTERNAL_REASON: StatusCode =
5565 StatusCode { value: ::fidl_next::wire::Uint16(92) };
5566
5567 pub const REFUSED_AP_OUT_OF_MEMORY: StatusCode =
5568 StatusCode { value: ::fidl_next::wire::Uint16(93) };
5569
5570 pub const REJECTED_EMERGENCY_SERVICES_NOT_SUPPORTED: StatusCode =
5571 StatusCode { value: ::fidl_next::wire::Uint16(94) };
5572
5573 pub const QUERY_RESPONSE_OUTSTANDING: StatusCode =
5574 StatusCode { value: ::fidl_next::wire::Uint16(95) };
5575
5576 pub const REJECT_DSE_BAND: StatusCode = StatusCode { value: ::fidl_next::wire::Uint16(96) };
5577
5578 pub const TCLAS_PROCESSING_TERMINATED: StatusCode =
5579 StatusCode { value: ::fidl_next::wire::Uint16(97) };
5580
5581 pub const TS_SCHEDULE_CONFLICT: StatusCode =
5582 StatusCode { value: ::fidl_next::wire::Uint16(98) };
5583
5584 pub const DENIED_WITH_SUGGESTED_BAND_AND_CHANNEL: StatusCode =
5585 StatusCode { value: ::fidl_next::wire::Uint16(99) };
5586
5587 pub const MCCAOP_RESERVATION_CONFLICT: StatusCode =
5588 StatusCode { value: ::fidl_next::wire::Uint16(100) };
5589
5590 pub const MAF_LIMIT_EXCEEDED: StatusCode =
5591 StatusCode { value: ::fidl_next::wire::Uint16(101) };
5592
5593 pub const MCCA_TRACK_LIMIT_EXCEEDED: StatusCode =
5594 StatusCode { value: ::fidl_next::wire::Uint16(102) };
5595
5596 pub const DENIED_DUE_TO_SPECTRUM_MANAGEMENT: StatusCode =
5597 StatusCode { value: ::fidl_next::wire::Uint16(103) };
5598
5599 pub const DENIED_VHT_NOT_SUPPORTED: StatusCode =
5600 StatusCode { value: ::fidl_next::wire::Uint16(104) };
5601
5602 pub const ENABLEMENT_DENIED: StatusCode =
5603 StatusCode { value: ::fidl_next::wire::Uint16(105) };
5604
5605 pub const RESTRICTION_FROM_AUTHORIZED_GDB: StatusCode =
5606 StatusCode { value: ::fidl_next::wire::Uint16(106) };
5607
5608 pub const AUTHORIZATION_DEENABLED: StatusCode =
5609 StatusCode { value: ::fidl_next::wire::Uint16(107) };
5610
5611 pub const ENERGY_LIMITED_OPERATION_NOT_SUPPORTED: StatusCode =
5612 StatusCode { value: ::fidl_next::wire::Uint16(108) };
5613
5614 pub const REJECTED_NDP_BLOCK_ACK_SUGGESTED: StatusCode =
5615 StatusCode { value: ::fidl_next::wire::Uint16(109) };
5616
5617 pub const REJECTED_MAX_AWAY_DURATION_UNACCEPTABLE: StatusCode =
5618 StatusCode { value: ::fidl_next::wire::Uint16(110) };
5619
5620 pub const FLOW_CONTROL_OPERATION_SUPPORTED: StatusCode =
5621 StatusCode { value: ::fidl_next::wire::Uint16(111) };
5622
5623 pub const FILS_AUTHENTICATION_FAILURE: StatusCode =
5624 StatusCode { value: ::fidl_next::wire::Uint16(112) };
5625
5626 pub const UNKNOWN_AUTHENTICATION_SERVER: StatusCode =
5627 StatusCode { value: ::fidl_next::wire::Uint16(113) };
5628
5629 pub const DENIED_NOTIFICATION_PERIOD_ALLOCATION: StatusCode =
5630 StatusCode { value: ::fidl_next::wire::Uint16(116) };
5631
5632 pub const DENIED_CHANNEL_SPLITTING: StatusCode =
5633 StatusCode { value: ::fidl_next::wire::Uint16(117) };
5634
5635 pub const DENIED_ALLOCATION: StatusCode =
5636 StatusCode { value: ::fidl_next::wire::Uint16(118) };
5637
5638 pub const CMMG_FEATURES_NOT_SUPPORTED: StatusCode =
5639 StatusCode { value: ::fidl_next::wire::Uint16(119) };
5640
5641 pub const GAS_FRAGMENT_NOT_AVAILABLE: StatusCode =
5642 StatusCode { value: ::fidl_next::wire::Uint16(120) };
5643
5644 pub const SUCCESS_CAG_VERSIONS_MATCH: StatusCode =
5645 StatusCode { value: ::fidl_next::wire::Uint16(121) };
5646
5647 pub const GLK_NOT_AUTHORIZED: StatusCode =
5648 StatusCode { value: ::fidl_next::wire::Uint16(122) };
5649
5650 pub const UNKNOWN_PASSWORD_IDENTIFIER: StatusCode =
5651 StatusCode { value: ::fidl_next::wire::Uint16(123) };
5652
5653 pub const DENIED_LOCAL_MAC_ADDRESS_POLICY_VIOLATION: StatusCode =
5654 StatusCode { value: ::fidl_next::wire::Uint16(125) };
5655
5656 pub const SAE_HASH_TO_ELEMENT: StatusCode =
5657 StatusCode { value: ::fidl_next::wire::Uint16(126) };
5658
5659 pub const TCLAS_PROCESSING_TERMINATED_INSUFFICIENT_QOS: StatusCode =
5660 StatusCode { value: ::fidl_next::wire::Uint16(128) };
5661
5662 pub const TCLAS_PROCESSING_TERMINATED_POLICY_CONFLICT: StatusCode =
5663 StatusCode { value: ::fidl_next::wire::Uint16(129) };
5664
5665 pub const JOIN_FAILURE: StatusCode = StatusCode { value: ::fidl_next::wire::Uint16(256) };
5666
5667 pub const SPURIOUS_DEAUTH_OR_DISASSOC: StatusCode =
5668 StatusCode { value: ::fidl_next::wire::Uint16(257) };
5669
5670 pub const CANCELED: StatusCode = StatusCode { value: ::fidl_next::wire::Uint16(258) };
5671
5672 pub const ESTABLISH_RSNA_FAILURE: StatusCode =
5673 StatusCode { value: ::fidl_next::wire::Uint16(259) };
5674
5675 pub const OWE_HANDSHAKE_FAILURE: StatusCode =
5676 StatusCode { value: ::fidl_next::wire::Uint16(260) };
5677 }
5678
5679 unsafe impl<___D> ::fidl_next::Decode<___D> for StatusCode
5680 where
5681 ___D: ?Sized,
5682 {
5683 fn decode(
5684 slot: ::fidl_next::Slot<'_, Self>,
5685 _: &mut ___D,
5686 _: (),
5687 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5688 Ok(())
5689 }
5690 }
5691
5692 impl ::core::convert::From<crate::natural::StatusCode> for StatusCode {
5693 fn from(natural: crate::natural::StatusCode) -> Self {
5694 match natural {
5695 crate::natural::StatusCode::Success => StatusCode::SUCCESS,
5696
5697 crate::natural::StatusCode::RefusedReasonUnspecified => {
5698 StatusCode::REFUSED_REASON_UNSPECIFIED
5699 }
5700
5701 crate::natural::StatusCode::TdlsRejectedAlternativeProvided => {
5702 StatusCode::TDLS_REJECTED_ALTERNATIVE_PROVIDED
5703 }
5704
5705 crate::natural::StatusCode::TdlsRejected => StatusCode::TDLS_REJECTED,
5706
5707 crate::natural::StatusCode::SecurityDisabled => StatusCode::SECURITY_DISABLED,
5708
5709 crate::natural::StatusCode::UnacceptableLifetime => {
5710 StatusCode::UNACCEPTABLE_LIFETIME
5711 }
5712
5713 crate::natural::StatusCode::NotInSameBss => StatusCode::NOT_IN_SAME_BSS,
5714
5715 crate::natural::StatusCode::RefusedCapabilitiesMismatch => {
5716 StatusCode::REFUSED_CAPABILITIES_MISMATCH
5717 }
5718
5719 crate::natural::StatusCode::DeniedNoAssociationExists => {
5720 StatusCode::DENIED_NO_ASSOCIATION_EXISTS
5721 }
5722
5723 crate::natural::StatusCode::DeniedOtherReason => StatusCode::DENIED_OTHER_REASON,
5724
5725 crate::natural::StatusCode::UnsupportedAuthAlgorithm => {
5726 StatusCode::UNSUPPORTED_AUTH_ALGORITHM
5727 }
5728
5729 crate::natural::StatusCode::TransactionSequenceError => {
5730 StatusCode::TRANSACTION_SEQUENCE_ERROR
5731 }
5732
5733 crate::natural::StatusCode::ChallengeFailure => StatusCode::CHALLENGE_FAILURE,
5734
5735 crate::natural::StatusCode::RejectedSequenceTimeout => {
5736 StatusCode::REJECTED_SEQUENCE_TIMEOUT
5737 }
5738
5739 crate::natural::StatusCode::DeniedNoMoreStas => StatusCode::DENIED_NO_MORE_STAS,
5740
5741 crate::natural::StatusCode::RefusedBasicRatesMismatch => {
5742 StatusCode::REFUSED_BASIC_RATES_MISMATCH
5743 }
5744
5745 crate::natural::StatusCode::DeniedNoShortPreambleSupport => {
5746 StatusCode::DENIED_NO_SHORT_PREAMBLE_SUPPORT
5747 }
5748
5749 crate::natural::StatusCode::RejectedSpectrumManagementRequired => {
5750 StatusCode::REJECTED_SPECTRUM_MANAGEMENT_REQUIRED
5751 }
5752
5753 crate::natural::StatusCode::RejectedBadPowerCapability => {
5754 StatusCode::REJECTED_BAD_POWER_CAPABILITY
5755 }
5756
5757 crate::natural::StatusCode::RejectedBadSupportedChannels => {
5758 StatusCode::REJECTED_BAD_SUPPORTED_CHANNELS
5759 }
5760
5761 crate::natural::StatusCode::DeniedNoShortSlotTimeSupport => {
5762 StatusCode::DENIED_NO_SHORT_SLOT_TIME_SUPPORT
5763 }
5764
5765 crate::natural::StatusCode::DeniedNoHtSupport => StatusCode::DENIED_NO_HT_SUPPORT,
5766
5767 crate::natural::StatusCode::R0KhUnreachable => StatusCode::R0_KH_UNREACHABLE,
5768
5769 crate::natural::StatusCode::DeniedPcoTimeNotSupported => {
5770 StatusCode::DENIED_PCO_TIME_NOT_SUPPORTED
5771 }
5772
5773 crate::natural::StatusCode::RefusedTemporarily => StatusCode::REFUSED_TEMPORARILY,
5774
5775 crate::natural::StatusCode::RobustManagementPolicyViolation => {
5776 StatusCode::ROBUST_MANAGEMENT_POLICY_VIOLATION
5777 }
5778
5779 crate::natural::StatusCode::UnspecifiedQosFailure => {
5780 StatusCode::UNSPECIFIED_QOS_FAILURE
5781 }
5782
5783 crate::natural::StatusCode::DeniedInsufficientBandwidth => {
5784 StatusCode::DENIED_INSUFFICIENT_BANDWIDTH
5785 }
5786
5787 crate::natural::StatusCode::DeniedPoorChannelConditions => {
5788 StatusCode::DENIED_POOR_CHANNEL_CONDITIONS
5789 }
5790
5791 crate::natural::StatusCode::DeniedQosNotSupported => {
5792 StatusCode::DENIED_QOS_NOT_SUPPORTED
5793 }
5794
5795 crate::natural::StatusCode::RequestDeclined => StatusCode::REQUEST_DECLINED,
5796
5797 crate::natural::StatusCode::InvalidParameters => StatusCode::INVALID_PARAMETERS,
5798
5799 crate::natural::StatusCode::RejectedWithSuggestedChanges => {
5800 StatusCode::REJECTED_WITH_SUGGESTED_CHANGES
5801 }
5802
5803 crate::natural::StatusCode::StatusInvalidElement => {
5804 StatusCode::STATUS_INVALID_ELEMENT
5805 }
5806
5807 crate::natural::StatusCode::StatusInvalidGroupCipher => {
5808 StatusCode::STATUS_INVALID_GROUP_CIPHER
5809 }
5810
5811 crate::natural::StatusCode::StatusInvalidPairwiseCipher => {
5812 StatusCode::STATUS_INVALID_PAIRWISE_CIPHER
5813 }
5814
5815 crate::natural::StatusCode::StatusInvalidAkmp => StatusCode::STATUS_INVALID_AKMP,
5816
5817 crate::natural::StatusCode::UnsupportedRsneVersion => {
5818 StatusCode::UNSUPPORTED_RSNE_VERSION
5819 }
5820
5821 crate::natural::StatusCode::InvalidRsneCapabilities => {
5822 StatusCode::INVALID_RSNE_CAPABILITIES
5823 }
5824
5825 crate::natural::StatusCode::StatusCipherOutOfPolicy => {
5826 StatusCode::STATUS_CIPHER_OUT_OF_POLICY
5827 }
5828
5829 crate::natural::StatusCode::RejectedForDelayPeriod => {
5830 StatusCode::REJECTED_FOR_DELAY_PERIOD
5831 }
5832
5833 crate::natural::StatusCode::DlsNotAllowed => StatusCode::DLS_NOT_ALLOWED,
5834
5835 crate::natural::StatusCode::NotPresent => StatusCode::NOT_PRESENT,
5836
5837 crate::natural::StatusCode::NotQosSta => StatusCode::NOT_QOS_STA,
5838
5839 crate::natural::StatusCode::DeniedListenIntervalTooLarge => {
5840 StatusCode::DENIED_LISTEN_INTERVAL_TOO_LARGE
5841 }
5842
5843 crate::natural::StatusCode::StatusInvalidFtActionFrameCount => {
5844 StatusCode::STATUS_INVALID_FT_ACTION_FRAME_COUNT
5845 }
5846
5847 crate::natural::StatusCode::StatusInvalidPmkid => StatusCode::STATUS_INVALID_PMKID,
5848
5849 crate::natural::StatusCode::StatusInvalidMde => StatusCode::STATUS_INVALID_MDE,
5850
5851 crate::natural::StatusCode::StatusInvalidFte => StatusCode::STATUS_INVALID_FTE,
5852
5853 crate::natural::StatusCode::RequestedTclasNotSupportedByAp => {
5854 StatusCode::REQUESTED_TCLAS_NOT_SUPPORTED_BY_AP
5855 }
5856
5857 crate::natural::StatusCode::InsufficientTclasProcessingResources => {
5858 StatusCode::INSUFFICIENT_TCLAS_PROCESSING_RESOURCES
5859 }
5860
5861 crate::natural::StatusCode::TryAnotherBss => StatusCode::TRY_ANOTHER_BSS,
5862
5863 crate::natural::StatusCode::GasAdvertisementProtocolNotSupported => {
5864 StatusCode::GAS_ADVERTISEMENT_PROTOCOL_NOT_SUPPORTED
5865 }
5866
5867 crate::natural::StatusCode::NoOutstandingGasRequest => {
5868 StatusCode::NO_OUTSTANDING_GAS_REQUEST
5869 }
5870
5871 crate::natural::StatusCode::GasResponseNotReceivedFromServer => {
5872 StatusCode::GAS_RESPONSE_NOT_RECEIVED_FROM_SERVER
5873 }
5874
5875 crate::natural::StatusCode::GasQueryTimeout => StatusCode::GAS_QUERY_TIMEOUT,
5876
5877 crate::natural::StatusCode::GasQueryResponseTooLarge => {
5878 StatusCode::GAS_QUERY_RESPONSE_TOO_LARGE
5879 }
5880
5881 crate::natural::StatusCode::RejectedHomeWithSuggestedChanges => {
5882 StatusCode::REJECTED_HOME_WITH_SUGGESTED_CHANGES
5883 }
5884
5885 crate::natural::StatusCode::ServerUnreachable => StatusCode::SERVER_UNREACHABLE,
5886
5887 crate::natural::StatusCode::RejectedForSspPermissions => {
5888 StatusCode::REJECTED_FOR_SSP_PERMISSIONS
5889 }
5890
5891 crate::natural::StatusCode::RefusedUnauthenticatedAccessNotSupported => {
5892 StatusCode::REFUSED_UNAUTHENTICATED_ACCESS_NOT_SUPPORTED
5893 }
5894
5895 crate::natural::StatusCode::InvalidRsne => StatusCode::INVALID_RSNE,
5896
5897 crate::natural::StatusCode::UApsdCoexistanceNotSupported => {
5898 StatusCode::U_APSD_COEXISTANCE_NOT_SUPPORTED
5899 }
5900
5901 crate::natural::StatusCode::UApsdCoexModeNotSupported => {
5902 StatusCode::U_APSD_COEX_MODE_NOT_SUPPORTED
5903 }
5904
5905 crate::natural::StatusCode::BadIntervalWithUApsdCoex => {
5906 StatusCode::BAD_INTERVAL_WITH_U_APSD_COEX
5907 }
5908
5909 crate::natural::StatusCode::AntiCloggingTokenRequired => {
5910 StatusCode::ANTI_CLOGGING_TOKEN_REQUIRED
5911 }
5912
5913 crate::natural::StatusCode::UnsupportedFiniteCyclicGroup => {
5914 StatusCode::UNSUPPORTED_FINITE_CYCLIC_GROUP
5915 }
5916
5917 crate::natural::StatusCode::CannotFindAlternativeTbtt => {
5918 StatusCode::CANNOT_FIND_ALTERNATIVE_TBTT
5919 }
5920
5921 crate::natural::StatusCode::TransmissionFailure => StatusCode::TRANSMISSION_FAILURE,
5922
5923 crate::natural::StatusCode::RequestedTclasNotSupported => {
5924 StatusCode::REQUESTED_TCLAS_NOT_SUPPORTED
5925 }
5926
5927 crate::natural::StatusCode::TclasResourcesExhausted => {
5928 StatusCode::TCLAS_RESOURCES_EXHAUSTED
5929 }
5930
5931 crate::natural::StatusCode::RejectedWithSuggestedBssTransition => {
5932 StatusCode::REJECTED_WITH_SUGGESTED_BSS_TRANSITION
5933 }
5934
5935 crate::natural::StatusCode::RejectWithSchedule => StatusCode::REJECT_WITH_SCHEDULE,
5936
5937 crate::natural::StatusCode::RejectNoWakeupSpecified => {
5938 StatusCode::REJECT_NO_WAKEUP_SPECIFIED
5939 }
5940
5941 crate::natural::StatusCode::SuccessPowerSaveMode => {
5942 StatusCode::SUCCESS_POWER_SAVE_MODE
5943 }
5944
5945 crate::natural::StatusCode::PendingAdmittingFstSession => {
5946 StatusCode::PENDING_ADMITTING_FST_SESSION
5947 }
5948
5949 crate::natural::StatusCode::PerformingFstNow => StatusCode::PERFORMING_FST_NOW,
5950
5951 crate::natural::StatusCode::PendingGapInBaWindow => {
5952 StatusCode::PENDING_GAP_IN_BA_WINDOW
5953 }
5954
5955 crate::natural::StatusCode::RejectUPidSetting => StatusCode::REJECT_U_PID_SETTING,
5956
5957 crate::natural::StatusCode::RefusedExternalReason => {
5958 StatusCode::REFUSED_EXTERNAL_REASON
5959 }
5960
5961 crate::natural::StatusCode::RefusedApOutOfMemory => {
5962 StatusCode::REFUSED_AP_OUT_OF_MEMORY
5963 }
5964
5965 crate::natural::StatusCode::RejectedEmergencyServicesNotSupported => {
5966 StatusCode::REJECTED_EMERGENCY_SERVICES_NOT_SUPPORTED
5967 }
5968
5969 crate::natural::StatusCode::QueryResponseOutstanding => {
5970 StatusCode::QUERY_RESPONSE_OUTSTANDING
5971 }
5972
5973 crate::natural::StatusCode::RejectDseBand => StatusCode::REJECT_DSE_BAND,
5974
5975 crate::natural::StatusCode::TclasProcessingTerminated => {
5976 StatusCode::TCLAS_PROCESSING_TERMINATED
5977 }
5978
5979 crate::natural::StatusCode::TsScheduleConflict => StatusCode::TS_SCHEDULE_CONFLICT,
5980
5981 crate::natural::StatusCode::DeniedWithSuggestedBandAndChannel => {
5982 StatusCode::DENIED_WITH_SUGGESTED_BAND_AND_CHANNEL
5983 }
5984
5985 crate::natural::StatusCode::MccaopReservationConflict => {
5986 StatusCode::MCCAOP_RESERVATION_CONFLICT
5987 }
5988
5989 crate::natural::StatusCode::MafLimitExceeded => StatusCode::MAF_LIMIT_EXCEEDED,
5990
5991 crate::natural::StatusCode::MccaTrackLimitExceeded => {
5992 StatusCode::MCCA_TRACK_LIMIT_EXCEEDED
5993 }
5994
5995 crate::natural::StatusCode::DeniedDueToSpectrumManagement => {
5996 StatusCode::DENIED_DUE_TO_SPECTRUM_MANAGEMENT
5997 }
5998
5999 crate::natural::StatusCode::DeniedVhtNotSupported => {
6000 StatusCode::DENIED_VHT_NOT_SUPPORTED
6001 }
6002
6003 crate::natural::StatusCode::EnablementDenied => StatusCode::ENABLEMENT_DENIED,
6004
6005 crate::natural::StatusCode::RestrictionFromAuthorizedGdb => {
6006 StatusCode::RESTRICTION_FROM_AUTHORIZED_GDB
6007 }
6008
6009 crate::natural::StatusCode::AuthorizationDeenabled => {
6010 StatusCode::AUTHORIZATION_DEENABLED
6011 }
6012
6013 crate::natural::StatusCode::EnergyLimitedOperationNotSupported => {
6014 StatusCode::ENERGY_LIMITED_OPERATION_NOT_SUPPORTED
6015 }
6016
6017 crate::natural::StatusCode::RejectedNdpBlockAckSuggested => {
6018 StatusCode::REJECTED_NDP_BLOCK_ACK_SUGGESTED
6019 }
6020
6021 crate::natural::StatusCode::RejectedMaxAwayDurationUnacceptable => {
6022 StatusCode::REJECTED_MAX_AWAY_DURATION_UNACCEPTABLE
6023 }
6024
6025 crate::natural::StatusCode::FlowControlOperationSupported => {
6026 StatusCode::FLOW_CONTROL_OPERATION_SUPPORTED
6027 }
6028
6029 crate::natural::StatusCode::FilsAuthenticationFailure => {
6030 StatusCode::FILS_AUTHENTICATION_FAILURE
6031 }
6032
6033 crate::natural::StatusCode::UnknownAuthenticationServer => {
6034 StatusCode::UNKNOWN_AUTHENTICATION_SERVER
6035 }
6036
6037 crate::natural::StatusCode::DeniedNotificationPeriodAllocation => {
6038 StatusCode::DENIED_NOTIFICATION_PERIOD_ALLOCATION
6039 }
6040
6041 crate::natural::StatusCode::DeniedChannelSplitting => {
6042 StatusCode::DENIED_CHANNEL_SPLITTING
6043 }
6044
6045 crate::natural::StatusCode::DeniedAllocation => StatusCode::DENIED_ALLOCATION,
6046
6047 crate::natural::StatusCode::CmmgFeaturesNotSupported => {
6048 StatusCode::CMMG_FEATURES_NOT_SUPPORTED
6049 }
6050
6051 crate::natural::StatusCode::GasFragmentNotAvailable => {
6052 StatusCode::GAS_FRAGMENT_NOT_AVAILABLE
6053 }
6054
6055 crate::natural::StatusCode::SuccessCagVersionsMatch => {
6056 StatusCode::SUCCESS_CAG_VERSIONS_MATCH
6057 }
6058
6059 crate::natural::StatusCode::GlkNotAuthorized => StatusCode::GLK_NOT_AUTHORIZED,
6060
6061 crate::natural::StatusCode::UnknownPasswordIdentifier => {
6062 StatusCode::UNKNOWN_PASSWORD_IDENTIFIER
6063 }
6064
6065 crate::natural::StatusCode::DeniedLocalMacAddressPolicyViolation => {
6066 StatusCode::DENIED_LOCAL_MAC_ADDRESS_POLICY_VIOLATION
6067 }
6068
6069 crate::natural::StatusCode::SaeHashToElement => StatusCode::SAE_HASH_TO_ELEMENT,
6070
6071 crate::natural::StatusCode::TclasProcessingTerminatedInsufficientQos => {
6072 StatusCode::TCLAS_PROCESSING_TERMINATED_INSUFFICIENT_QOS
6073 }
6074
6075 crate::natural::StatusCode::TclasProcessingTerminatedPolicyConflict => {
6076 StatusCode::TCLAS_PROCESSING_TERMINATED_POLICY_CONFLICT
6077 }
6078
6079 crate::natural::StatusCode::JoinFailure => StatusCode::JOIN_FAILURE,
6080
6081 crate::natural::StatusCode::SpuriousDeauthOrDisassoc => {
6082 StatusCode::SPURIOUS_DEAUTH_OR_DISASSOC
6083 }
6084
6085 crate::natural::StatusCode::Canceled => StatusCode::CANCELED,
6086
6087 crate::natural::StatusCode::EstablishRsnaFailure => {
6088 StatusCode::ESTABLISH_RSNA_FAILURE
6089 }
6090
6091 crate::natural::StatusCode::OweHandshakeFailure => {
6092 StatusCode::OWE_HANDSHAKE_FAILURE
6093 }
6094
6095 crate::natural::StatusCode::UnknownOrdinal_(value) => {
6096 StatusCode { value: ::fidl_next::wire::Uint16::from(value) }
6097 }
6098 }
6099 }
6100 }
6101
6102 impl ::fidl_next::IntoNatural for StatusCode {
6103 type Natural = crate::natural::StatusCode;
6104 }
6105
6106 #[derive(Clone, Debug)]
6108 #[repr(C)]
6109 pub struct VhtCapabilities {
6110 pub bytes: [u8; 12],
6111 }
6112
6113 static_assertions::const_assert_eq!(std::mem::size_of::<VhtCapabilities>(), 12);
6114 static_assertions::const_assert_eq!(std::mem::align_of::<VhtCapabilities>(), 1);
6115
6116 static_assertions::const_assert_eq!(std::mem::offset_of!(VhtCapabilities, bytes), 0);
6117
6118 impl ::fidl_next::Constrained for VhtCapabilities {
6119 type Constraint = ();
6120
6121 fn validate(
6122 _: ::fidl_next::Slot<'_, Self>,
6123 _: Self::Constraint,
6124 ) -> Result<(), ::fidl_next::ValidationError> {
6125 Ok(())
6126 }
6127 }
6128
6129 unsafe impl ::fidl_next::Wire for VhtCapabilities {
6130 type Narrowed<'de> = VhtCapabilities;
6131
6132 #[inline]
6133 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6134 ::fidl_next::munge! {
6135 let Self {
6136 bytes,
6137
6138 } = &mut *out_;
6139 }
6140
6141 ::fidl_next::Wire::zero_padding(bytes);
6142 }
6143 }
6144
6145 unsafe impl<___D> ::fidl_next::Decode<___D> for VhtCapabilities
6146 where
6147 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6148 {
6149 fn decode(
6150 slot_: ::fidl_next::Slot<'_, Self>,
6151 decoder_: &mut ___D,
6152 _: (),
6153 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6154 ::fidl_next::munge! {
6155 let Self {
6156 mut bytes,
6157
6158 } = slot_;
6159 }
6160
6161 let _field = bytes.as_mut();
6162
6163 ::fidl_next::Decode::decode(bytes.as_mut(), decoder_, ())?;
6164
6165 Ok(())
6166 }
6167 }
6168
6169 impl ::fidl_next::IntoNatural for VhtCapabilities {
6170 type Natural = crate::natural::VhtCapabilities;
6171 }
6172
6173 #[derive(Clone, Debug)]
6175 #[repr(C)]
6176 pub struct VhtOperation {
6177 pub bytes: [u8; 5],
6178 }
6179
6180 static_assertions::const_assert_eq!(std::mem::size_of::<VhtOperation>(), 5);
6181 static_assertions::const_assert_eq!(std::mem::align_of::<VhtOperation>(), 1);
6182
6183 static_assertions::const_assert_eq!(std::mem::offset_of!(VhtOperation, bytes), 0);
6184
6185 impl ::fidl_next::Constrained for VhtOperation {
6186 type Constraint = ();
6187
6188 fn validate(
6189 _: ::fidl_next::Slot<'_, Self>,
6190 _: Self::Constraint,
6191 ) -> Result<(), ::fidl_next::ValidationError> {
6192 Ok(())
6193 }
6194 }
6195
6196 unsafe impl ::fidl_next::Wire for VhtOperation {
6197 type Narrowed<'de> = VhtOperation;
6198
6199 #[inline]
6200 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6201 ::fidl_next::munge! {
6202 let Self {
6203 bytes,
6204
6205 } = &mut *out_;
6206 }
6207
6208 ::fidl_next::Wire::zero_padding(bytes);
6209 }
6210 }
6211
6212 unsafe impl<___D> ::fidl_next::Decode<___D> for VhtOperation
6213 where
6214 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6215 {
6216 fn decode(
6217 slot_: ::fidl_next::Slot<'_, Self>,
6218 decoder_: &mut ___D,
6219 _: (),
6220 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6221 ::fidl_next::munge! {
6222 let Self {
6223 mut bytes,
6224
6225 } = slot_;
6226 }
6227
6228 let _field = bytes.as_mut();
6229
6230 ::fidl_next::Decode::decode(bytes.as_mut(), decoder_, ())?;
6231
6232 Ok(())
6233 }
6234 }
6235
6236 impl ::fidl_next::IntoNatural for VhtOperation {
6237 type Natural = crate::natural::VhtOperation;
6238 }
6239
6240 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
6242 #[repr(transparent)]
6243 pub struct WlanAccessCategory {
6244 pub(crate) value: ::fidl_next::wire::Uint32,
6245 }
6246
6247 impl ::fidl_next::Constrained for WlanAccessCategory {
6248 type Constraint = ();
6249
6250 fn validate(
6251 _: ::fidl_next::Slot<'_, Self>,
6252 _: Self::Constraint,
6253 ) -> Result<(), ::fidl_next::ValidationError> {
6254 Ok(())
6255 }
6256 }
6257
6258 unsafe impl ::fidl_next::Wire for WlanAccessCategory {
6259 type Narrowed<'de> = Self;
6260
6261 #[inline]
6262 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
6263 }
6265 }
6266
6267 impl WlanAccessCategory {
6268 pub const BACKGROUND: WlanAccessCategory =
6269 WlanAccessCategory { value: ::fidl_next::wire::Uint32(1) };
6270
6271 pub const BEST_EFFORT: WlanAccessCategory =
6272 WlanAccessCategory { value: ::fidl_next::wire::Uint32(2) };
6273
6274 pub const VIDEO: WlanAccessCategory =
6275 WlanAccessCategory { value: ::fidl_next::wire::Uint32(3) };
6276
6277 pub const VOICE: WlanAccessCategory =
6278 WlanAccessCategory { value: ::fidl_next::wire::Uint32(4) };
6279 }
6280
6281 unsafe impl<___D> ::fidl_next::Decode<___D> for WlanAccessCategory
6282 where
6283 ___D: ?Sized,
6284 {
6285 fn decode(
6286 slot: ::fidl_next::Slot<'_, Self>,
6287 _: &mut ___D,
6288 _: (),
6289 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6290 ::fidl_next::munge!(let Self { value } = slot);
6291
6292 match u32::from(*value) {
6293 1 | 2 | 3 | 4 => (),
6294 unknown => {
6295 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
6296 }
6297 }
6298
6299 Ok(())
6300 }
6301 }
6302
6303 impl ::core::convert::From<crate::natural::WlanAccessCategory> for WlanAccessCategory {
6304 fn from(natural: crate::natural::WlanAccessCategory) -> Self {
6305 match natural {
6306 crate::natural::WlanAccessCategory::Background => WlanAccessCategory::BACKGROUND,
6307
6308 crate::natural::WlanAccessCategory::BestEffort => WlanAccessCategory::BEST_EFFORT,
6309
6310 crate::natural::WlanAccessCategory::Video => WlanAccessCategory::VIDEO,
6311
6312 crate::natural::WlanAccessCategory::Voice => WlanAccessCategory::VOICE,
6313 }
6314 }
6315 }
6316
6317 impl ::fidl_next::IntoNatural for WlanAccessCategory {
6318 type Natural = crate::natural::WlanAccessCategory;
6319 }
6320
6321 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
6323 #[repr(transparent)]
6324 pub struct WlanBand {
6325 pub(crate) value: u8,
6326 }
6327
6328 impl ::fidl_next::Constrained for WlanBand {
6329 type Constraint = ();
6330
6331 fn validate(
6332 _: ::fidl_next::Slot<'_, Self>,
6333 _: Self::Constraint,
6334 ) -> Result<(), ::fidl_next::ValidationError> {
6335 Ok(())
6336 }
6337 }
6338
6339 unsafe impl ::fidl_next::Wire for WlanBand {
6340 type Narrowed<'de> = Self;
6341
6342 #[inline]
6343 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
6344 }
6346 }
6347
6348 impl WlanBand {
6349 pub const TWO_GHZ: WlanBand = WlanBand { value: 0 };
6350
6351 pub const FIVE_GHZ: WlanBand = WlanBand { value: 1 };
6352 }
6353
6354 unsafe impl<___D> ::fidl_next::Decode<___D> for WlanBand
6355 where
6356 ___D: ?Sized,
6357 {
6358 fn decode(
6359 slot: ::fidl_next::Slot<'_, Self>,
6360 _: &mut ___D,
6361 _: (),
6362 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6363 Ok(())
6364 }
6365 }
6366
6367 impl ::core::convert::From<crate::natural::WlanBand> for WlanBand {
6368 fn from(natural: crate::natural::WlanBand) -> Self {
6369 match natural {
6370 crate::natural::WlanBand::TwoGhz => WlanBand::TWO_GHZ,
6371
6372 crate::natural::WlanBand::FiveGhz => WlanBand::FIVE_GHZ,
6373
6374 crate::natural::WlanBand::UnknownOrdinal_(value) => {
6375 WlanBand { value: u8::from(value) }
6376 }
6377 }
6378 }
6379 }
6380
6381 impl ::fidl_next::IntoNatural for WlanBand {
6382 type Natural = crate::natural::WlanBand;
6383 }
6384
6385 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
6387 #[repr(transparent)]
6388 pub struct WlanPhyType {
6389 pub(crate) value: ::fidl_next::wire::Uint32,
6390 }
6391
6392 impl ::fidl_next::Constrained for WlanPhyType {
6393 type Constraint = ();
6394
6395 fn validate(
6396 _: ::fidl_next::Slot<'_, Self>,
6397 _: Self::Constraint,
6398 ) -> Result<(), ::fidl_next::ValidationError> {
6399 Ok(())
6400 }
6401 }
6402
6403 unsafe impl ::fidl_next::Wire for WlanPhyType {
6404 type Narrowed<'de> = Self;
6405
6406 #[inline]
6407 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
6408 }
6410 }
6411
6412 impl WlanPhyType {
6413 pub const DSSS: WlanPhyType = WlanPhyType { value: ::fidl_next::wire::Uint32(1) };
6414
6415 pub const HR: WlanPhyType = WlanPhyType { value: ::fidl_next::wire::Uint32(2) };
6416
6417 pub const OFDM: WlanPhyType = WlanPhyType { value: ::fidl_next::wire::Uint32(3) };
6418
6419 pub const ERP: WlanPhyType = WlanPhyType { value: ::fidl_next::wire::Uint32(4) };
6420
6421 pub const HT: WlanPhyType = WlanPhyType { value: ::fidl_next::wire::Uint32(5) };
6422
6423 pub const DMG: WlanPhyType = WlanPhyType { value: ::fidl_next::wire::Uint32(6) };
6424
6425 pub const VHT: WlanPhyType = WlanPhyType { value: ::fidl_next::wire::Uint32(7) };
6426
6427 pub const TVHT: WlanPhyType = WlanPhyType { value: ::fidl_next::wire::Uint32(8) };
6428
6429 pub const S1_G: WlanPhyType = WlanPhyType { value: ::fidl_next::wire::Uint32(9) };
6430
6431 pub const CDMG: WlanPhyType = WlanPhyType { value: ::fidl_next::wire::Uint32(10) };
6432
6433 pub const CMMG: WlanPhyType = WlanPhyType { value: ::fidl_next::wire::Uint32(11) };
6434
6435 pub const HE: WlanPhyType = WlanPhyType { value: ::fidl_next::wire::Uint32(12) };
6436 }
6437
6438 unsafe impl<___D> ::fidl_next::Decode<___D> for WlanPhyType
6439 where
6440 ___D: ?Sized,
6441 {
6442 fn decode(
6443 slot: ::fidl_next::Slot<'_, Self>,
6444 _: &mut ___D,
6445 _: (),
6446 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6447 Ok(())
6448 }
6449 }
6450
6451 impl ::core::convert::From<crate::natural::WlanPhyType> for WlanPhyType {
6452 fn from(natural: crate::natural::WlanPhyType) -> Self {
6453 match natural {
6454 crate::natural::WlanPhyType::Dsss => WlanPhyType::DSSS,
6455
6456 crate::natural::WlanPhyType::Hr => WlanPhyType::HR,
6457
6458 crate::natural::WlanPhyType::Ofdm => WlanPhyType::OFDM,
6459
6460 crate::natural::WlanPhyType::Erp => WlanPhyType::ERP,
6461
6462 crate::natural::WlanPhyType::Ht => WlanPhyType::HT,
6463
6464 crate::natural::WlanPhyType::Dmg => WlanPhyType::DMG,
6465
6466 crate::natural::WlanPhyType::Vht => WlanPhyType::VHT,
6467
6468 crate::natural::WlanPhyType::Tvht => WlanPhyType::TVHT,
6469
6470 crate::natural::WlanPhyType::S1G => WlanPhyType::S1_G,
6471
6472 crate::natural::WlanPhyType::Cdmg => WlanPhyType::CDMG,
6473
6474 crate::natural::WlanPhyType::Cmmg => WlanPhyType::CMMG,
6475
6476 crate::natural::WlanPhyType::He => WlanPhyType::HE,
6477
6478 crate::natural::WlanPhyType::UnknownOrdinal_(value) => {
6479 WlanPhyType { value: ::fidl_next::wire::Uint32::from(value) }
6480 }
6481 }
6482 }
6483 }
6484
6485 impl ::fidl_next::IntoNatural for WlanPhyType {
6486 type Natural = crate::natural::WlanPhyType;
6487 }
6488}
6489
6490pub mod wire_optional {}
6491
6492pub mod generic {
6493
6494 pub struct WlanChannel<T0, T1, T2> {
6496 pub primary: T0,
6497
6498 pub cbw: T1,
6499
6500 pub secondary80: T2,
6501 }
6502
6503 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::WlanChannel, ___E>
6504 for WlanChannel<T0, T1, T2>
6505 where
6506 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6507 T0: ::fidl_next::Encode<u8, ___E>,
6508 T1: ::fidl_next::Encode<crate::wire::ChannelBandwidth, ___E>,
6509 T2: ::fidl_next::Encode<u8, ___E>,
6510 {
6511 #[inline]
6512 fn encode(
6513 self,
6514 encoder_: &mut ___E,
6515 out_: &mut ::core::mem::MaybeUninit<crate::wire::WlanChannel>,
6516 _: (),
6517 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6518 ::fidl_next::munge! {
6519 let crate::wire::WlanChannel {
6520 primary,
6521 cbw,
6522 secondary80,
6523
6524 } = out_;
6525 }
6526
6527 ::fidl_next::Encode::encode(self.primary, encoder_, primary, ())?;
6528
6529 ::fidl_next::Encode::encode(self.cbw, encoder_, cbw, ())?;
6530
6531 ::fidl_next::Encode::encode(self.secondary80, encoder_, secondary80, ())?;
6532
6533 Ok(())
6534 }
6535 }
6536
6537 pub struct BssDescription<T0, T1, T2, T3, T4, T5, T6, T7> {
6539 pub bssid: T0,
6540
6541 pub bss_type: T1,
6542
6543 pub beacon_period: T2,
6544
6545 pub capability_info: T3,
6546
6547 pub ies: T4,
6548
6549 pub channel: T5,
6550
6551 pub rssi_dbm: T6,
6552
6553 pub snr_db: T7,
6554 }
6555
6556 unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6, T7>
6557 ::fidl_next::Encode<crate::wire::BssDescription<'static>, ___E>
6558 for BssDescription<T0, T1, T2, T3, T4, T5, T6, T7>
6559 where
6560 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6561 ___E: ::fidl_next::Encoder,
6562 T0: ::fidl_next::Encode<[u8; 6], ___E>,
6563 T1: ::fidl_next::Encode<crate::wire::BssType, ___E>,
6564 T2: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
6565 T3: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
6566 T4: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
6567 T5: ::fidl_next::Encode<crate::wire::WlanChannel, ___E>,
6568 T6: ::fidl_next::Encode<i8, ___E>,
6569 T7: ::fidl_next::Encode<i8, ___E>,
6570 {
6571 #[inline]
6572 fn encode(
6573 self,
6574 encoder_: &mut ___E,
6575 out_: &mut ::core::mem::MaybeUninit<crate::wire::BssDescription<'static>>,
6576 _: (),
6577 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6578 ::fidl_next::munge! {
6579 let crate::wire::BssDescription {
6580 bssid,
6581 bss_type,
6582 beacon_period,
6583 capability_info,
6584 ies,
6585 channel,
6586 rssi_dbm,
6587 snr_db,
6588
6589 } = out_;
6590 }
6591
6592 ::fidl_next::Encode::encode(self.bssid, encoder_, bssid, ())?;
6593
6594 ::fidl_next::Encode::encode(self.bss_type, encoder_, bss_type, ())?;
6595
6596 ::fidl_next::Encode::encode(self.beacon_period, encoder_, beacon_period, ())?;
6597
6598 ::fidl_next::Encode::encode(self.capability_info, encoder_, capability_info, ())?;
6599
6600 ::fidl_next::Encode::encode(self.ies, encoder_, ies, (4294967295, ()))?;
6601
6602 ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
6603
6604 ::fidl_next::Encode::encode(self.rssi_dbm, encoder_, rssi_dbm, ())?;
6605
6606 ::fidl_next::Encode::encode(self.snr_db, encoder_, snr_db, ())?;
6607
6608 Ok(())
6609 }
6610 }
6611
6612 pub struct CSsid<T0, T1> {
6614 pub len: T0,
6615
6616 pub data: T1,
6617 }
6618
6619 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::CSsid, ___E> for CSsid<T0, T1>
6620 where
6621 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6622 T0: ::fidl_next::Encode<u8, ___E>,
6623 T1: ::fidl_next::Encode<[u8; 32], ___E>,
6624 {
6625 #[inline]
6626 fn encode(
6627 self,
6628 encoder_: &mut ___E,
6629 out_: &mut ::core::mem::MaybeUninit<crate::wire::CSsid>,
6630 _: (),
6631 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6632 ::fidl_next::munge! {
6633 let crate::wire::CSsid {
6634 len,
6635 data,
6636
6637 } = out_;
6638 }
6639
6640 ::fidl_next::Encode::encode(self.len, encoder_, len, ())?;
6641
6642 ::fidl_next::Encode::encode(self.data, encoder_, data, ())?;
6643
6644 Ok(())
6645 }
6646 }
6647
6648 pub struct HtCapabilities<T0> {
6650 pub bytes: T0,
6651 }
6652
6653 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::HtCapabilities, ___E> for HtCapabilities<T0>
6654 where
6655 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6656 T0: ::fidl_next::Encode<[u8; 26], ___E>,
6657 {
6658 #[inline]
6659 fn encode(
6660 self,
6661 encoder_: &mut ___E,
6662 out_: &mut ::core::mem::MaybeUninit<crate::wire::HtCapabilities>,
6663 _: (),
6664 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6665 ::fidl_next::munge! {
6666 let crate::wire::HtCapabilities {
6667 bytes,
6668
6669 } = out_;
6670 }
6671
6672 ::fidl_next::Encode::encode(self.bytes, encoder_, bytes, ())?;
6673
6674 Ok(())
6675 }
6676 }
6677
6678 pub struct HtOperation<T0> {
6680 pub bytes: T0,
6681 }
6682
6683 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::HtOperation, ___E> for HtOperation<T0>
6684 where
6685 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6686 T0: ::fidl_next::Encode<[u8; 22], ___E>,
6687 {
6688 #[inline]
6689 fn encode(
6690 self,
6691 encoder_: &mut ___E,
6692 out_: &mut ::core::mem::MaybeUninit<crate::wire::HtOperation>,
6693 _: (),
6694 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6695 ::fidl_next::munge! {
6696 let crate::wire::HtOperation {
6697 bytes,
6698
6699 } = out_;
6700 }
6701
6702 ::fidl_next::Encode::encode(self.bytes, encoder_, bytes, ())?;
6703
6704 Ok(())
6705 }
6706 }
6707
6708 pub struct VhtCapabilities<T0> {
6710 pub bytes: T0,
6711 }
6712
6713 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::VhtCapabilities, ___E>
6714 for VhtCapabilities<T0>
6715 where
6716 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6717 T0: ::fidl_next::Encode<[u8; 12], ___E>,
6718 {
6719 #[inline]
6720 fn encode(
6721 self,
6722 encoder_: &mut ___E,
6723 out_: &mut ::core::mem::MaybeUninit<crate::wire::VhtCapabilities>,
6724 _: (),
6725 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6726 ::fidl_next::munge! {
6727 let crate::wire::VhtCapabilities {
6728 bytes,
6729
6730 } = out_;
6731 }
6732
6733 ::fidl_next::Encode::encode(self.bytes, encoder_, bytes, ())?;
6734
6735 Ok(())
6736 }
6737 }
6738
6739 pub struct VhtOperation<T0> {
6741 pub bytes: T0,
6742 }
6743
6744 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::VhtOperation, ___E> for VhtOperation<T0>
6745 where
6746 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6747 T0: ::fidl_next::Encode<[u8; 5], ___E>,
6748 {
6749 #[inline]
6750 fn encode(
6751 self,
6752 encoder_: &mut ___E,
6753 out_: &mut ::core::mem::MaybeUninit<crate::wire::VhtOperation>,
6754 _: (),
6755 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6756 ::fidl_next::munge! {
6757 let crate::wire::VhtOperation {
6758 bytes,
6759
6760 } = out_;
6761 }
6762
6763 ::fidl_next::Encode::encode(self.bytes, encoder_, bytes, ())?;
6764
6765 Ok(())
6766 }
6767 }
6768}
6769
6770pub use self::natural::*;
6771
6772pub const MAC_ADDR_LEN: u8 = 6 as u8;
6773
6774pub const CCMP_128_MIC_LEN: u32 = 8 as u32;
6775
6776pub const CCMP_256_MIC_LEN: u32 = 16 as u32;
6777
6778#[doc = " IEEE Std 802.11-2016 12.5.3.2\n"]
6779pub const CCMP_HDR_LEN: u32 = 8 as u32;
6780
6781pub const CCMP_PN_LEN: u32 = 6 as u32;
6782
6783#[doc = " IEEE Std 802.11-2016, 9.4.2.2\n The maximum length of an SSID is 32 bytes, even when the SSID should be\n interpreted using UTF-8 encoding (see Table 9-135). While every length in\n the 802.11 standard is byte oriented, the word BYTE is included in the\n name of this constant to emphasize the importance that it not be applied\n to the length of a UTF-8 encoded string.\n"]
6784pub const MAX_SSID_BYTE_LEN: u8 = 32 as u8;
6785
6786pub const HT_CAP_LEN: u8 = 26 as u8;
6787
6788pub const HT_OP_LEN: u8 = 22 as u8;
6789
6790pub const MAX_KEY_LEN: u8 = 32 as u8;
6791
6792#[doc = " IEEE Std 802.11-2016, 9.4.2.99\n"]
6793pub const MAX_MESH_ID_BYTE_LEN: u8 = 32 as u8;
6794
6795#[doc = " IEEE Std 802.11-2016, 9.3.3.2\n"]
6796pub const MAX_MGMT_FRAME_MAC_HEADER_BYTE_LEN: u8 = 28 as u8;
6797
6798#[doc = " IEEE Std 802.11-2016, 9.2.4.7\n"]
6799pub const MAX_MMPDU_BYTE_LEN: u16 = 2304 as u16;
6800
6801pub const MAX_SUPPORTED_BASIC_RATES: u8 = 12 as u8;
6802
6803#[doc = " The limit on the number of channels in a list of unique channel numbers is 256\n since a channel number in IEEE 802.11-2016 cannot exceed one octet. See\n IEEE 802.11-2016 9.4.2.18 Supported Channels element for an example element\n that assumes a channel number does not exceed one octet.\n"]
6804pub const MAX_UNIQUE_CHANNEL_NUMBERS: u16 = 256 as u16;
6805
6806pub const MAX_VHT_MPDU_BYTE_LEN_0: u16 = 3895 as u16;
6807
6808pub const MAX_VHT_MPDU_BYTE_LEN_1: u16 = 7991 as u16;
6809
6810pub const MAX_VHT_MPDU_BYTE_LEN_2: u16 = 11454 as u16;
6811
6812pub const OUI_LEN: u8 = 3 as u8;
6813
6814#[doc = " The limit on the number of SSIDs is 84 because an SSID List IE can contain no\n more than 84 one byte SSIDs. (Specifying a zero byte SSID in an SSID List with\n more than one SSID is valid but unnecessary since it is the wildcard SSID.)\n"]
6815pub const SSID_LIST_MAX: u8 = 84 as u8;
6816
6817#[doc = " IEEE Std 802.11-2016, 9.2.4.5\n"]
6818pub const TIDS_MAX: u32 = 16 as u32;
6819
6820pub const VHT_CAP_LEN: u8 = 12 as u8;
6821
6822pub const VHT_OP_LEN: u8 = 5 as u8;
6823
6824pub const WLAN_IE_BODY_MAX_LEN: u32 = 255 as u32;
6825
6826#[doc = " IEEE Std 802.11-2016, 9.4.2.25.1\n IEEE mentions that an element body maximum length is 255 octets in the RSN element\n section, but not in a dedicated section.\n Since the IE header is two octets, the whole IE max length is 257 octets.\n"]
6827pub const WLAN_IE_MAX_LEN: u32 = 257 as u32;
6828
6829#[doc = " IEEE Std 802.11-2016, Table 9-19\n"]
6830pub const WLAN_MSDU_MAX_LEN: u32 = 2304 as u32;