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