fidl_fuchsia_wlan_device_service__common/
fidl_fuchsia_wlan_device_service__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
12pub enum DeviceMonitorError {
13    #[doc(hidden)]
14    __SourceBreaking { unknown_ordinal: u32 },
15}
16
17/// Pattern that matches an unknown `DeviceMonitorError` member.
18#[macro_export]
19macro_rules! DeviceMonitorErrorUnknown {
20    () => {
21        _
22    };
23}
24
25impl DeviceMonitorError {
26    #[inline]
27    pub fn from_primitive(prim: u32) -> Option<Self> {
28        match prim {
29            _ => None,
30        }
31    }
32
33    #[inline]
34    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
35        match prim {
36            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
37        }
38    }
39
40    #[inline]
41    pub fn unknown() -> Self {
42        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
43    }
44
45    #[inline]
46    pub const fn into_primitive(self) -> u32 {
47        match self {
48            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
49        }
50    }
51
52    #[inline]
53    pub fn is_unknown(&self) -> bool {
54        match self {
55            Self::__SourceBreaking { unknown_ordinal: _ } => true,
56        }
57    }
58}
59
60#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
61#[repr(C)]
62pub struct ClearCountryRequest {
63    pub phy_id: u16,
64}
65
66impl fidl::Persistable for ClearCountryRequest {}
67
68#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
69#[repr(C)]
70pub struct DestroyIfaceRequest {
71    pub iface_id: u16,
72}
73
74impl fidl::Persistable for DestroyIfaceRequest {}
75
76#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
77#[repr(C)]
78pub struct DeviceMonitorClearCountryRequest {
79    pub req: ClearCountryRequest,
80}
81
82impl fidl::Persistable for DeviceMonitorClearCountryRequest {}
83
84#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
85#[repr(C)]
86pub struct DeviceMonitorClearCountryResponse {
87    pub status: i32,
88}
89
90impl fidl::Persistable for DeviceMonitorClearCountryResponse {}
91
92#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
93#[repr(C)]
94pub struct DeviceMonitorDestroyIfaceRequest {
95    pub req: DestroyIfaceRequest,
96}
97
98impl fidl::Persistable for DeviceMonitorDestroyIfaceRequest {}
99
100#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
101#[repr(C)]
102pub struct DeviceMonitorDestroyIfaceResponse {
103    pub status: i32,
104}
105
106impl fidl::Persistable for DeviceMonitorDestroyIfaceResponse {}
107
108#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
109#[repr(C)]
110pub struct DeviceMonitorGetCountryRequest {
111    pub phy_id: u16,
112}
113
114impl fidl::Persistable for DeviceMonitorGetCountryRequest {}
115
116#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
117#[repr(C)]
118pub struct DeviceMonitorGetDevPathRequest {
119    pub phy_id: u16,
120}
121
122impl fidl::Persistable for DeviceMonitorGetDevPathRequest {}
123
124#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
125pub struct DeviceMonitorGetDevPathResponse {
126    pub dev_path: Option<String>,
127}
128
129impl fidl::Persistable for DeviceMonitorGetDevPathResponse {}
130
131#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
132#[repr(C)]
133pub struct DeviceMonitorGetPowerSaveModeRequest {
134    pub phy_id: u16,
135}
136
137impl fidl::Persistable for DeviceMonitorGetPowerSaveModeRequest {}
138
139#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
140#[repr(C)]
141pub struct DeviceMonitorGetSupportedMacRolesRequest {
142    pub phy_id: u16,
143}
144
145impl fidl::Persistable for DeviceMonitorGetSupportedMacRolesRequest {}
146
147#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
148pub struct DeviceMonitorListIfacesResponse {
149    pub iface_list: Vec<u16>,
150}
151
152impl fidl::Persistable for DeviceMonitorListIfacesResponse {}
153
154#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
155pub struct DeviceMonitorListPhysResponse {
156    pub phy_list: Vec<u16>,
157}
158
159impl fidl::Persistable for DeviceMonitorListPhysResponse {}
160
161#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
162#[repr(C)]
163pub struct DeviceMonitorQueryIfaceRequest {
164    pub iface_id: u16,
165}
166
167impl fidl::Persistable for DeviceMonitorQueryIfaceRequest {}
168
169#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
170#[repr(C)]
171pub struct DeviceMonitorSetCountryRequest {
172    pub req: SetCountryRequest,
173}
174
175impl fidl::Persistable for DeviceMonitorSetCountryRequest {}
176
177#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
178#[repr(C)]
179pub struct DeviceMonitorSetCountryResponse {
180    pub status: i32,
181}
182
183impl fidl::Persistable for DeviceMonitorSetCountryResponse {}
184
185#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
186pub struct DeviceMonitorSetPowerSaveModeRequest {
187    pub req: SetPowerSaveModeRequest,
188}
189
190impl fidl::Persistable for DeviceMonitorSetPowerSaveModeRequest {}
191
192#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
193#[repr(C)]
194pub struct DeviceMonitorSetPowerSaveModeResponse {
195    pub status: i32,
196}
197
198impl fidl::Persistable for DeviceMonitorSetPowerSaveModeResponse {}
199
200#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
201#[repr(C)]
202pub struct DeviceMonitorGetCountryResponse {
203    pub resp: GetCountryResponse,
204}
205
206impl fidl::Persistable for DeviceMonitorGetCountryResponse {}
207
208#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
209pub struct DeviceMonitorGetPowerSaveModeResponse {
210    pub resp: GetPowerSaveModeResponse,
211}
212
213impl fidl::Persistable for DeviceMonitorGetPowerSaveModeResponse {}
214
215#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
216pub struct DeviceMonitorGetSupportedMacRolesResponse {
217    pub supported_mac_roles: Vec<fidl_fuchsia_wlan_common__common::WlanMacRole>,
218}
219
220impl fidl::Persistable for DeviceMonitorGetSupportedMacRolesResponse {}
221
222#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
223pub struct DeviceMonitorQueryIfaceResponse {
224    pub resp: QueryIfaceResponse,
225}
226
227impl fidl::Persistable for DeviceMonitorQueryIfaceResponse {}
228
229#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
230#[repr(C)]
231pub struct DeviceWatcherOnIfaceAddedRequest {
232    pub iface_id: u16,
233}
234
235impl fidl::Persistable for DeviceWatcherOnIfaceAddedRequest {}
236
237#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
238#[repr(C)]
239pub struct DeviceWatcherOnIfaceRemovedRequest {
240    pub iface_id: u16,
241}
242
243impl fidl::Persistable for DeviceWatcherOnIfaceRemovedRequest {}
244
245#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
246#[repr(C)]
247pub struct DeviceWatcherOnPhyAddedRequest {
248    pub phy_id: u16,
249}
250
251impl fidl::Persistable for DeviceWatcherOnPhyAddedRequest {}
252
253#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
254#[repr(C)]
255pub struct DeviceWatcherOnPhyRemovedRequest {
256    pub phy_id: u16,
257}
258
259impl fidl::Persistable for DeviceWatcherOnPhyRemovedRequest {}
260
261#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
262#[repr(C)]
263pub struct GetCountryResponse {
264    pub alpha2: [u8; 2],
265}
266
267impl fidl::Persistable for GetCountryResponse {}
268
269#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
270pub struct GetPowerSaveModeResponse {
271    /// Power Save Mode bit mask
272    pub ps_mode: fidl_fuchsia_wlan_common__common::PowerSaveType,
273}
274
275impl fidl::Persistable for GetPowerSaveModeResponse {}
276
277#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
278pub struct QueryIfaceResponse {
279    /// The role the iface is currently operating in, e.g., client role.
280    pub role: fidl_fuchsia_wlan_common__common::WlanMacRole,
281    /// The iface's global ID.
282    pub id: u16,
283    /// Iface's PHY ID.
284    pub phy_id: u16,
285    /// Local ID assigned by this iface's PHY.
286    pub phy_assigned_id: u16,
287    /// The iface's MAC.
288    pub sta_addr: [u8; 6],
289}
290
291impl fidl::Persistable for QueryIfaceResponse {}
292
293#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
294#[repr(C)]
295pub struct SetCountryRequest {
296    pub phy_id: u16,
297    pub alpha2: [u8; 2],
298}
299
300impl fidl::Persistable for SetCountryRequest {}
301
302#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
303pub struct SetPowerSaveModeRequest {
304    /// Interface's PHY ID
305    pub phy_id: u16,
306    /// Power Save Mode bit mask
307    pub ps_mode: fidl_fuchsia_wlan_common__common::PowerSaveType,
308}
309
310impl fidl::Persistable for SetPowerSaveModeRequest {}
311
312#[derive(Clone, Debug, Default, PartialEq)]
313pub struct DeviceMonitorCreateIfaceRequest {
314    pub phy_id: Option<u16>,
315    pub role: Option<fidl_fuchsia_wlan_common__common::WlanMacRole>,
316    pub sta_address: Option<[u8; 6]>,
317    #[doc(hidden)]
318    pub __source_breaking: fidl::marker::SourceBreaking,
319}
320
321impl fidl::Persistable for DeviceMonitorCreateIfaceRequest {}
322
323#[derive(Clone, Debug, Default, PartialEq)]
324pub struct DeviceMonitorCreateIfaceResponse {
325    pub iface_id: Option<u16>,
326    #[doc(hidden)]
327    pub __source_breaking: fidl::marker::SourceBreaking,
328}
329
330impl fidl::Persistable for DeviceMonitorCreateIfaceResponse {}
331
332#[derive(Clone, Debug, PartialEq)]
333pub enum GetIfaceHistogramStatsResponse {
334    Stats(fidl_fuchsia_wlan_stats__common::IfaceHistogramStats),
335    ErrorStatus(i32),
336}
337
338impl GetIfaceHistogramStatsResponse {
339    #[inline]
340    pub fn ordinal(&self) -> u64 {
341        match *self {
342            Self::Stats(_) => 1,
343            Self::ErrorStatus(_) => 2,
344        }
345    }
346}
347
348impl fidl::Persistable for GetIfaceHistogramStatsResponse {}
349
350mod internal {
351    use super::*;
352    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorError {
353        type Owned = Self;
354
355        #[inline(always)]
356        fn inline_align(_context: fidl::encoding::Context) -> usize {
357            std::mem::align_of::<u32>()
358        }
359
360        #[inline(always)]
361        fn inline_size(_context: fidl::encoding::Context) -> usize {
362            std::mem::size_of::<u32>()
363        }
364
365        #[inline(always)]
366        fn encode_is_copy() -> bool {
367            false
368        }
369
370        #[inline(always)]
371        fn decode_is_copy() -> bool {
372            false
373        }
374    }
375
376    impl fidl::encoding::ValueTypeMarker for DeviceMonitorError {
377        type Borrowed<'a> = Self;
378        #[inline(always)]
379        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
380            *value
381        }
382    }
383
384    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
385        for DeviceMonitorError
386    {
387        #[inline]
388        unsafe fn encode(
389            self,
390            encoder: &mut fidl::encoding::Encoder<'_, D>,
391            offset: usize,
392            _depth: fidl::encoding::Depth,
393        ) -> fidl::Result<()> {
394            encoder.debug_check_bounds::<Self>(offset);
395            encoder.write_num(self.into_primitive(), offset);
396            Ok(())
397        }
398    }
399
400    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceMonitorError {
401        #[inline(always)]
402        fn new_empty() -> Self {
403            Self::unknown()
404        }
405
406        #[inline]
407        unsafe fn decode(
408            &mut self,
409            decoder: &mut fidl::encoding::Decoder<'_, D>,
410            offset: usize,
411            _depth: fidl::encoding::Depth,
412        ) -> fidl::Result<()> {
413            decoder.debug_check_bounds::<Self>(offset);
414            let prim = decoder.read_num::<u32>(offset);
415
416            *self = Self::from_primitive_allow_unknown(prim);
417            Ok(())
418        }
419    }
420
421    impl fidl::encoding::ValueTypeMarker for ClearCountryRequest {
422        type Borrowed<'a> = &'a Self;
423        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
424            value
425        }
426    }
427
428    unsafe impl fidl::encoding::TypeMarker for ClearCountryRequest {
429        type Owned = Self;
430
431        #[inline(always)]
432        fn inline_align(_context: fidl::encoding::Context) -> usize {
433            2
434        }
435
436        #[inline(always)]
437        fn inline_size(_context: fidl::encoding::Context) -> usize {
438            2
439        }
440        #[inline(always)]
441        fn encode_is_copy() -> bool {
442            true
443        }
444
445        #[inline(always)]
446        fn decode_is_copy() -> bool {
447            true
448        }
449    }
450
451    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ClearCountryRequest, D>
452        for &ClearCountryRequest
453    {
454        #[inline]
455        unsafe fn encode(
456            self,
457            encoder: &mut fidl::encoding::Encoder<'_, D>,
458            offset: usize,
459            _depth: fidl::encoding::Depth,
460        ) -> fidl::Result<()> {
461            encoder.debug_check_bounds::<ClearCountryRequest>(offset);
462            unsafe {
463                // Copy the object into the buffer.
464                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
465                (buf_ptr as *mut ClearCountryRequest)
466                    .write_unaligned((self as *const ClearCountryRequest).read());
467                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
468                // done second because the memcpy will write garbage to these bytes.
469            }
470            Ok(())
471        }
472    }
473    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
474        fidl::encoding::Encode<ClearCountryRequest, D> for (T0,)
475    {
476        #[inline]
477        unsafe fn encode(
478            self,
479            encoder: &mut fidl::encoding::Encoder<'_, D>,
480            offset: usize,
481            depth: fidl::encoding::Depth,
482        ) -> fidl::Result<()> {
483            encoder.debug_check_bounds::<ClearCountryRequest>(offset);
484            // Zero out padding regions. There's no need to apply masks
485            // because the unmasked parts will be overwritten by fields.
486            // Write the fields.
487            self.0.encode(encoder, offset + 0, depth)?;
488            Ok(())
489        }
490    }
491
492    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ClearCountryRequest {
493        #[inline(always)]
494        fn new_empty() -> Self {
495            Self { phy_id: fidl::new_empty!(u16, D) }
496        }
497
498        #[inline]
499        unsafe fn decode(
500            &mut self,
501            decoder: &mut fidl::encoding::Decoder<'_, D>,
502            offset: usize,
503            _depth: fidl::encoding::Depth,
504        ) -> fidl::Result<()> {
505            decoder.debug_check_bounds::<Self>(offset);
506            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
507            // Verify that padding bytes are zero.
508            // Copy from the buffer into the object.
509            unsafe {
510                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
511            }
512            Ok(())
513        }
514    }
515
516    impl fidl::encoding::ValueTypeMarker for DestroyIfaceRequest {
517        type Borrowed<'a> = &'a Self;
518        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
519            value
520        }
521    }
522
523    unsafe impl fidl::encoding::TypeMarker for DestroyIfaceRequest {
524        type Owned = Self;
525
526        #[inline(always)]
527        fn inline_align(_context: fidl::encoding::Context) -> usize {
528            2
529        }
530
531        #[inline(always)]
532        fn inline_size(_context: fidl::encoding::Context) -> usize {
533            2
534        }
535        #[inline(always)]
536        fn encode_is_copy() -> bool {
537            true
538        }
539
540        #[inline(always)]
541        fn decode_is_copy() -> bool {
542            true
543        }
544    }
545
546    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DestroyIfaceRequest, D>
547        for &DestroyIfaceRequest
548    {
549        #[inline]
550        unsafe fn encode(
551            self,
552            encoder: &mut fidl::encoding::Encoder<'_, D>,
553            offset: usize,
554            _depth: fidl::encoding::Depth,
555        ) -> fidl::Result<()> {
556            encoder.debug_check_bounds::<DestroyIfaceRequest>(offset);
557            unsafe {
558                // Copy the object into the buffer.
559                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
560                (buf_ptr as *mut DestroyIfaceRequest)
561                    .write_unaligned((self as *const DestroyIfaceRequest).read());
562                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
563                // done second because the memcpy will write garbage to these bytes.
564            }
565            Ok(())
566        }
567    }
568    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
569        fidl::encoding::Encode<DestroyIfaceRequest, D> for (T0,)
570    {
571        #[inline]
572        unsafe fn encode(
573            self,
574            encoder: &mut fidl::encoding::Encoder<'_, D>,
575            offset: usize,
576            depth: fidl::encoding::Depth,
577        ) -> fidl::Result<()> {
578            encoder.debug_check_bounds::<DestroyIfaceRequest>(offset);
579            // Zero out padding regions. There's no need to apply masks
580            // because the unmasked parts will be overwritten by fields.
581            // Write the fields.
582            self.0.encode(encoder, offset + 0, depth)?;
583            Ok(())
584        }
585    }
586
587    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DestroyIfaceRequest {
588        #[inline(always)]
589        fn new_empty() -> Self {
590            Self { iface_id: fidl::new_empty!(u16, D) }
591        }
592
593        #[inline]
594        unsafe fn decode(
595            &mut self,
596            decoder: &mut fidl::encoding::Decoder<'_, D>,
597            offset: usize,
598            _depth: fidl::encoding::Depth,
599        ) -> fidl::Result<()> {
600            decoder.debug_check_bounds::<Self>(offset);
601            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
602            // Verify that padding bytes are zero.
603            // Copy from the buffer into the object.
604            unsafe {
605                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
606            }
607            Ok(())
608        }
609    }
610
611    impl fidl::encoding::ValueTypeMarker for DeviceMonitorClearCountryRequest {
612        type Borrowed<'a> = &'a Self;
613        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
614            value
615        }
616    }
617
618    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorClearCountryRequest {
619        type Owned = Self;
620
621        #[inline(always)]
622        fn inline_align(_context: fidl::encoding::Context) -> usize {
623            2
624        }
625
626        #[inline(always)]
627        fn inline_size(_context: fidl::encoding::Context) -> usize {
628            2
629        }
630        #[inline(always)]
631        fn encode_is_copy() -> bool {
632            true
633        }
634
635        #[inline(always)]
636        fn decode_is_copy() -> bool {
637            true
638        }
639    }
640
641    unsafe impl<D: fidl::encoding::ResourceDialect>
642        fidl::encoding::Encode<DeviceMonitorClearCountryRequest, D>
643        for &DeviceMonitorClearCountryRequest
644    {
645        #[inline]
646        unsafe fn encode(
647            self,
648            encoder: &mut fidl::encoding::Encoder<'_, D>,
649            offset: usize,
650            _depth: fidl::encoding::Depth,
651        ) -> fidl::Result<()> {
652            encoder.debug_check_bounds::<DeviceMonitorClearCountryRequest>(offset);
653            unsafe {
654                // Copy the object into the buffer.
655                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
656                (buf_ptr as *mut DeviceMonitorClearCountryRequest)
657                    .write_unaligned((self as *const DeviceMonitorClearCountryRequest).read());
658                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
659                // done second because the memcpy will write garbage to these bytes.
660            }
661            Ok(())
662        }
663    }
664    unsafe impl<
665            D: fidl::encoding::ResourceDialect,
666            T0: fidl::encoding::Encode<ClearCountryRequest, D>,
667        > fidl::encoding::Encode<DeviceMonitorClearCountryRequest, D> for (T0,)
668    {
669        #[inline]
670        unsafe fn encode(
671            self,
672            encoder: &mut fidl::encoding::Encoder<'_, D>,
673            offset: usize,
674            depth: fidl::encoding::Depth,
675        ) -> fidl::Result<()> {
676            encoder.debug_check_bounds::<DeviceMonitorClearCountryRequest>(offset);
677            // Zero out padding regions. There's no need to apply masks
678            // because the unmasked parts will be overwritten by fields.
679            // Write the fields.
680            self.0.encode(encoder, offset + 0, depth)?;
681            Ok(())
682        }
683    }
684
685    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
686        for DeviceMonitorClearCountryRequest
687    {
688        #[inline(always)]
689        fn new_empty() -> Self {
690            Self { req: fidl::new_empty!(ClearCountryRequest, D) }
691        }
692
693        #[inline]
694        unsafe fn decode(
695            &mut self,
696            decoder: &mut fidl::encoding::Decoder<'_, D>,
697            offset: usize,
698            _depth: fidl::encoding::Depth,
699        ) -> fidl::Result<()> {
700            decoder.debug_check_bounds::<Self>(offset);
701            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
702            // Verify that padding bytes are zero.
703            // Copy from the buffer into the object.
704            unsafe {
705                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
706            }
707            Ok(())
708        }
709    }
710
711    impl fidl::encoding::ValueTypeMarker for DeviceMonitorClearCountryResponse {
712        type Borrowed<'a> = &'a Self;
713        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
714            value
715        }
716    }
717
718    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorClearCountryResponse {
719        type Owned = Self;
720
721        #[inline(always)]
722        fn inline_align(_context: fidl::encoding::Context) -> usize {
723            4
724        }
725
726        #[inline(always)]
727        fn inline_size(_context: fidl::encoding::Context) -> usize {
728            4
729        }
730        #[inline(always)]
731        fn encode_is_copy() -> bool {
732            true
733        }
734
735        #[inline(always)]
736        fn decode_is_copy() -> bool {
737            true
738        }
739    }
740
741    unsafe impl<D: fidl::encoding::ResourceDialect>
742        fidl::encoding::Encode<DeviceMonitorClearCountryResponse, D>
743        for &DeviceMonitorClearCountryResponse
744    {
745        #[inline]
746        unsafe fn encode(
747            self,
748            encoder: &mut fidl::encoding::Encoder<'_, D>,
749            offset: usize,
750            _depth: fidl::encoding::Depth,
751        ) -> fidl::Result<()> {
752            encoder.debug_check_bounds::<DeviceMonitorClearCountryResponse>(offset);
753            unsafe {
754                // Copy the object into the buffer.
755                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
756                (buf_ptr as *mut DeviceMonitorClearCountryResponse)
757                    .write_unaligned((self as *const DeviceMonitorClearCountryResponse).read());
758                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
759                // done second because the memcpy will write garbage to these bytes.
760            }
761            Ok(())
762        }
763    }
764    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
765        fidl::encoding::Encode<DeviceMonitorClearCountryResponse, D> for (T0,)
766    {
767        #[inline]
768        unsafe fn encode(
769            self,
770            encoder: &mut fidl::encoding::Encoder<'_, D>,
771            offset: usize,
772            depth: fidl::encoding::Depth,
773        ) -> fidl::Result<()> {
774            encoder.debug_check_bounds::<DeviceMonitorClearCountryResponse>(offset);
775            // Zero out padding regions. There's no need to apply masks
776            // because the unmasked parts will be overwritten by fields.
777            // Write the fields.
778            self.0.encode(encoder, offset + 0, depth)?;
779            Ok(())
780        }
781    }
782
783    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
784        for DeviceMonitorClearCountryResponse
785    {
786        #[inline(always)]
787        fn new_empty() -> Self {
788            Self { status: fidl::new_empty!(i32, D) }
789        }
790
791        #[inline]
792        unsafe fn decode(
793            &mut self,
794            decoder: &mut fidl::encoding::Decoder<'_, D>,
795            offset: usize,
796            _depth: fidl::encoding::Depth,
797        ) -> fidl::Result<()> {
798            decoder.debug_check_bounds::<Self>(offset);
799            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
800            // Verify that padding bytes are zero.
801            // Copy from the buffer into the object.
802            unsafe {
803                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
804            }
805            Ok(())
806        }
807    }
808
809    impl fidl::encoding::ValueTypeMarker for DeviceMonitorDestroyIfaceRequest {
810        type Borrowed<'a> = &'a Self;
811        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
812            value
813        }
814    }
815
816    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorDestroyIfaceRequest {
817        type Owned = Self;
818
819        #[inline(always)]
820        fn inline_align(_context: fidl::encoding::Context) -> usize {
821            2
822        }
823
824        #[inline(always)]
825        fn inline_size(_context: fidl::encoding::Context) -> usize {
826            2
827        }
828        #[inline(always)]
829        fn encode_is_copy() -> bool {
830            true
831        }
832
833        #[inline(always)]
834        fn decode_is_copy() -> bool {
835            true
836        }
837    }
838
839    unsafe impl<D: fidl::encoding::ResourceDialect>
840        fidl::encoding::Encode<DeviceMonitorDestroyIfaceRequest, D>
841        for &DeviceMonitorDestroyIfaceRequest
842    {
843        #[inline]
844        unsafe fn encode(
845            self,
846            encoder: &mut fidl::encoding::Encoder<'_, D>,
847            offset: usize,
848            _depth: fidl::encoding::Depth,
849        ) -> fidl::Result<()> {
850            encoder.debug_check_bounds::<DeviceMonitorDestroyIfaceRequest>(offset);
851            unsafe {
852                // Copy the object into the buffer.
853                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
854                (buf_ptr as *mut DeviceMonitorDestroyIfaceRequest)
855                    .write_unaligned((self as *const DeviceMonitorDestroyIfaceRequest).read());
856                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
857                // done second because the memcpy will write garbage to these bytes.
858            }
859            Ok(())
860        }
861    }
862    unsafe impl<
863            D: fidl::encoding::ResourceDialect,
864            T0: fidl::encoding::Encode<DestroyIfaceRequest, D>,
865        > fidl::encoding::Encode<DeviceMonitorDestroyIfaceRequest, D> for (T0,)
866    {
867        #[inline]
868        unsafe fn encode(
869            self,
870            encoder: &mut fidl::encoding::Encoder<'_, D>,
871            offset: usize,
872            depth: fidl::encoding::Depth,
873        ) -> fidl::Result<()> {
874            encoder.debug_check_bounds::<DeviceMonitorDestroyIfaceRequest>(offset);
875            // Zero out padding regions. There's no need to apply masks
876            // because the unmasked parts will be overwritten by fields.
877            // Write the fields.
878            self.0.encode(encoder, offset + 0, depth)?;
879            Ok(())
880        }
881    }
882
883    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
884        for DeviceMonitorDestroyIfaceRequest
885    {
886        #[inline(always)]
887        fn new_empty() -> Self {
888            Self { req: fidl::new_empty!(DestroyIfaceRequest, D) }
889        }
890
891        #[inline]
892        unsafe fn decode(
893            &mut self,
894            decoder: &mut fidl::encoding::Decoder<'_, D>,
895            offset: usize,
896            _depth: fidl::encoding::Depth,
897        ) -> fidl::Result<()> {
898            decoder.debug_check_bounds::<Self>(offset);
899            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
900            // Verify that padding bytes are zero.
901            // Copy from the buffer into the object.
902            unsafe {
903                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
904            }
905            Ok(())
906        }
907    }
908
909    impl fidl::encoding::ValueTypeMarker for DeviceMonitorDestroyIfaceResponse {
910        type Borrowed<'a> = &'a Self;
911        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
912            value
913        }
914    }
915
916    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorDestroyIfaceResponse {
917        type Owned = Self;
918
919        #[inline(always)]
920        fn inline_align(_context: fidl::encoding::Context) -> usize {
921            4
922        }
923
924        #[inline(always)]
925        fn inline_size(_context: fidl::encoding::Context) -> usize {
926            4
927        }
928        #[inline(always)]
929        fn encode_is_copy() -> bool {
930            true
931        }
932
933        #[inline(always)]
934        fn decode_is_copy() -> bool {
935            true
936        }
937    }
938
939    unsafe impl<D: fidl::encoding::ResourceDialect>
940        fidl::encoding::Encode<DeviceMonitorDestroyIfaceResponse, D>
941        for &DeviceMonitorDestroyIfaceResponse
942    {
943        #[inline]
944        unsafe fn encode(
945            self,
946            encoder: &mut fidl::encoding::Encoder<'_, D>,
947            offset: usize,
948            _depth: fidl::encoding::Depth,
949        ) -> fidl::Result<()> {
950            encoder.debug_check_bounds::<DeviceMonitorDestroyIfaceResponse>(offset);
951            unsafe {
952                // Copy the object into the buffer.
953                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
954                (buf_ptr as *mut DeviceMonitorDestroyIfaceResponse)
955                    .write_unaligned((self as *const DeviceMonitorDestroyIfaceResponse).read());
956                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
957                // done second because the memcpy will write garbage to these bytes.
958            }
959            Ok(())
960        }
961    }
962    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
963        fidl::encoding::Encode<DeviceMonitorDestroyIfaceResponse, D> for (T0,)
964    {
965        #[inline]
966        unsafe fn encode(
967            self,
968            encoder: &mut fidl::encoding::Encoder<'_, D>,
969            offset: usize,
970            depth: fidl::encoding::Depth,
971        ) -> fidl::Result<()> {
972            encoder.debug_check_bounds::<DeviceMonitorDestroyIfaceResponse>(offset);
973            // Zero out padding regions. There's no need to apply masks
974            // because the unmasked parts will be overwritten by fields.
975            // Write the fields.
976            self.0.encode(encoder, offset + 0, depth)?;
977            Ok(())
978        }
979    }
980
981    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
982        for DeviceMonitorDestroyIfaceResponse
983    {
984        #[inline(always)]
985        fn new_empty() -> Self {
986            Self { status: fidl::new_empty!(i32, D) }
987        }
988
989        #[inline]
990        unsafe fn decode(
991            &mut self,
992            decoder: &mut fidl::encoding::Decoder<'_, D>,
993            offset: usize,
994            _depth: fidl::encoding::Depth,
995        ) -> fidl::Result<()> {
996            decoder.debug_check_bounds::<Self>(offset);
997            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
998            // Verify that padding bytes are zero.
999            // Copy from the buffer into the object.
1000            unsafe {
1001                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1002            }
1003            Ok(())
1004        }
1005    }
1006
1007    impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetCountryRequest {
1008        type Borrowed<'a> = &'a Self;
1009        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1010            value
1011        }
1012    }
1013
1014    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetCountryRequest {
1015        type Owned = Self;
1016
1017        #[inline(always)]
1018        fn inline_align(_context: fidl::encoding::Context) -> usize {
1019            2
1020        }
1021
1022        #[inline(always)]
1023        fn inline_size(_context: fidl::encoding::Context) -> usize {
1024            2
1025        }
1026        #[inline(always)]
1027        fn encode_is_copy() -> bool {
1028            true
1029        }
1030
1031        #[inline(always)]
1032        fn decode_is_copy() -> bool {
1033            true
1034        }
1035    }
1036
1037    unsafe impl<D: fidl::encoding::ResourceDialect>
1038        fidl::encoding::Encode<DeviceMonitorGetCountryRequest, D>
1039        for &DeviceMonitorGetCountryRequest
1040    {
1041        #[inline]
1042        unsafe fn encode(
1043            self,
1044            encoder: &mut fidl::encoding::Encoder<'_, D>,
1045            offset: usize,
1046            _depth: fidl::encoding::Depth,
1047        ) -> fidl::Result<()> {
1048            encoder.debug_check_bounds::<DeviceMonitorGetCountryRequest>(offset);
1049            unsafe {
1050                // Copy the object into the buffer.
1051                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1052                (buf_ptr as *mut DeviceMonitorGetCountryRequest)
1053                    .write_unaligned((self as *const DeviceMonitorGetCountryRequest).read());
1054                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1055                // done second because the memcpy will write garbage to these bytes.
1056            }
1057            Ok(())
1058        }
1059    }
1060    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1061        fidl::encoding::Encode<DeviceMonitorGetCountryRequest, D> for (T0,)
1062    {
1063        #[inline]
1064        unsafe fn encode(
1065            self,
1066            encoder: &mut fidl::encoding::Encoder<'_, D>,
1067            offset: usize,
1068            depth: fidl::encoding::Depth,
1069        ) -> fidl::Result<()> {
1070            encoder.debug_check_bounds::<DeviceMonitorGetCountryRequest>(offset);
1071            // Zero out padding regions. There's no need to apply masks
1072            // because the unmasked parts will be overwritten by fields.
1073            // Write the fields.
1074            self.0.encode(encoder, offset + 0, depth)?;
1075            Ok(())
1076        }
1077    }
1078
1079    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1080        for DeviceMonitorGetCountryRequest
1081    {
1082        #[inline(always)]
1083        fn new_empty() -> Self {
1084            Self { phy_id: fidl::new_empty!(u16, D) }
1085        }
1086
1087        #[inline]
1088        unsafe fn decode(
1089            &mut self,
1090            decoder: &mut fidl::encoding::Decoder<'_, D>,
1091            offset: usize,
1092            _depth: fidl::encoding::Depth,
1093        ) -> fidl::Result<()> {
1094            decoder.debug_check_bounds::<Self>(offset);
1095            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1096            // Verify that padding bytes are zero.
1097            // Copy from the buffer into the object.
1098            unsafe {
1099                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1100            }
1101            Ok(())
1102        }
1103    }
1104
1105    impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetDevPathRequest {
1106        type Borrowed<'a> = &'a Self;
1107        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1108            value
1109        }
1110    }
1111
1112    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetDevPathRequest {
1113        type Owned = Self;
1114
1115        #[inline(always)]
1116        fn inline_align(_context: fidl::encoding::Context) -> usize {
1117            2
1118        }
1119
1120        #[inline(always)]
1121        fn inline_size(_context: fidl::encoding::Context) -> usize {
1122            2
1123        }
1124        #[inline(always)]
1125        fn encode_is_copy() -> bool {
1126            true
1127        }
1128
1129        #[inline(always)]
1130        fn decode_is_copy() -> bool {
1131            true
1132        }
1133    }
1134
1135    unsafe impl<D: fidl::encoding::ResourceDialect>
1136        fidl::encoding::Encode<DeviceMonitorGetDevPathRequest, D>
1137        for &DeviceMonitorGetDevPathRequest
1138    {
1139        #[inline]
1140        unsafe fn encode(
1141            self,
1142            encoder: &mut fidl::encoding::Encoder<'_, D>,
1143            offset: usize,
1144            _depth: fidl::encoding::Depth,
1145        ) -> fidl::Result<()> {
1146            encoder.debug_check_bounds::<DeviceMonitorGetDevPathRequest>(offset);
1147            unsafe {
1148                // Copy the object into the buffer.
1149                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1150                (buf_ptr as *mut DeviceMonitorGetDevPathRequest)
1151                    .write_unaligned((self as *const DeviceMonitorGetDevPathRequest).read());
1152                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1153                // done second because the memcpy will write garbage to these bytes.
1154            }
1155            Ok(())
1156        }
1157    }
1158    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1159        fidl::encoding::Encode<DeviceMonitorGetDevPathRequest, D> for (T0,)
1160    {
1161        #[inline]
1162        unsafe fn encode(
1163            self,
1164            encoder: &mut fidl::encoding::Encoder<'_, D>,
1165            offset: usize,
1166            depth: fidl::encoding::Depth,
1167        ) -> fidl::Result<()> {
1168            encoder.debug_check_bounds::<DeviceMonitorGetDevPathRequest>(offset);
1169            // Zero out padding regions. There's no need to apply masks
1170            // because the unmasked parts will be overwritten by fields.
1171            // Write the fields.
1172            self.0.encode(encoder, offset + 0, depth)?;
1173            Ok(())
1174        }
1175    }
1176
1177    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1178        for DeviceMonitorGetDevPathRequest
1179    {
1180        #[inline(always)]
1181        fn new_empty() -> Self {
1182            Self { phy_id: fidl::new_empty!(u16, D) }
1183        }
1184
1185        #[inline]
1186        unsafe fn decode(
1187            &mut self,
1188            decoder: &mut fidl::encoding::Decoder<'_, D>,
1189            offset: usize,
1190            _depth: fidl::encoding::Depth,
1191        ) -> fidl::Result<()> {
1192            decoder.debug_check_bounds::<Self>(offset);
1193            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1194            // Verify that padding bytes are zero.
1195            // Copy from the buffer into the object.
1196            unsafe {
1197                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1198            }
1199            Ok(())
1200        }
1201    }
1202
1203    impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetDevPathResponse {
1204        type Borrowed<'a> = &'a Self;
1205        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1206            value
1207        }
1208    }
1209
1210    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetDevPathResponse {
1211        type Owned = Self;
1212
1213        #[inline(always)]
1214        fn inline_align(_context: fidl::encoding::Context) -> usize {
1215            8
1216        }
1217
1218        #[inline(always)]
1219        fn inline_size(_context: fidl::encoding::Context) -> usize {
1220            16
1221        }
1222    }
1223
1224    unsafe impl<D: fidl::encoding::ResourceDialect>
1225        fidl::encoding::Encode<DeviceMonitorGetDevPathResponse, D>
1226        for &DeviceMonitorGetDevPathResponse
1227    {
1228        #[inline]
1229        unsafe fn encode(
1230            self,
1231            encoder: &mut fidl::encoding::Encoder<'_, D>,
1232            offset: usize,
1233            _depth: fidl::encoding::Depth,
1234        ) -> fidl::Result<()> {
1235            encoder.debug_check_bounds::<DeviceMonitorGetDevPathResponse>(offset);
1236            // Delegate to tuple encoding.
1237            fidl::encoding::Encode::<DeviceMonitorGetDevPathResponse, D>::encode(
1238                (
1239                    <fidl::encoding::Optional<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.dev_path),
1240                ),
1241                encoder, offset, _depth
1242            )
1243        }
1244    }
1245    unsafe impl<
1246            D: fidl::encoding::ResourceDialect,
1247            T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::UnboundedString>, D>,
1248        > fidl::encoding::Encode<DeviceMonitorGetDevPathResponse, D> for (T0,)
1249    {
1250        #[inline]
1251        unsafe fn encode(
1252            self,
1253            encoder: &mut fidl::encoding::Encoder<'_, D>,
1254            offset: usize,
1255            depth: fidl::encoding::Depth,
1256        ) -> fidl::Result<()> {
1257            encoder.debug_check_bounds::<DeviceMonitorGetDevPathResponse>(offset);
1258            // Zero out padding regions. There's no need to apply masks
1259            // because the unmasked parts will be overwritten by fields.
1260            // Write the fields.
1261            self.0.encode(encoder, offset + 0, depth)?;
1262            Ok(())
1263        }
1264    }
1265
1266    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1267        for DeviceMonitorGetDevPathResponse
1268    {
1269        #[inline(always)]
1270        fn new_empty() -> Self {
1271            Self {
1272                dev_path: fidl::new_empty!(
1273                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
1274                    D
1275                ),
1276            }
1277        }
1278
1279        #[inline]
1280        unsafe fn decode(
1281            &mut self,
1282            decoder: &mut fidl::encoding::Decoder<'_, D>,
1283            offset: usize,
1284            _depth: fidl::encoding::Depth,
1285        ) -> fidl::Result<()> {
1286            decoder.debug_check_bounds::<Self>(offset);
1287            // Verify that padding bytes are zero.
1288            fidl::decode!(
1289                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
1290                D,
1291                &mut self.dev_path,
1292                decoder,
1293                offset + 0,
1294                _depth
1295            )?;
1296            Ok(())
1297        }
1298    }
1299
1300    impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetPowerSaveModeRequest {
1301        type Borrowed<'a> = &'a Self;
1302        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1303            value
1304        }
1305    }
1306
1307    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetPowerSaveModeRequest {
1308        type Owned = Self;
1309
1310        #[inline(always)]
1311        fn inline_align(_context: fidl::encoding::Context) -> usize {
1312            2
1313        }
1314
1315        #[inline(always)]
1316        fn inline_size(_context: fidl::encoding::Context) -> usize {
1317            2
1318        }
1319        #[inline(always)]
1320        fn encode_is_copy() -> bool {
1321            true
1322        }
1323
1324        #[inline(always)]
1325        fn decode_is_copy() -> bool {
1326            true
1327        }
1328    }
1329
1330    unsafe impl<D: fidl::encoding::ResourceDialect>
1331        fidl::encoding::Encode<DeviceMonitorGetPowerSaveModeRequest, D>
1332        for &DeviceMonitorGetPowerSaveModeRequest
1333    {
1334        #[inline]
1335        unsafe fn encode(
1336            self,
1337            encoder: &mut fidl::encoding::Encoder<'_, D>,
1338            offset: usize,
1339            _depth: fidl::encoding::Depth,
1340        ) -> fidl::Result<()> {
1341            encoder.debug_check_bounds::<DeviceMonitorGetPowerSaveModeRequest>(offset);
1342            unsafe {
1343                // Copy the object into the buffer.
1344                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1345                (buf_ptr as *mut DeviceMonitorGetPowerSaveModeRequest)
1346                    .write_unaligned((self as *const DeviceMonitorGetPowerSaveModeRequest).read());
1347                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1348                // done second because the memcpy will write garbage to these bytes.
1349            }
1350            Ok(())
1351        }
1352    }
1353    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1354        fidl::encoding::Encode<DeviceMonitorGetPowerSaveModeRequest, D> for (T0,)
1355    {
1356        #[inline]
1357        unsafe fn encode(
1358            self,
1359            encoder: &mut fidl::encoding::Encoder<'_, D>,
1360            offset: usize,
1361            depth: fidl::encoding::Depth,
1362        ) -> fidl::Result<()> {
1363            encoder.debug_check_bounds::<DeviceMonitorGetPowerSaveModeRequest>(offset);
1364            // Zero out padding regions. There's no need to apply masks
1365            // because the unmasked parts will be overwritten by fields.
1366            // Write the fields.
1367            self.0.encode(encoder, offset + 0, depth)?;
1368            Ok(())
1369        }
1370    }
1371
1372    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1373        for DeviceMonitorGetPowerSaveModeRequest
1374    {
1375        #[inline(always)]
1376        fn new_empty() -> Self {
1377            Self { phy_id: fidl::new_empty!(u16, D) }
1378        }
1379
1380        #[inline]
1381        unsafe fn decode(
1382            &mut self,
1383            decoder: &mut fidl::encoding::Decoder<'_, D>,
1384            offset: usize,
1385            _depth: fidl::encoding::Depth,
1386        ) -> fidl::Result<()> {
1387            decoder.debug_check_bounds::<Self>(offset);
1388            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1389            // Verify that padding bytes are zero.
1390            // Copy from the buffer into the object.
1391            unsafe {
1392                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1393            }
1394            Ok(())
1395        }
1396    }
1397
1398    impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetSupportedMacRolesRequest {
1399        type Borrowed<'a> = &'a Self;
1400        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1401            value
1402        }
1403    }
1404
1405    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetSupportedMacRolesRequest {
1406        type Owned = Self;
1407
1408        #[inline(always)]
1409        fn inline_align(_context: fidl::encoding::Context) -> usize {
1410            2
1411        }
1412
1413        #[inline(always)]
1414        fn inline_size(_context: fidl::encoding::Context) -> usize {
1415            2
1416        }
1417        #[inline(always)]
1418        fn encode_is_copy() -> bool {
1419            true
1420        }
1421
1422        #[inline(always)]
1423        fn decode_is_copy() -> bool {
1424            true
1425        }
1426    }
1427
1428    unsafe impl<D: fidl::encoding::ResourceDialect>
1429        fidl::encoding::Encode<DeviceMonitorGetSupportedMacRolesRequest, D>
1430        for &DeviceMonitorGetSupportedMacRolesRequest
1431    {
1432        #[inline]
1433        unsafe fn encode(
1434            self,
1435            encoder: &mut fidl::encoding::Encoder<'_, D>,
1436            offset: usize,
1437            _depth: fidl::encoding::Depth,
1438        ) -> fidl::Result<()> {
1439            encoder.debug_check_bounds::<DeviceMonitorGetSupportedMacRolesRequest>(offset);
1440            unsafe {
1441                // Copy the object into the buffer.
1442                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1443                (buf_ptr as *mut DeviceMonitorGetSupportedMacRolesRequest).write_unaligned(
1444                    (self as *const DeviceMonitorGetSupportedMacRolesRequest).read(),
1445                );
1446                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1447                // done second because the memcpy will write garbage to these bytes.
1448            }
1449            Ok(())
1450        }
1451    }
1452    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1453        fidl::encoding::Encode<DeviceMonitorGetSupportedMacRolesRequest, D> for (T0,)
1454    {
1455        #[inline]
1456        unsafe fn encode(
1457            self,
1458            encoder: &mut fidl::encoding::Encoder<'_, D>,
1459            offset: usize,
1460            depth: fidl::encoding::Depth,
1461        ) -> fidl::Result<()> {
1462            encoder.debug_check_bounds::<DeviceMonitorGetSupportedMacRolesRequest>(offset);
1463            // Zero out padding regions. There's no need to apply masks
1464            // because the unmasked parts will be overwritten by fields.
1465            // Write the fields.
1466            self.0.encode(encoder, offset + 0, depth)?;
1467            Ok(())
1468        }
1469    }
1470
1471    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1472        for DeviceMonitorGetSupportedMacRolesRequest
1473    {
1474        #[inline(always)]
1475        fn new_empty() -> Self {
1476            Self { phy_id: fidl::new_empty!(u16, D) }
1477        }
1478
1479        #[inline]
1480        unsafe fn decode(
1481            &mut self,
1482            decoder: &mut fidl::encoding::Decoder<'_, D>,
1483            offset: usize,
1484            _depth: fidl::encoding::Depth,
1485        ) -> fidl::Result<()> {
1486            decoder.debug_check_bounds::<Self>(offset);
1487            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1488            // Verify that padding bytes are zero.
1489            // Copy from the buffer into the object.
1490            unsafe {
1491                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1492            }
1493            Ok(())
1494        }
1495    }
1496
1497    impl fidl::encoding::ValueTypeMarker for DeviceMonitorListIfacesResponse {
1498        type Borrowed<'a> = &'a Self;
1499        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1500            value
1501        }
1502    }
1503
1504    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorListIfacesResponse {
1505        type Owned = Self;
1506
1507        #[inline(always)]
1508        fn inline_align(_context: fidl::encoding::Context) -> usize {
1509            8
1510        }
1511
1512        #[inline(always)]
1513        fn inline_size(_context: fidl::encoding::Context) -> usize {
1514            16
1515        }
1516    }
1517
1518    unsafe impl<D: fidl::encoding::ResourceDialect>
1519        fidl::encoding::Encode<DeviceMonitorListIfacesResponse, D>
1520        for &DeviceMonitorListIfacesResponse
1521    {
1522        #[inline]
1523        unsafe fn encode(
1524            self,
1525            encoder: &mut fidl::encoding::Encoder<'_, D>,
1526            offset: usize,
1527            _depth: fidl::encoding::Depth,
1528        ) -> fidl::Result<()> {
1529            encoder.debug_check_bounds::<DeviceMonitorListIfacesResponse>(offset);
1530            // Delegate to tuple encoding.
1531            fidl::encoding::Encode::<DeviceMonitorListIfacesResponse, D>::encode(
1532                (
1533                    <fidl::encoding::UnboundedVector<u16> as fidl::encoding::ValueTypeMarker>::borrow(&self.iface_list),
1534                ),
1535                encoder, offset, _depth
1536            )
1537        }
1538    }
1539    unsafe impl<
1540            D: fidl::encoding::ResourceDialect,
1541            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u16>, D>,
1542        > fidl::encoding::Encode<DeviceMonitorListIfacesResponse, D> for (T0,)
1543    {
1544        #[inline]
1545        unsafe fn encode(
1546            self,
1547            encoder: &mut fidl::encoding::Encoder<'_, D>,
1548            offset: usize,
1549            depth: fidl::encoding::Depth,
1550        ) -> fidl::Result<()> {
1551            encoder.debug_check_bounds::<DeviceMonitorListIfacesResponse>(offset);
1552            // Zero out padding regions. There's no need to apply masks
1553            // because the unmasked parts will be overwritten by fields.
1554            // Write the fields.
1555            self.0.encode(encoder, offset + 0, depth)?;
1556            Ok(())
1557        }
1558    }
1559
1560    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1561        for DeviceMonitorListIfacesResponse
1562    {
1563        #[inline(always)]
1564        fn new_empty() -> Self {
1565            Self { iface_list: fidl::new_empty!(fidl::encoding::UnboundedVector<u16>, D) }
1566        }
1567
1568        #[inline]
1569        unsafe fn decode(
1570            &mut self,
1571            decoder: &mut fidl::encoding::Decoder<'_, D>,
1572            offset: usize,
1573            _depth: fidl::encoding::Depth,
1574        ) -> fidl::Result<()> {
1575            decoder.debug_check_bounds::<Self>(offset);
1576            // Verify that padding bytes are zero.
1577            fidl::decode!(
1578                fidl::encoding::UnboundedVector<u16>,
1579                D,
1580                &mut self.iface_list,
1581                decoder,
1582                offset + 0,
1583                _depth
1584            )?;
1585            Ok(())
1586        }
1587    }
1588
1589    impl fidl::encoding::ValueTypeMarker for DeviceMonitorListPhysResponse {
1590        type Borrowed<'a> = &'a Self;
1591        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1592            value
1593        }
1594    }
1595
1596    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorListPhysResponse {
1597        type Owned = Self;
1598
1599        #[inline(always)]
1600        fn inline_align(_context: fidl::encoding::Context) -> usize {
1601            8
1602        }
1603
1604        #[inline(always)]
1605        fn inline_size(_context: fidl::encoding::Context) -> usize {
1606            16
1607        }
1608    }
1609
1610    unsafe impl<D: fidl::encoding::ResourceDialect>
1611        fidl::encoding::Encode<DeviceMonitorListPhysResponse, D>
1612        for &DeviceMonitorListPhysResponse
1613    {
1614        #[inline]
1615        unsafe fn encode(
1616            self,
1617            encoder: &mut fidl::encoding::Encoder<'_, D>,
1618            offset: usize,
1619            _depth: fidl::encoding::Depth,
1620        ) -> fidl::Result<()> {
1621            encoder.debug_check_bounds::<DeviceMonitorListPhysResponse>(offset);
1622            // Delegate to tuple encoding.
1623            fidl::encoding::Encode::<DeviceMonitorListPhysResponse, D>::encode(
1624                (
1625                    <fidl::encoding::UnboundedVector<u16> as fidl::encoding::ValueTypeMarker>::borrow(&self.phy_list),
1626                ),
1627                encoder, offset, _depth
1628            )
1629        }
1630    }
1631    unsafe impl<
1632            D: fidl::encoding::ResourceDialect,
1633            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u16>, D>,
1634        > fidl::encoding::Encode<DeviceMonitorListPhysResponse, D> for (T0,)
1635    {
1636        #[inline]
1637        unsafe fn encode(
1638            self,
1639            encoder: &mut fidl::encoding::Encoder<'_, D>,
1640            offset: usize,
1641            depth: fidl::encoding::Depth,
1642        ) -> fidl::Result<()> {
1643            encoder.debug_check_bounds::<DeviceMonitorListPhysResponse>(offset);
1644            // Zero out padding regions. There's no need to apply masks
1645            // because the unmasked parts will be overwritten by fields.
1646            // Write the fields.
1647            self.0.encode(encoder, offset + 0, depth)?;
1648            Ok(())
1649        }
1650    }
1651
1652    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1653        for DeviceMonitorListPhysResponse
1654    {
1655        #[inline(always)]
1656        fn new_empty() -> Self {
1657            Self { phy_list: fidl::new_empty!(fidl::encoding::UnboundedVector<u16>, D) }
1658        }
1659
1660        #[inline]
1661        unsafe fn decode(
1662            &mut self,
1663            decoder: &mut fidl::encoding::Decoder<'_, D>,
1664            offset: usize,
1665            _depth: fidl::encoding::Depth,
1666        ) -> fidl::Result<()> {
1667            decoder.debug_check_bounds::<Self>(offset);
1668            // Verify that padding bytes are zero.
1669            fidl::decode!(
1670                fidl::encoding::UnboundedVector<u16>,
1671                D,
1672                &mut self.phy_list,
1673                decoder,
1674                offset + 0,
1675                _depth
1676            )?;
1677            Ok(())
1678        }
1679    }
1680
1681    impl fidl::encoding::ValueTypeMarker for DeviceMonitorQueryIfaceRequest {
1682        type Borrowed<'a> = &'a Self;
1683        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1684            value
1685        }
1686    }
1687
1688    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorQueryIfaceRequest {
1689        type Owned = Self;
1690
1691        #[inline(always)]
1692        fn inline_align(_context: fidl::encoding::Context) -> usize {
1693            2
1694        }
1695
1696        #[inline(always)]
1697        fn inline_size(_context: fidl::encoding::Context) -> usize {
1698            2
1699        }
1700        #[inline(always)]
1701        fn encode_is_copy() -> bool {
1702            true
1703        }
1704
1705        #[inline(always)]
1706        fn decode_is_copy() -> bool {
1707            true
1708        }
1709    }
1710
1711    unsafe impl<D: fidl::encoding::ResourceDialect>
1712        fidl::encoding::Encode<DeviceMonitorQueryIfaceRequest, D>
1713        for &DeviceMonitorQueryIfaceRequest
1714    {
1715        #[inline]
1716        unsafe fn encode(
1717            self,
1718            encoder: &mut fidl::encoding::Encoder<'_, D>,
1719            offset: usize,
1720            _depth: fidl::encoding::Depth,
1721        ) -> fidl::Result<()> {
1722            encoder.debug_check_bounds::<DeviceMonitorQueryIfaceRequest>(offset);
1723            unsafe {
1724                // Copy the object into the buffer.
1725                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1726                (buf_ptr as *mut DeviceMonitorQueryIfaceRequest)
1727                    .write_unaligned((self as *const DeviceMonitorQueryIfaceRequest).read());
1728                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1729                // done second because the memcpy will write garbage to these bytes.
1730            }
1731            Ok(())
1732        }
1733    }
1734    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1735        fidl::encoding::Encode<DeviceMonitorQueryIfaceRequest, D> for (T0,)
1736    {
1737        #[inline]
1738        unsafe fn encode(
1739            self,
1740            encoder: &mut fidl::encoding::Encoder<'_, D>,
1741            offset: usize,
1742            depth: fidl::encoding::Depth,
1743        ) -> fidl::Result<()> {
1744            encoder.debug_check_bounds::<DeviceMonitorQueryIfaceRequest>(offset);
1745            // Zero out padding regions. There's no need to apply masks
1746            // because the unmasked parts will be overwritten by fields.
1747            // Write the fields.
1748            self.0.encode(encoder, offset + 0, depth)?;
1749            Ok(())
1750        }
1751    }
1752
1753    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1754        for DeviceMonitorQueryIfaceRequest
1755    {
1756        #[inline(always)]
1757        fn new_empty() -> Self {
1758            Self { iface_id: fidl::new_empty!(u16, D) }
1759        }
1760
1761        #[inline]
1762        unsafe fn decode(
1763            &mut self,
1764            decoder: &mut fidl::encoding::Decoder<'_, D>,
1765            offset: usize,
1766            _depth: fidl::encoding::Depth,
1767        ) -> fidl::Result<()> {
1768            decoder.debug_check_bounds::<Self>(offset);
1769            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1770            // Verify that padding bytes are zero.
1771            // Copy from the buffer into the object.
1772            unsafe {
1773                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1774            }
1775            Ok(())
1776        }
1777    }
1778
1779    impl fidl::encoding::ValueTypeMarker for DeviceMonitorSetCountryRequest {
1780        type Borrowed<'a> = &'a Self;
1781        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1782            value
1783        }
1784    }
1785
1786    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorSetCountryRequest {
1787        type Owned = Self;
1788
1789        #[inline(always)]
1790        fn inline_align(_context: fidl::encoding::Context) -> usize {
1791            2
1792        }
1793
1794        #[inline(always)]
1795        fn inline_size(_context: fidl::encoding::Context) -> usize {
1796            4
1797        }
1798        #[inline(always)]
1799        fn encode_is_copy() -> bool {
1800            true
1801        }
1802
1803        #[inline(always)]
1804        fn decode_is_copy() -> bool {
1805            true
1806        }
1807    }
1808
1809    unsafe impl<D: fidl::encoding::ResourceDialect>
1810        fidl::encoding::Encode<DeviceMonitorSetCountryRequest, D>
1811        for &DeviceMonitorSetCountryRequest
1812    {
1813        #[inline]
1814        unsafe fn encode(
1815            self,
1816            encoder: &mut fidl::encoding::Encoder<'_, D>,
1817            offset: usize,
1818            _depth: fidl::encoding::Depth,
1819        ) -> fidl::Result<()> {
1820            encoder.debug_check_bounds::<DeviceMonitorSetCountryRequest>(offset);
1821            unsafe {
1822                // Copy the object into the buffer.
1823                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1824                (buf_ptr as *mut DeviceMonitorSetCountryRequest)
1825                    .write_unaligned((self as *const DeviceMonitorSetCountryRequest).read());
1826                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1827                // done second because the memcpy will write garbage to these bytes.
1828            }
1829            Ok(())
1830        }
1831    }
1832    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<SetCountryRequest, D>>
1833        fidl::encoding::Encode<DeviceMonitorSetCountryRequest, D> for (T0,)
1834    {
1835        #[inline]
1836        unsafe fn encode(
1837            self,
1838            encoder: &mut fidl::encoding::Encoder<'_, D>,
1839            offset: usize,
1840            depth: fidl::encoding::Depth,
1841        ) -> fidl::Result<()> {
1842            encoder.debug_check_bounds::<DeviceMonitorSetCountryRequest>(offset);
1843            // Zero out padding regions. There's no need to apply masks
1844            // because the unmasked parts will be overwritten by fields.
1845            // Write the fields.
1846            self.0.encode(encoder, offset + 0, depth)?;
1847            Ok(())
1848        }
1849    }
1850
1851    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1852        for DeviceMonitorSetCountryRequest
1853    {
1854        #[inline(always)]
1855        fn new_empty() -> Self {
1856            Self { req: fidl::new_empty!(SetCountryRequest, D) }
1857        }
1858
1859        #[inline]
1860        unsafe fn decode(
1861            &mut self,
1862            decoder: &mut fidl::encoding::Decoder<'_, D>,
1863            offset: usize,
1864            _depth: fidl::encoding::Depth,
1865        ) -> fidl::Result<()> {
1866            decoder.debug_check_bounds::<Self>(offset);
1867            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1868            // Verify that padding bytes are zero.
1869            // Copy from the buffer into the object.
1870            unsafe {
1871                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1872            }
1873            Ok(())
1874        }
1875    }
1876
1877    impl fidl::encoding::ValueTypeMarker for DeviceMonitorSetCountryResponse {
1878        type Borrowed<'a> = &'a Self;
1879        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1880            value
1881        }
1882    }
1883
1884    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorSetCountryResponse {
1885        type Owned = Self;
1886
1887        #[inline(always)]
1888        fn inline_align(_context: fidl::encoding::Context) -> usize {
1889            4
1890        }
1891
1892        #[inline(always)]
1893        fn inline_size(_context: fidl::encoding::Context) -> usize {
1894            4
1895        }
1896        #[inline(always)]
1897        fn encode_is_copy() -> bool {
1898            true
1899        }
1900
1901        #[inline(always)]
1902        fn decode_is_copy() -> bool {
1903            true
1904        }
1905    }
1906
1907    unsafe impl<D: fidl::encoding::ResourceDialect>
1908        fidl::encoding::Encode<DeviceMonitorSetCountryResponse, D>
1909        for &DeviceMonitorSetCountryResponse
1910    {
1911        #[inline]
1912        unsafe fn encode(
1913            self,
1914            encoder: &mut fidl::encoding::Encoder<'_, D>,
1915            offset: usize,
1916            _depth: fidl::encoding::Depth,
1917        ) -> fidl::Result<()> {
1918            encoder.debug_check_bounds::<DeviceMonitorSetCountryResponse>(offset);
1919            unsafe {
1920                // Copy the object into the buffer.
1921                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1922                (buf_ptr as *mut DeviceMonitorSetCountryResponse)
1923                    .write_unaligned((self as *const DeviceMonitorSetCountryResponse).read());
1924                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1925                // done second because the memcpy will write garbage to these bytes.
1926            }
1927            Ok(())
1928        }
1929    }
1930    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
1931        fidl::encoding::Encode<DeviceMonitorSetCountryResponse, D> for (T0,)
1932    {
1933        #[inline]
1934        unsafe fn encode(
1935            self,
1936            encoder: &mut fidl::encoding::Encoder<'_, D>,
1937            offset: usize,
1938            depth: fidl::encoding::Depth,
1939        ) -> fidl::Result<()> {
1940            encoder.debug_check_bounds::<DeviceMonitorSetCountryResponse>(offset);
1941            // Zero out padding regions. There's no need to apply masks
1942            // because the unmasked parts will be overwritten by fields.
1943            // Write the fields.
1944            self.0.encode(encoder, offset + 0, depth)?;
1945            Ok(())
1946        }
1947    }
1948
1949    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1950        for DeviceMonitorSetCountryResponse
1951    {
1952        #[inline(always)]
1953        fn new_empty() -> Self {
1954            Self { status: fidl::new_empty!(i32, D) }
1955        }
1956
1957        #[inline]
1958        unsafe fn decode(
1959            &mut self,
1960            decoder: &mut fidl::encoding::Decoder<'_, D>,
1961            offset: usize,
1962            _depth: fidl::encoding::Depth,
1963        ) -> fidl::Result<()> {
1964            decoder.debug_check_bounds::<Self>(offset);
1965            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1966            // Verify that padding bytes are zero.
1967            // Copy from the buffer into the object.
1968            unsafe {
1969                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
1970            }
1971            Ok(())
1972        }
1973    }
1974
1975    impl fidl::encoding::ValueTypeMarker for DeviceMonitorSetPowerSaveModeRequest {
1976        type Borrowed<'a> = &'a Self;
1977        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1978            value
1979        }
1980    }
1981
1982    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorSetPowerSaveModeRequest {
1983        type Owned = Self;
1984
1985        #[inline(always)]
1986        fn inline_align(_context: fidl::encoding::Context) -> usize {
1987            4
1988        }
1989
1990        #[inline(always)]
1991        fn inline_size(_context: fidl::encoding::Context) -> usize {
1992            8
1993        }
1994    }
1995
1996    unsafe impl<D: fidl::encoding::ResourceDialect>
1997        fidl::encoding::Encode<DeviceMonitorSetPowerSaveModeRequest, D>
1998        for &DeviceMonitorSetPowerSaveModeRequest
1999    {
2000        #[inline]
2001        unsafe fn encode(
2002            self,
2003            encoder: &mut fidl::encoding::Encoder<'_, D>,
2004            offset: usize,
2005            _depth: fidl::encoding::Depth,
2006        ) -> fidl::Result<()> {
2007            encoder.debug_check_bounds::<DeviceMonitorSetPowerSaveModeRequest>(offset);
2008            // Delegate to tuple encoding.
2009            fidl::encoding::Encode::<DeviceMonitorSetPowerSaveModeRequest, D>::encode(
2010                (<SetPowerSaveModeRequest as fidl::encoding::ValueTypeMarker>::borrow(&self.req),),
2011                encoder,
2012                offset,
2013                _depth,
2014            )
2015        }
2016    }
2017    unsafe impl<
2018            D: fidl::encoding::ResourceDialect,
2019            T0: fidl::encoding::Encode<SetPowerSaveModeRequest, D>,
2020        > fidl::encoding::Encode<DeviceMonitorSetPowerSaveModeRequest, D> for (T0,)
2021    {
2022        #[inline]
2023        unsafe fn encode(
2024            self,
2025            encoder: &mut fidl::encoding::Encoder<'_, D>,
2026            offset: usize,
2027            depth: fidl::encoding::Depth,
2028        ) -> fidl::Result<()> {
2029            encoder.debug_check_bounds::<DeviceMonitorSetPowerSaveModeRequest>(offset);
2030            // Zero out padding regions. There's no need to apply masks
2031            // because the unmasked parts will be overwritten by fields.
2032            // Write the fields.
2033            self.0.encode(encoder, offset + 0, depth)?;
2034            Ok(())
2035        }
2036    }
2037
2038    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2039        for DeviceMonitorSetPowerSaveModeRequest
2040    {
2041        #[inline(always)]
2042        fn new_empty() -> Self {
2043            Self { req: fidl::new_empty!(SetPowerSaveModeRequest, D) }
2044        }
2045
2046        #[inline]
2047        unsafe fn decode(
2048            &mut self,
2049            decoder: &mut fidl::encoding::Decoder<'_, D>,
2050            offset: usize,
2051            _depth: fidl::encoding::Depth,
2052        ) -> fidl::Result<()> {
2053            decoder.debug_check_bounds::<Self>(offset);
2054            // Verify that padding bytes are zero.
2055            fidl::decode!(SetPowerSaveModeRequest, D, &mut self.req, decoder, offset + 0, _depth)?;
2056            Ok(())
2057        }
2058    }
2059
2060    impl fidl::encoding::ValueTypeMarker for DeviceMonitorSetPowerSaveModeResponse {
2061        type Borrowed<'a> = &'a Self;
2062        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2063            value
2064        }
2065    }
2066
2067    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorSetPowerSaveModeResponse {
2068        type Owned = Self;
2069
2070        #[inline(always)]
2071        fn inline_align(_context: fidl::encoding::Context) -> usize {
2072            4
2073        }
2074
2075        #[inline(always)]
2076        fn inline_size(_context: fidl::encoding::Context) -> usize {
2077            4
2078        }
2079        #[inline(always)]
2080        fn encode_is_copy() -> bool {
2081            true
2082        }
2083
2084        #[inline(always)]
2085        fn decode_is_copy() -> bool {
2086            true
2087        }
2088    }
2089
2090    unsafe impl<D: fidl::encoding::ResourceDialect>
2091        fidl::encoding::Encode<DeviceMonitorSetPowerSaveModeResponse, D>
2092        for &DeviceMonitorSetPowerSaveModeResponse
2093    {
2094        #[inline]
2095        unsafe fn encode(
2096            self,
2097            encoder: &mut fidl::encoding::Encoder<'_, D>,
2098            offset: usize,
2099            _depth: fidl::encoding::Depth,
2100        ) -> fidl::Result<()> {
2101            encoder.debug_check_bounds::<DeviceMonitorSetPowerSaveModeResponse>(offset);
2102            unsafe {
2103                // Copy the object into the buffer.
2104                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2105                (buf_ptr as *mut DeviceMonitorSetPowerSaveModeResponse)
2106                    .write_unaligned((self as *const DeviceMonitorSetPowerSaveModeResponse).read());
2107                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2108                // done second because the memcpy will write garbage to these bytes.
2109            }
2110            Ok(())
2111        }
2112    }
2113    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
2114        fidl::encoding::Encode<DeviceMonitorSetPowerSaveModeResponse, D> for (T0,)
2115    {
2116        #[inline]
2117        unsafe fn encode(
2118            self,
2119            encoder: &mut fidl::encoding::Encoder<'_, D>,
2120            offset: usize,
2121            depth: fidl::encoding::Depth,
2122        ) -> fidl::Result<()> {
2123            encoder.debug_check_bounds::<DeviceMonitorSetPowerSaveModeResponse>(offset);
2124            // Zero out padding regions. There's no need to apply masks
2125            // because the unmasked parts will be overwritten by fields.
2126            // Write the fields.
2127            self.0.encode(encoder, offset + 0, depth)?;
2128            Ok(())
2129        }
2130    }
2131
2132    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2133        for DeviceMonitorSetPowerSaveModeResponse
2134    {
2135        #[inline(always)]
2136        fn new_empty() -> Self {
2137            Self { status: fidl::new_empty!(i32, D) }
2138        }
2139
2140        #[inline]
2141        unsafe fn decode(
2142            &mut self,
2143            decoder: &mut fidl::encoding::Decoder<'_, D>,
2144            offset: usize,
2145            _depth: fidl::encoding::Depth,
2146        ) -> fidl::Result<()> {
2147            decoder.debug_check_bounds::<Self>(offset);
2148            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2149            // Verify that padding bytes are zero.
2150            // Copy from the buffer into the object.
2151            unsafe {
2152                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
2153            }
2154            Ok(())
2155        }
2156    }
2157
2158    impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetCountryResponse {
2159        type Borrowed<'a> = &'a Self;
2160        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2161            value
2162        }
2163    }
2164
2165    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetCountryResponse {
2166        type Owned = Self;
2167
2168        #[inline(always)]
2169        fn inline_align(_context: fidl::encoding::Context) -> usize {
2170            1
2171        }
2172
2173        #[inline(always)]
2174        fn inline_size(_context: fidl::encoding::Context) -> usize {
2175            2
2176        }
2177        #[inline(always)]
2178        fn encode_is_copy() -> bool {
2179            true
2180        }
2181
2182        #[inline(always)]
2183        fn decode_is_copy() -> bool {
2184            true
2185        }
2186    }
2187
2188    unsafe impl<D: fidl::encoding::ResourceDialect>
2189        fidl::encoding::Encode<DeviceMonitorGetCountryResponse, D>
2190        for &DeviceMonitorGetCountryResponse
2191    {
2192        #[inline]
2193        unsafe fn encode(
2194            self,
2195            encoder: &mut fidl::encoding::Encoder<'_, D>,
2196            offset: usize,
2197            _depth: fidl::encoding::Depth,
2198        ) -> fidl::Result<()> {
2199            encoder.debug_check_bounds::<DeviceMonitorGetCountryResponse>(offset);
2200            unsafe {
2201                // Copy the object into the buffer.
2202                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2203                (buf_ptr as *mut DeviceMonitorGetCountryResponse)
2204                    .write_unaligned((self as *const DeviceMonitorGetCountryResponse).read());
2205                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2206                // done second because the memcpy will write garbage to these bytes.
2207            }
2208            Ok(())
2209        }
2210    }
2211    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<GetCountryResponse, D>>
2212        fidl::encoding::Encode<DeviceMonitorGetCountryResponse, D> for (T0,)
2213    {
2214        #[inline]
2215        unsafe fn encode(
2216            self,
2217            encoder: &mut fidl::encoding::Encoder<'_, D>,
2218            offset: usize,
2219            depth: fidl::encoding::Depth,
2220        ) -> fidl::Result<()> {
2221            encoder.debug_check_bounds::<DeviceMonitorGetCountryResponse>(offset);
2222            // Zero out padding regions. There's no need to apply masks
2223            // because the unmasked parts will be overwritten by fields.
2224            // Write the fields.
2225            self.0.encode(encoder, offset + 0, depth)?;
2226            Ok(())
2227        }
2228    }
2229
2230    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2231        for DeviceMonitorGetCountryResponse
2232    {
2233        #[inline(always)]
2234        fn new_empty() -> Self {
2235            Self { resp: fidl::new_empty!(GetCountryResponse, D) }
2236        }
2237
2238        #[inline]
2239        unsafe fn decode(
2240            &mut self,
2241            decoder: &mut fidl::encoding::Decoder<'_, D>,
2242            offset: usize,
2243            _depth: fidl::encoding::Depth,
2244        ) -> fidl::Result<()> {
2245            decoder.debug_check_bounds::<Self>(offset);
2246            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2247            // Verify that padding bytes are zero.
2248            // Copy from the buffer into the object.
2249            unsafe {
2250                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2251            }
2252            Ok(())
2253        }
2254    }
2255
2256    impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetPowerSaveModeResponse {
2257        type Borrowed<'a> = &'a Self;
2258        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2259            value
2260        }
2261    }
2262
2263    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetPowerSaveModeResponse {
2264        type Owned = Self;
2265
2266        #[inline(always)]
2267        fn inline_align(_context: fidl::encoding::Context) -> usize {
2268            4
2269        }
2270
2271        #[inline(always)]
2272        fn inline_size(_context: fidl::encoding::Context) -> usize {
2273            4
2274        }
2275    }
2276
2277    unsafe impl<D: fidl::encoding::ResourceDialect>
2278        fidl::encoding::Encode<DeviceMonitorGetPowerSaveModeResponse, D>
2279        for &DeviceMonitorGetPowerSaveModeResponse
2280    {
2281        #[inline]
2282        unsafe fn encode(
2283            self,
2284            encoder: &mut fidl::encoding::Encoder<'_, D>,
2285            offset: usize,
2286            _depth: fidl::encoding::Depth,
2287        ) -> fidl::Result<()> {
2288            encoder.debug_check_bounds::<DeviceMonitorGetPowerSaveModeResponse>(offset);
2289            // Delegate to tuple encoding.
2290            fidl::encoding::Encode::<DeviceMonitorGetPowerSaveModeResponse, D>::encode(
2291                (<GetPowerSaveModeResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
2292                encoder,
2293                offset,
2294                _depth,
2295            )
2296        }
2297    }
2298    unsafe impl<
2299            D: fidl::encoding::ResourceDialect,
2300            T0: fidl::encoding::Encode<GetPowerSaveModeResponse, D>,
2301        > fidl::encoding::Encode<DeviceMonitorGetPowerSaveModeResponse, D> for (T0,)
2302    {
2303        #[inline]
2304        unsafe fn encode(
2305            self,
2306            encoder: &mut fidl::encoding::Encoder<'_, D>,
2307            offset: usize,
2308            depth: fidl::encoding::Depth,
2309        ) -> fidl::Result<()> {
2310            encoder.debug_check_bounds::<DeviceMonitorGetPowerSaveModeResponse>(offset);
2311            // Zero out padding regions. There's no need to apply masks
2312            // because the unmasked parts will be overwritten by fields.
2313            // Write the fields.
2314            self.0.encode(encoder, offset + 0, depth)?;
2315            Ok(())
2316        }
2317    }
2318
2319    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2320        for DeviceMonitorGetPowerSaveModeResponse
2321    {
2322        #[inline(always)]
2323        fn new_empty() -> Self {
2324            Self { resp: fidl::new_empty!(GetPowerSaveModeResponse, D) }
2325        }
2326
2327        #[inline]
2328        unsafe fn decode(
2329            &mut self,
2330            decoder: &mut fidl::encoding::Decoder<'_, D>,
2331            offset: usize,
2332            _depth: fidl::encoding::Depth,
2333        ) -> fidl::Result<()> {
2334            decoder.debug_check_bounds::<Self>(offset);
2335            // Verify that padding bytes are zero.
2336            fidl::decode!(
2337                GetPowerSaveModeResponse,
2338                D,
2339                &mut self.resp,
2340                decoder,
2341                offset + 0,
2342                _depth
2343            )?;
2344            Ok(())
2345        }
2346    }
2347
2348    impl fidl::encoding::ValueTypeMarker for DeviceMonitorGetSupportedMacRolesResponse {
2349        type Borrowed<'a> = &'a Self;
2350        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2351            value
2352        }
2353    }
2354
2355    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorGetSupportedMacRolesResponse {
2356        type Owned = Self;
2357
2358        #[inline(always)]
2359        fn inline_align(_context: fidl::encoding::Context) -> usize {
2360            8
2361        }
2362
2363        #[inline(always)]
2364        fn inline_size(_context: fidl::encoding::Context) -> usize {
2365            16
2366        }
2367    }
2368
2369    unsafe impl<D: fidl::encoding::ResourceDialect>
2370        fidl::encoding::Encode<DeviceMonitorGetSupportedMacRolesResponse, D>
2371        for &DeviceMonitorGetSupportedMacRolesResponse
2372    {
2373        #[inline]
2374        unsafe fn encode(
2375            self,
2376            encoder: &mut fidl::encoding::Encoder<'_, D>,
2377            offset: usize,
2378            _depth: fidl::encoding::Depth,
2379        ) -> fidl::Result<()> {
2380            encoder.debug_check_bounds::<DeviceMonitorGetSupportedMacRolesResponse>(offset);
2381            // Delegate to tuple encoding.
2382            fidl::encoding::Encode::<DeviceMonitorGetSupportedMacRolesResponse, D>::encode(
2383                (
2384                    <fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanMacRole, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.supported_mac_roles),
2385                ),
2386                encoder, offset, _depth
2387            )
2388        }
2389    }
2390    unsafe impl<
2391            D: fidl::encoding::ResourceDialect,
2392            T0: fidl::encoding::Encode<
2393                fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanMacRole, 16>,
2394                D,
2395            >,
2396        > fidl::encoding::Encode<DeviceMonitorGetSupportedMacRolesResponse, D> for (T0,)
2397    {
2398        #[inline]
2399        unsafe fn encode(
2400            self,
2401            encoder: &mut fidl::encoding::Encoder<'_, D>,
2402            offset: usize,
2403            depth: fidl::encoding::Depth,
2404        ) -> fidl::Result<()> {
2405            encoder.debug_check_bounds::<DeviceMonitorGetSupportedMacRolesResponse>(offset);
2406            // Zero out padding regions. There's no need to apply masks
2407            // because the unmasked parts will be overwritten by fields.
2408            // Write the fields.
2409            self.0.encode(encoder, offset + 0, depth)?;
2410            Ok(())
2411        }
2412    }
2413
2414    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2415        for DeviceMonitorGetSupportedMacRolesResponse
2416    {
2417        #[inline(always)]
2418        fn new_empty() -> Self {
2419            Self {
2420                supported_mac_roles: fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanMacRole, 16>, D),
2421            }
2422        }
2423
2424        #[inline]
2425        unsafe fn decode(
2426            &mut self,
2427            decoder: &mut fidl::encoding::Decoder<'_, D>,
2428            offset: usize,
2429            _depth: fidl::encoding::Depth,
2430        ) -> fidl::Result<()> {
2431            decoder.debug_check_bounds::<Self>(offset);
2432            // Verify that padding bytes are zero.
2433            fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_wlan_common__common::WlanMacRole, 16>, D, &mut self.supported_mac_roles, decoder, offset + 0, _depth)?;
2434            Ok(())
2435        }
2436    }
2437
2438    impl fidl::encoding::ValueTypeMarker for DeviceMonitorQueryIfaceResponse {
2439        type Borrowed<'a> = &'a Self;
2440        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2441            value
2442        }
2443    }
2444
2445    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorQueryIfaceResponse {
2446        type Owned = Self;
2447
2448        #[inline(always)]
2449        fn inline_align(_context: fidl::encoding::Context) -> usize {
2450            4
2451        }
2452
2453        #[inline(always)]
2454        fn inline_size(_context: fidl::encoding::Context) -> usize {
2455            16
2456        }
2457    }
2458
2459    unsafe impl<D: fidl::encoding::ResourceDialect>
2460        fidl::encoding::Encode<DeviceMonitorQueryIfaceResponse, D>
2461        for &DeviceMonitorQueryIfaceResponse
2462    {
2463        #[inline]
2464        unsafe fn encode(
2465            self,
2466            encoder: &mut fidl::encoding::Encoder<'_, D>,
2467            offset: usize,
2468            _depth: fidl::encoding::Depth,
2469        ) -> fidl::Result<()> {
2470            encoder.debug_check_bounds::<DeviceMonitorQueryIfaceResponse>(offset);
2471            // Delegate to tuple encoding.
2472            fidl::encoding::Encode::<DeviceMonitorQueryIfaceResponse, D>::encode(
2473                (<QueryIfaceResponse as fidl::encoding::ValueTypeMarker>::borrow(&self.resp),),
2474                encoder,
2475                offset,
2476                _depth,
2477            )
2478        }
2479    }
2480    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<QueryIfaceResponse, D>>
2481        fidl::encoding::Encode<DeviceMonitorQueryIfaceResponse, D> for (T0,)
2482    {
2483        #[inline]
2484        unsafe fn encode(
2485            self,
2486            encoder: &mut fidl::encoding::Encoder<'_, D>,
2487            offset: usize,
2488            depth: fidl::encoding::Depth,
2489        ) -> fidl::Result<()> {
2490            encoder.debug_check_bounds::<DeviceMonitorQueryIfaceResponse>(offset);
2491            // Zero out padding regions. There's no need to apply masks
2492            // because the unmasked parts will be overwritten by fields.
2493            // Write the fields.
2494            self.0.encode(encoder, offset + 0, depth)?;
2495            Ok(())
2496        }
2497    }
2498
2499    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2500        for DeviceMonitorQueryIfaceResponse
2501    {
2502        #[inline(always)]
2503        fn new_empty() -> Self {
2504            Self { resp: fidl::new_empty!(QueryIfaceResponse, D) }
2505        }
2506
2507        #[inline]
2508        unsafe fn decode(
2509            &mut self,
2510            decoder: &mut fidl::encoding::Decoder<'_, D>,
2511            offset: usize,
2512            _depth: fidl::encoding::Depth,
2513        ) -> fidl::Result<()> {
2514            decoder.debug_check_bounds::<Self>(offset);
2515            // Verify that padding bytes are zero.
2516            fidl::decode!(QueryIfaceResponse, D, &mut self.resp, decoder, offset + 0, _depth)?;
2517            Ok(())
2518        }
2519    }
2520
2521    impl fidl::encoding::ValueTypeMarker for DeviceWatcherOnIfaceAddedRequest {
2522        type Borrowed<'a> = &'a Self;
2523        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2524            value
2525        }
2526    }
2527
2528    unsafe impl fidl::encoding::TypeMarker for DeviceWatcherOnIfaceAddedRequest {
2529        type Owned = Self;
2530
2531        #[inline(always)]
2532        fn inline_align(_context: fidl::encoding::Context) -> usize {
2533            2
2534        }
2535
2536        #[inline(always)]
2537        fn inline_size(_context: fidl::encoding::Context) -> usize {
2538            2
2539        }
2540        #[inline(always)]
2541        fn encode_is_copy() -> bool {
2542            true
2543        }
2544
2545        #[inline(always)]
2546        fn decode_is_copy() -> bool {
2547            true
2548        }
2549    }
2550
2551    unsafe impl<D: fidl::encoding::ResourceDialect>
2552        fidl::encoding::Encode<DeviceWatcherOnIfaceAddedRequest, D>
2553        for &DeviceWatcherOnIfaceAddedRequest
2554    {
2555        #[inline]
2556        unsafe fn encode(
2557            self,
2558            encoder: &mut fidl::encoding::Encoder<'_, D>,
2559            offset: usize,
2560            _depth: fidl::encoding::Depth,
2561        ) -> fidl::Result<()> {
2562            encoder.debug_check_bounds::<DeviceWatcherOnIfaceAddedRequest>(offset);
2563            unsafe {
2564                // Copy the object into the buffer.
2565                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2566                (buf_ptr as *mut DeviceWatcherOnIfaceAddedRequest)
2567                    .write_unaligned((self as *const DeviceWatcherOnIfaceAddedRequest).read());
2568                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2569                // done second because the memcpy will write garbage to these bytes.
2570            }
2571            Ok(())
2572        }
2573    }
2574    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
2575        fidl::encoding::Encode<DeviceWatcherOnIfaceAddedRequest, D> for (T0,)
2576    {
2577        #[inline]
2578        unsafe fn encode(
2579            self,
2580            encoder: &mut fidl::encoding::Encoder<'_, D>,
2581            offset: usize,
2582            depth: fidl::encoding::Depth,
2583        ) -> fidl::Result<()> {
2584            encoder.debug_check_bounds::<DeviceWatcherOnIfaceAddedRequest>(offset);
2585            // Zero out padding regions. There's no need to apply masks
2586            // because the unmasked parts will be overwritten by fields.
2587            // Write the fields.
2588            self.0.encode(encoder, offset + 0, depth)?;
2589            Ok(())
2590        }
2591    }
2592
2593    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2594        for DeviceWatcherOnIfaceAddedRequest
2595    {
2596        #[inline(always)]
2597        fn new_empty() -> Self {
2598            Self { iface_id: fidl::new_empty!(u16, D) }
2599        }
2600
2601        #[inline]
2602        unsafe fn decode(
2603            &mut self,
2604            decoder: &mut fidl::encoding::Decoder<'_, D>,
2605            offset: usize,
2606            _depth: fidl::encoding::Depth,
2607        ) -> fidl::Result<()> {
2608            decoder.debug_check_bounds::<Self>(offset);
2609            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2610            // Verify that padding bytes are zero.
2611            // Copy from the buffer into the object.
2612            unsafe {
2613                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2614            }
2615            Ok(())
2616        }
2617    }
2618
2619    impl fidl::encoding::ValueTypeMarker for DeviceWatcherOnIfaceRemovedRequest {
2620        type Borrowed<'a> = &'a Self;
2621        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2622            value
2623        }
2624    }
2625
2626    unsafe impl fidl::encoding::TypeMarker for DeviceWatcherOnIfaceRemovedRequest {
2627        type Owned = Self;
2628
2629        #[inline(always)]
2630        fn inline_align(_context: fidl::encoding::Context) -> usize {
2631            2
2632        }
2633
2634        #[inline(always)]
2635        fn inline_size(_context: fidl::encoding::Context) -> usize {
2636            2
2637        }
2638        #[inline(always)]
2639        fn encode_is_copy() -> bool {
2640            true
2641        }
2642
2643        #[inline(always)]
2644        fn decode_is_copy() -> bool {
2645            true
2646        }
2647    }
2648
2649    unsafe impl<D: fidl::encoding::ResourceDialect>
2650        fidl::encoding::Encode<DeviceWatcherOnIfaceRemovedRequest, D>
2651        for &DeviceWatcherOnIfaceRemovedRequest
2652    {
2653        #[inline]
2654        unsafe fn encode(
2655            self,
2656            encoder: &mut fidl::encoding::Encoder<'_, D>,
2657            offset: usize,
2658            _depth: fidl::encoding::Depth,
2659        ) -> fidl::Result<()> {
2660            encoder.debug_check_bounds::<DeviceWatcherOnIfaceRemovedRequest>(offset);
2661            unsafe {
2662                // Copy the object into the buffer.
2663                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2664                (buf_ptr as *mut DeviceWatcherOnIfaceRemovedRequest)
2665                    .write_unaligned((self as *const DeviceWatcherOnIfaceRemovedRequest).read());
2666                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2667                // done second because the memcpy will write garbage to these bytes.
2668            }
2669            Ok(())
2670        }
2671    }
2672    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
2673        fidl::encoding::Encode<DeviceWatcherOnIfaceRemovedRequest, D> for (T0,)
2674    {
2675        #[inline]
2676        unsafe fn encode(
2677            self,
2678            encoder: &mut fidl::encoding::Encoder<'_, D>,
2679            offset: usize,
2680            depth: fidl::encoding::Depth,
2681        ) -> fidl::Result<()> {
2682            encoder.debug_check_bounds::<DeviceWatcherOnIfaceRemovedRequest>(offset);
2683            // Zero out padding regions. There's no need to apply masks
2684            // because the unmasked parts will be overwritten by fields.
2685            // Write the fields.
2686            self.0.encode(encoder, offset + 0, depth)?;
2687            Ok(())
2688        }
2689    }
2690
2691    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2692        for DeviceWatcherOnIfaceRemovedRequest
2693    {
2694        #[inline(always)]
2695        fn new_empty() -> Self {
2696            Self { iface_id: fidl::new_empty!(u16, D) }
2697        }
2698
2699        #[inline]
2700        unsafe fn decode(
2701            &mut self,
2702            decoder: &mut fidl::encoding::Decoder<'_, D>,
2703            offset: usize,
2704            _depth: fidl::encoding::Depth,
2705        ) -> fidl::Result<()> {
2706            decoder.debug_check_bounds::<Self>(offset);
2707            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2708            // Verify that padding bytes are zero.
2709            // Copy from the buffer into the object.
2710            unsafe {
2711                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2712            }
2713            Ok(())
2714        }
2715    }
2716
2717    impl fidl::encoding::ValueTypeMarker for DeviceWatcherOnPhyAddedRequest {
2718        type Borrowed<'a> = &'a Self;
2719        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2720            value
2721        }
2722    }
2723
2724    unsafe impl fidl::encoding::TypeMarker for DeviceWatcherOnPhyAddedRequest {
2725        type Owned = Self;
2726
2727        #[inline(always)]
2728        fn inline_align(_context: fidl::encoding::Context) -> usize {
2729            2
2730        }
2731
2732        #[inline(always)]
2733        fn inline_size(_context: fidl::encoding::Context) -> usize {
2734            2
2735        }
2736        #[inline(always)]
2737        fn encode_is_copy() -> bool {
2738            true
2739        }
2740
2741        #[inline(always)]
2742        fn decode_is_copy() -> bool {
2743            true
2744        }
2745    }
2746
2747    unsafe impl<D: fidl::encoding::ResourceDialect>
2748        fidl::encoding::Encode<DeviceWatcherOnPhyAddedRequest, D>
2749        for &DeviceWatcherOnPhyAddedRequest
2750    {
2751        #[inline]
2752        unsafe fn encode(
2753            self,
2754            encoder: &mut fidl::encoding::Encoder<'_, D>,
2755            offset: usize,
2756            _depth: fidl::encoding::Depth,
2757        ) -> fidl::Result<()> {
2758            encoder.debug_check_bounds::<DeviceWatcherOnPhyAddedRequest>(offset);
2759            unsafe {
2760                // Copy the object into the buffer.
2761                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2762                (buf_ptr as *mut DeviceWatcherOnPhyAddedRequest)
2763                    .write_unaligned((self as *const DeviceWatcherOnPhyAddedRequest).read());
2764                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2765                // done second because the memcpy will write garbage to these bytes.
2766            }
2767            Ok(())
2768        }
2769    }
2770    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
2771        fidl::encoding::Encode<DeviceWatcherOnPhyAddedRequest, D> for (T0,)
2772    {
2773        #[inline]
2774        unsafe fn encode(
2775            self,
2776            encoder: &mut fidl::encoding::Encoder<'_, D>,
2777            offset: usize,
2778            depth: fidl::encoding::Depth,
2779        ) -> fidl::Result<()> {
2780            encoder.debug_check_bounds::<DeviceWatcherOnPhyAddedRequest>(offset);
2781            // Zero out padding regions. There's no need to apply masks
2782            // because the unmasked parts will be overwritten by fields.
2783            // Write the fields.
2784            self.0.encode(encoder, offset + 0, depth)?;
2785            Ok(())
2786        }
2787    }
2788
2789    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2790        for DeviceWatcherOnPhyAddedRequest
2791    {
2792        #[inline(always)]
2793        fn new_empty() -> Self {
2794            Self { phy_id: fidl::new_empty!(u16, D) }
2795        }
2796
2797        #[inline]
2798        unsafe fn decode(
2799            &mut self,
2800            decoder: &mut fidl::encoding::Decoder<'_, D>,
2801            offset: usize,
2802            _depth: fidl::encoding::Depth,
2803        ) -> fidl::Result<()> {
2804            decoder.debug_check_bounds::<Self>(offset);
2805            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2806            // Verify that padding bytes are zero.
2807            // Copy from the buffer into the object.
2808            unsafe {
2809                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2810            }
2811            Ok(())
2812        }
2813    }
2814
2815    impl fidl::encoding::ValueTypeMarker for DeviceWatcherOnPhyRemovedRequest {
2816        type Borrowed<'a> = &'a Self;
2817        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2818            value
2819        }
2820    }
2821
2822    unsafe impl fidl::encoding::TypeMarker for DeviceWatcherOnPhyRemovedRequest {
2823        type Owned = Self;
2824
2825        #[inline(always)]
2826        fn inline_align(_context: fidl::encoding::Context) -> usize {
2827            2
2828        }
2829
2830        #[inline(always)]
2831        fn inline_size(_context: fidl::encoding::Context) -> usize {
2832            2
2833        }
2834        #[inline(always)]
2835        fn encode_is_copy() -> bool {
2836            true
2837        }
2838
2839        #[inline(always)]
2840        fn decode_is_copy() -> bool {
2841            true
2842        }
2843    }
2844
2845    unsafe impl<D: fidl::encoding::ResourceDialect>
2846        fidl::encoding::Encode<DeviceWatcherOnPhyRemovedRequest, D>
2847        for &DeviceWatcherOnPhyRemovedRequest
2848    {
2849        #[inline]
2850        unsafe fn encode(
2851            self,
2852            encoder: &mut fidl::encoding::Encoder<'_, D>,
2853            offset: usize,
2854            _depth: fidl::encoding::Depth,
2855        ) -> fidl::Result<()> {
2856            encoder.debug_check_bounds::<DeviceWatcherOnPhyRemovedRequest>(offset);
2857            unsafe {
2858                // Copy the object into the buffer.
2859                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2860                (buf_ptr as *mut DeviceWatcherOnPhyRemovedRequest)
2861                    .write_unaligned((self as *const DeviceWatcherOnPhyRemovedRequest).read());
2862                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2863                // done second because the memcpy will write garbage to these bytes.
2864            }
2865            Ok(())
2866        }
2867    }
2868    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
2869        fidl::encoding::Encode<DeviceWatcherOnPhyRemovedRequest, D> for (T0,)
2870    {
2871        #[inline]
2872        unsafe fn encode(
2873            self,
2874            encoder: &mut fidl::encoding::Encoder<'_, D>,
2875            offset: usize,
2876            depth: fidl::encoding::Depth,
2877        ) -> fidl::Result<()> {
2878            encoder.debug_check_bounds::<DeviceWatcherOnPhyRemovedRequest>(offset);
2879            // Zero out padding regions. There's no need to apply masks
2880            // because the unmasked parts will be overwritten by fields.
2881            // Write the fields.
2882            self.0.encode(encoder, offset + 0, depth)?;
2883            Ok(())
2884        }
2885    }
2886
2887    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2888        for DeviceWatcherOnPhyRemovedRequest
2889    {
2890        #[inline(always)]
2891        fn new_empty() -> Self {
2892            Self { phy_id: fidl::new_empty!(u16, D) }
2893        }
2894
2895        #[inline]
2896        unsafe fn decode(
2897            &mut self,
2898            decoder: &mut fidl::encoding::Decoder<'_, D>,
2899            offset: usize,
2900            _depth: fidl::encoding::Depth,
2901        ) -> fidl::Result<()> {
2902            decoder.debug_check_bounds::<Self>(offset);
2903            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2904            // Verify that padding bytes are zero.
2905            // Copy from the buffer into the object.
2906            unsafe {
2907                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
2908            }
2909            Ok(())
2910        }
2911    }
2912
2913    impl fidl::encoding::ValueTypeMarker for GetCountryResponse {
2914        type Borrowed<'a> = &'a Self;
2915        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2916            value
2917        }
2918    }
2919
2920    unsafe impl fidl::encoding::TypeMarker for GetCountryResponse {
2921        type Owned = Self;
2922
2923        #[inline(always)]
2924        fn inline_align(_context: fidl::encoding::Context) -> usize {
2925            1
2926        }
2927
2928        #[inline(always)]
2929        fn inline_size(_context: fidl::encoding::Context) -> usize {
2930            2
2931        }
2932        #[inline(always)]
2933        fn encode_is_copy() -> bool {
2934            true
2935        }
2936
2937        #[inline(always)]
2938        fn decode_is_copy() -> bool {
2939            true
2940        }
2941    }
2942
2943    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<GetCountryResponse, D>
2944        for &GetCountryResponse
2945    {
2946        #[inline]
2947        unsafe fn encode(
2948            self,
2949            encoder: &mut fidl::encoding::Encoder<'_, D>,
2950            offset: usize,
2951            _depth: fidl::encoding::Depth,
2952        ) -> fidl::Result<()> {
2953            encoder.debug_check_bounds::<GetCountryResponse>(offset);
2954            unsafe {
2955                // Copy the object into the buffer.
2956                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2957                (buf_ptr as *mut GetCountryResponse)
2958                    .write_unaligned((self as *const GetCountryResponse).read());
2959                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2960                // done second because the memcpy will write garbage to these bytes.
2961            }
2962            Ok(())
2963        }
2964    }
2965    unsafe impl<
2966            D: fidl::encoding::ResourceDialect,
2967            T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 2>, D>,
2968        > fidl::encoding::Encode<GetCountryResponse, D> for (T0,)
2969    {
2970        #[inline]
2971        unsafe fn encode(
2972            self,
2973            encoder: &mut fidl::encoding::Encoder<'_, D>,
2974            offset: usize,
2975            depth: fidl::encoding::Depth,
2976        ) -> fidl::Result<()> {
2977            encoder.debug_check_bounds::<GetCountryResponse>(offset);
2978            // Zero out padding regions. There's no need to apply masks
2979            // because the unmasked parts will be overwritten by fields.
2980            // Write the fields.
2981            self.0.encode(encoder, offset + 0, depth)?;
2982            Ok(())
2983        }
2984    }
2985
2986    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetCountryResponse {
2987        #[inline(always)]
2988        fn new_empty() -> Self {
2989            Self { alpha2: fidl::new_empty!(fidl::encoding::Array<u8, 2>, D) }
2990        }
2991
2992        #[inline]
2993        unsafe fn decode(
2994            &mut self,
2995            decoder: &mut fidl::encoding::Decoder<'_, D>,
2996            offset: usize,
2997            _depth: fidl::encoding::Depth,
2998        ) -> fidl::Result<()> {
2999            decoder.debug_check_bounds::<Self>(offset);
3000            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3001            // Verify that padding bytes are zero.
3002            // Copy from the buffer into the object.
3003            unsafe {
3004                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
3005            }
3006            Ok(())
3007        }
3008    }
3009
3010    impl fidl::encoding::ValueTypeMarker for GetPowerSaveModeResponse {
3011        type Borrowed<'a> = &'a Self;
3012        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3013            value
3014        }
3015    }
3016
3017    unsafe impl fidl::encoding::TypeMarker for GetPowerSaveModeResponse {
3018        type Owned = Self;
3019
3020        #[inline(always)]
3021        fn inline_align(_context: fidl::encoding::Context) -> usize {
3022            4
3023        }
3024
3025        #[inline(always)]
3026        fn inline_size(_context: fidl::encoding::Context) -> usize {
3027            4
3028        }
3029    }
3030
3031    unsafe impl<D: fidl::encoding::ResourceDialect>
3032        fidl::encoding::Encode<GetPowerSaveModeResponse, D> for &GetPowerSaveModeResponse
3033    {
3034        #[inline]
3035        unsafe fn encode(
3036            self,
3037            encoder: &mut fidl::encoding::Encoder<'_, D>,
3038            offset: usize,
3039            _depth: fidl::encoding::Depth,
3040        ) -> fidl::Result<()> {
3041            encoder.debug_check_bounds::<GetPowerSaveModeResponse>(offset);
3042            // Delegate to tuple encoding.
3043            fidl::encoding::Encode::<GetPowerSaveModeResponse, D>::encode(
3044                (
3045                    <fidl_fuchsia_wlan_common__common::PowerSaveType as fidl::encoding::ValueTypeMarker>::borrow(&self.ps_mode),
3046                ),
3047                encoder, offset, _depth
3048            )
3049        }
3050    }
3051    unsafe impl<
3052            D: fidl::encoding::ResourceDialect,
3053            T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::PowerSaveType, D>,
3054        > fidl::encoding::Encode<GetPowerSaveModeResponse, D> for (T0,)
3055    {
3056        #[inline]
3057        unsafe fn encode(
3058            self,
3059            encoder: &mut fidl::encoding::Encoder<'_, D>,
3060            offset: usize,
3061            depth: fidl::encoding::Depth,
3062        ) -> fidl::Result<()> {
3063            encoder.debug_check_bounds::<GetPowerSaveModeResponse>(offset);
3064            // Zero out padding regions. There's no need to apply masks
3065            // because the unmasked parts will be overwritten by fields.
3066            // Write the fields.
3067            self.0.encode(encoder, offset + 0, depth)?;
3068            Ok(())
3069        }
3070    }
3071
3072    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3073        for GetPowerSaveModeResponse
3074    {
3075        #[inline(always)]
3076        fn new_empty() -> Self {
3077            Self { ps_mode: fidl::new_empty!(fidl_fuchsia_wlan_common__common::PowerSaveType, D) }
3078        }
3079
3080        #[inline]
3081        unsafe fn decode(
3082            &mut self,
3083            decoder: &mut fidl::encoding::Decoder<'_, D>,
3084            offset: usize,
3085            _depth: fidl::encoding::Depth,
3086        ) -> fidl::Result<()> {
3087            decoder.debug_check_bounds::<Self>(offset);
3088            // Verify that padding bytes are zero.
3089            fidl::decode!(
3090                fidl_fuchsia_wlan_common__common::PowerSaveType,
3091                D,
3092                &mut self.ps_mode,
3093                decoder,
3094                offset + 0,
3095                _depth
3096            )?;
3097            Ok(())
3098        }
3099    }
3100
3101    impl fidl::encoding::ValueTypeMarker for QueryIfaceResponse {
3102        type Borrowed<'a> = &'a Self;
3103        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3104            value
3105        }
3106    }
3107
3108    unsafe impl fidl::encoding::TypeMarker for QueryIfaceResponse {
3109        type Owned = Self;
3110
3111        #[inline(always)]
3112        fn inline_align(_context: fidl::encoding::Context) -> usize {
3113            4
3114        }
3115
3116        #[inline(always)]
3117        fn inline_size(_context: fidl::encoding::Context) -> usize {
3118            16
3119        }
3120    }
3121
3122    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<QueryIfaceResponse, D>
3123        for &QueryIfaceResponse
3124    {
3125        #[inline]
3126        unsafe fn encode(
3127            self,
3128            encoder: &mut fidl::encoding::Encoder<'_, D>,
3129            offset: usize,
3130            _depth: fidl::encoding::Depth,
3131        ) -> fidl::Result<()> {
3132            encoder.debug_check_bounds::<QueryIfaceResponse>(offset);
3133            // Delegate to tuple encoding.
3134            fidl::encoding::Encode::<QueryIfaceResponse, D>::encode(
3135                (
3136                    <fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::ValueTypeMarker>::borrow(&self.role),
3137                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
3138                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.phy_id),
3139                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.phy_assigned_id),
3140                    <fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow(&self.sta_addr),
3141                ),
3142                encoder, offset, _depth
3143            )
3144        }
3145    }
3146    unsafe impl<
3147            D: fidl::encoding::ResourceDialect,
3148            T0: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::WlanMacRole, D>,
3149            T1: fidl::encoding::Encode<u16, D>,
3150            T2: fidl::encoding::Encode<u16, D>,
3151            T3: fidl::encoding::Encode<u16, D>,
3152            T4: fidl::encoding::Encode<fidl::encoding::Array<u8, 6>, D>,
3153        > fidl::encoding::Encode<QueryIfaceResponse, D> for (T0, T1, T2, T3, T4)
3154    {
3155        #[inline]
3156        unsafe fn encode(
3157            self,
3158            encoder: &mut fidl::encoding::Encoder<'_, D>,
3159            offset: usize,
3160            depth: fidl::encoding::Depth,
3161        ) -> fidl::Result<()> {
3162            encoder.debug_check_bounds::<QueryIfaceResponse>(offset);
3163            // Zero out padding regions. There's no need to apply masks
3164            // because the unmasked parts will be overwritten by fields.
3165            // Write the fields.
3166            self.0.encode(encoder, offset + 0, depth)?;
3167            self.1.encode(encoder, offset + 4, depth)?;
3168            self.2.encode(encoder, offset + 6, depth)?;
3169            self.3.encode(encoder, offset + 8, depth)?;
3170            self.4.encode(encoder, offset + 10, depth)?;
3171            Ok(())
3172        }
3173    }
3174
3175    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for QueryIfaceResponse {
3176        #[inline(always)]
3177        fn new_empty() -> Self {
3178            Self {
3179                role: fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanMacRole, D),
3180                id: fidl::new_empty!(u16, D),
3181                phy_id: fidl::new_empty!(u16, D),
3182                phy_assigned_id: fidl::new_empty!(u16, D),
3183                sta_addr: fidl::new_empty!(fidl::encoding::Array<u8, 6>, D),
3184            }
3185        }
3186
3187        #[inline]
3188        unsafe fn decode(
3189            &mut self,
3190            decoder: &mut fidl::encoding::Decoder<'_, D>,
3191            offset: usize,
3192            _depth: fidl::encoding::Depth,
3193        ) -> fidl::Result<()> {
3194            decoder.debug_check_bounds::<Self>(offset);
3195            // Verify that padding bytes are zero.
3196            fidl::decode!(
3197                fidl_fuchsia_wlan_common__common::WlanMacRole,
3198                D,
3199                &mut self.role,
3200                decoder,
3201                offset + 0,
3202                _depth
3203            )?;
3204            fidl::decode!(u16, D, &mut self.id, decoder, offset + 4, _depth)?;
3205            fidl::decode!(u16, D, &mut self.phy_id, decoder, offset + 6, _depth)?;
3206            fidl::decode!(u16, D, &mut self.phy_assigned_id, decoder, offset + 8, _depth)?;
3207            fidl::decode!(fidl::encoding::Array<u8, 6>, D, &mut self.sta_addr, decoder, offset + 10, _depth)?;
3208            Ok(())
3209        }
3210    }
3211
3212    impl fidl::encoding::ValueTypeMarker for SetCountryRequest {
3213        type Borrowed<'a> = &'a Self;
3214        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3215            value
3216        }
3217    }
3218
3219    unsafe impl fidl::encoding::TypeMarker for SetCountryRequest {
3220        type Owned = Self;
3221
3222        #[inline(always)]
3223        fn inline_align(_context: fidl::encoding::Context) -> usize {
3224            2
3225        }
3226
3227        #[inline(always)]
3228        fn inline_size(_context: fidl::encoding::Context) -> usize {
3229            4
3230        }
3231        #[inline(always)]
3232        fn encode_is_copy() -> bool {
3233            true
3234        }
3235
3236        #[inline(always)]
3237        fn decode_is_copy() -> bool {
3238            true
3239        }
3240    }
3241
3242    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SetCountryRequest, D>
3243        for &SetCountryRequest
3244    {
3245        #[inline]
3246        unsafe fn encode(
3247            self,
3248            encoder: &mut fidl::encoding::Encoder<'_, D>,
3249            offset: usize,
3250            _depth: fidl::encoding::Depth,
3251        ) -> fidl::Result<()> {
3252            encoder.debug_check_bounds::<SetCountryRequest>(offset);
3253            unsafe {
3254                // Copy the object into the buffer.
3255                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3256                (buf_ptr as *mut SetCountryRequest)
3257                    .write_unaligned((self as *const SetCountryRequest).read());
3258                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
3259                // done second because the memcpy will write garbage to these bytes.
3260            }
3261            Ok(())
3262        }
3263    }
3264    unsafe impl<
3265            D: fidl::encoding::ResourceDialect,
3266            T0: fidl::encoding::Encode<u16, D>,
3267            T1: fidl::encoding::Encode<fidl::encoding::Array<u8, 2>, D>,
3268        > fidl::encoding::Encode<SetCountryRequest, D> for (T0, T1)
3269    {
3270        #[inline]
3271        unsafe fn encode(
3272            self,
3273            encoder: &mut fidl::encoding::Encoder<'_, D>,
3274            offset: usize,
3275            depth: fidl::encoding::Depth,
3276        ) -> fidl::Result<()> {
3277            encoder.debug_check_bounds::<SetCountryRequest>(offset);
3278            // Zero out padding regions. There's no need to apply masks
3279            // because the unmasked parts will be overwritten by fields.
3280            // Write the fields.
3281            self.0.encode(encoder, offset + 0, depth)?;
3282            self.1.encode(encoder, offset + 2, depth)?;
3283            Ok(())
3284        }
3285    }
3286
3287    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SetCountryRequest {
3288        #[inline(always)]
3289        fn new_empty() -> Self {
3290            Self {
3291                phy_id: fidl::new_empty!(u16, D),
3292                alpha2: fidl::new_empty!(fidl::encoding::Array<u8, 2>, D),
3293            }
3294        }
3295
3296        #[inline]
3297        unsafe fn decode(
3298            &mut self,
3299            decoder: &mut fidl::encoding::Decoder<'_, D>,
3300            offset: usize,
3301            _depth: fidl::encoding::Depth,
3302        ) -> fidl::Result<()> {
3303            decoder.debug_check_bounds::<Self>(offset);
3304            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3305            // Verify that padding bytes are zero.
3306            // Copy from the buffer into the object.
3307            unsafe {
3308                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
3309            }
3310            Ok(())
3311        }
3312    }
3313
3314    impl fidl::encoding::ValueTypeMarker for SetPowerSaveModeRequest {
3315        type Borrowed<'a> = &'a Self;
3316        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3317            value
3318        }
3319    }
3320
3321    unsafe impl fidl::encoding::TypeMarker for SetPowerSaveModeRequest {
3322        type Owned = Self;
3323
3324        #[inline(always)]
3325        fn inline_align(_context: fidl::encoding::Context) -> usize {
3326            4
3327        }
3328
3329        #[inline(always)]
3330        fn inline_size(_context: fidl::encoding::Context) -> usize {
3331            8
3332        }
3333    }
3334
3335    unsafe impl<D: fidl::encoding::ResourceDialect>
3336        fidl::encoding::Encode<SetPowerSaveModeRequest, D> for &SetPowerSaveModeRequest
3337    {
3338        #[inline]
3339        unsafe fn encode(
3340            self,
3341            encoder: &mut fidl::encoding::Encoder<'_, D>,
3342            offset: usize,
3343            _depth: fidl::encoding::Depth,
3344        ) -> fidl::Result<()> {
3345            encoder.debug_check_bounds::<SetPowerSaveModeRequest>(offset);
3346            // Delegate to tuple encoding.
3347            fidl::encoding::Encode::<SetPowerSaveModeRequest, D>::encode(
3348                (
3349                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.phy_id),
3350                    <fidl_fuchsia_wlan_common__common::PowerSaveType as fidl::encoding::ValueTypeMarker>::borrow(&self.ps_mode),
3351                ),
3352                encoder, offset, _depth
3353            )
3354        }
3355    }
3356    unsafe impl<
3357            D: fidl::encoding::ResourceDialect,
3358            T0: fidl::encoding::Encode<u16, D>,
3359            T1: fidl::encoding::Encode<fidl_fuchsia_wlan_common__common::PowerSaveType, D>,
3360        > fidl::encoding::Encode<SetPowerSaveModeRequest, D> for (T0, T1)
3361    {
3362        #[inline]
3363        unsafe fn encode(
3364            self,
3365            encoder: &mut fidl::encoding::Encoder<'_, D>,
3366            offset: usize,
3367            depth: fidl::encoding::Depth,
3368        ) -> fidl::Result<()> {
3369            encoder.debug_check_bounds::<SetPowerSaveModeRequest>(offset);
3370            // Zero out padding regions. There's no need to apply masks
3371            // because the unmasked parts will be overwritten by fields.
3372            unsafe {
3373                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3374                (ptr as *mut u32).write_unaligned(0);
3375            }
3376            // Write the fields.
3377            self.0.encode(encoder, offset + 0, depth)?;
3378            self.1.encode(encoder, offset + 4, depth)?;
3379            Ok(())
3380        }
3381    }
3382
3383    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3384        for SetPowerSaveModeRequest
3385    {
3386        #[inline(always)]
3387        fn new_empty() -> Self {
3388            Self {
3389                phy_id: fidl::new_empty!(u16, D),
3390                ps_mode: fidl::new_empty!(fidl_fuchsia_wlan_common__common::PowerSaveType, D),
3391            }
3392        }
3393
3394        #[inline]
3395        unsafe fn decode(
3396            &mut self,
3397            decoder: &mut fidl::encoding::Decoder<'_, D>,
3398            offset: usize,
3399            _depth: fidl::encoding::Depth,
3400        ) -> fidl::Result<()> {
3401            decoder.debug_check_bounds::<Self>(offset);
3402            // Verify that padding bytes are zero.
3403            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3404            let padval = unsafe { (ptr as *const u32).read_unaligned() };
3405            let mask = 0xffff0000u32;
3406            let maskedval = padval & mask;
3407            if maskedval != 0 {
3408                return Err(fidl::Error::NonZeroPadding {
3409                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3410                });
3411            }
3412            fidl::decode!(u16, D, &mut self.phy_id, decoder, offset + 0, _depth)?;
3413            fidl::decode!(
3414                fidl_fuchsia_wlan_common__common::PowerSaveType,
3415                D,
3416                &mut self.ps_mode,
3417                decoder,
3418                offset + 4,
3419                _depth
3420            )?;
3421            Ok(())
3422        }
3423    }
3424
3425    impl DeviceMonitorCreateIfaceRequest {
3426        #[inline(always)]
3427        fn max_ordinal_present(&self) -> u64 {
3428            if let Some(_) = self.sta_address {
3429                return 3;
3430            }
3431            if let Some(_) = self.role {
3432                return 2;
3433            }
3434            if let Some(_) = self.phy_id {
3435                return 1;
3436            }
3437            0
3438        }
3439    }
3440
3441    impl fidl::encoding::ValueTypeMarker for DeviceMonitorCreateIfaceRequest {
3442        type Borrowed<'a> = &'a Self;
3443        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3444            value
3445        }
3446    }
3447
3448    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorCreateIfaceRequest {
3449        type Owned = Self;
3450
3451        #[inline(always)]
3452        fn inline_align(_context: fidl::encoding::Context) -> usize {
3453            8
3454        }
3455
3456        #[inline(always)]
3457        fn inline_size(_context: fidl::encoding::Context) -> usize {
3458            16
3459        }
3460    }
3461
3462    unsafe impl<D: fidl::encoding::ResourceDialect>
3463        fidl::encoding::Encode<DeviceMonitorCreateIfaceRequest, D>
3464        for &DeviceMonitorCreateIfaceRequest
3465    {
3466        unsafe fn encode(
3467            self,
3468            encoder: &mut fidl::encoding::Encoder<'_, D>,
3469            offset: usize,
3470            mut depth: fidl::encoding::Depth,
3471        ) -> fidl::Result<()> {
3472            encoder.debug_check_bounds::<DeviceMonitorCreateIfaceRequest>(offset);
3473            // Vector header
3474            let max_ordinal: u64 = self.max_ordinal_present();
3475            encoder.write_num(max_ordinal, offset);
3476            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3477            // Calling encoder.out_of_line_offset(0) is not allowed.
3478            if max_ordinal == 0 {
3479                return Ok(());
3480            }
3481            depth.increment()?;
3482            let envelope_size = 8;
3483            let bytes_len = max_ordinal as usize * envelope_size;
3484            #[allow(unused_variables)]
3485            let offset = encoder.out_of_line_offset(bytes_len);
3486            let mut _prev_end_offset: usize = 0;
3487            if 1 > max_ordinal {
3488                return Ok(());
3489            }
3490
3491            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3492            // are envelope_size bytes.
3493            let cur_offset: usize = (1 - 1) * envelope_size;
3494
3495            // Zero reserved fields.
3496            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3497
3498            // Safety:
3499            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3500            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3501            //   envelope_size bytes, there is always sufficient room.
3502            fidl::encoding::encode_in_envelope_optional::<u16, D>(
3503                self.phy_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3504                encoder,
3505                offset + cur_offset,
3506                depth,
3507            )?;
3508
3509            _prev_end_offset = cur_offset + envelope_size;
3510            if 2 > max_ordinal {
3511                return Ok(());
3512            }
3513
3514            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3515            // are envelope_size bytes.
3516            let cur_offset: usize = (2 - 1) * envelope_size;
3517
3518            // Zero reserved fields.
3519            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3520
3521            // Safety:
3522            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3523            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3524            //   envelope_size bytes, there is always sufficient room.
3525            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_wlan_common__common::WlanMacRole, D>(
3526            self.role.as_ref().map(<fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::ValueTypeMarker>::borrow),
3527            encoder, offset + cur_offset, depth
3528        )?;
3529
3530            _prev_end_offset = cur_offset + envelope_size;
3531            if 3 > max_ordinal {
3532                return Ok(());
3533            }
3534
3535            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3536            // are envelope_size bytes.
3537            let cur_offset: usize = (3 - 1) * envelope_size;
3538
3539            // Zero reserved fields.
3540            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3541
3542            // Safety:
3543            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3544            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3545            //   envelope_size bytes, there is always sufficient room.
3546            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
3547                self.sta_address
3548                    .as_ref()
3549                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
3550                encoder,
3551                offset + cur_offset,
3552                depth,
3553            )?;
3554
3555            _prev_end_offset = cur_offset + envelope_size;
3556
3557            Ok(())
3558        }
3559    }
3560
3561    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3562        for DeviceMonitorCreateIfaceRequest
3563    {
3564        #[inline(always)]
3565        fn new_empty() -> Self {
3566            Self::default()
3567        }
3568
3569        unsafe fn decode(
3570            &mut self,
3571            decoder: &mut fidl::encoding::Decoder<'_, D>,
3572            offset: usize,
3573            mut depth: fidl::encoding::Depth,
3574        ) -> fidl::Result<()> {
3575            decoder.debug_check_bounds::<Self>(offset);
3576            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3577                None => return Err(fidl::Error::NotNullable),
3578                Some(len) => len,
3579            };
3580            // Calling decoder.out_of_line_offset(0) is not allowed.
3581            if len == 0 {
3582                return Ok(());
3583            };
3584            depth.increment()?;
3585            let envelope_size = 8;
3586            let bytes_len = len * envelope_size;
3587            let offset = decoder.out_of_line_offset(bytes_len)?;
3588            // Decode the envelope for each type.
3589            let mut _next_ordinal_to_read = 0;
3590            let mut next_offset = offset;
3591            let end_offset = offset + bytes_len;
3592            _next_ordinal_to_read += 1;
3593            if next_offset >= end_offset {
3594                return Ok(());
3595            }
3596
3597            // Decode unknown envelopes for gaps in ordinals.
3598            while _next_ordinal_to_read < 1 {
3599                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3600                _next_ordinal_to_read += 1;
3601                next_offset += envelope_size;
3602            }
3603
3604            let next_out_of_line = decoder.next_out_of_line();
3605            let handles_before = decoder.remaining_handles();
3606            if let Some((inlined, num_bytes, num_handles)) =
3607                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3608            {
3609                let member_inline_size =
3610                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3611                if inlined != (member_inline_size <= 4) {
3612                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3613                }
3614                let inner_offset;
3615                let mut inner_depth = depth.clone();
3616                if inlined {
3617                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3618                    inner_offset = next_offset;
3619                } else {
3620                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3621                    inner_depth.increment()?;
3622                }
3623                let val_ref = self.phy_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
3624                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3625                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3626                {
3627                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3628                }
3629                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3630                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3631                }
3632            }
3633
3634            next_offset += envelope_size;
3635            _next_ordinal_to_read += 1;
3636            if next_offset >= end_offset {
3637                return Ok(());
3638            }
3639
3640            // Decode unknown envelopes for gaps in ordinals.
3641            while _next_ordinal_to_read < 2 {
3642                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3643                _next_ordinal_to_read += 1;
3644                next_offset += envelope_size;
3645            }
3646
3647            let next_out_of_line = decoder.next_out_of_line();
3648            let handles_before = decoder.remaining_handles();
3649            if let Some((inlined, num_bytes, num_handles)) =
3650                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3651            {
3652                let member_inline_size = <fidl_fuchsia_wlan_common__common::WlanMacRole as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3653                if inlined != (member_inline_size <= 4) {
3654                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3655                }
3656                let inner_offset;
3657                let mut inner_depth = depth.clone();
3658                if inlined {
3659                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3660                    inner_offset = next_offset;
3661                } else {
3662                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3663                    inner_depth.increment()?;
3664                }
3665                let val_ref = self.role.get_or_insert_with(|| {
3666                    fidl::new_empty!(fidl_fuchsia_wlan_common__common::WlanMacRole, D)
3667                });
3668                fidl::decode!(
3669                    fidl_fuchsia_wlan_common__common::WlanMacRole,
3670                    D,
3671                    val_ref,
3672                    decoder,
3673                    inner_offset,
3674                    inner_depth
3675                )?;
3676                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3677                {
3678                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3679                }
3680                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3681                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3682                }
3683            }
3684
3685            next_offset += envelope_size;
3686            _next_ordinal_to_read += 1;
3687            if next_offset >= end_offset {
3688                return Ok(());
3689            }
3690
3691            // Decode unknown envelopes for gaps in ordinals.
3692            while _next_ordinal_to_read < 3 {
3693                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3694                _next_ordinal_to_read += 1;
3695                next_offset += envelope_size;
3696            }
3697
3698            let next_out_of_line = decoder.next_out_of_line();
3699            let handles_before = decoder.remaining_handles();
3700            if let Some((inlined, num_bytes, num_handles)) =
3701                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3702            {
3703                let member_inline_size =
3704                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
3705                        decoder.context,
3706                    );
3707                if inlined != (member_inline_size <= 4) {
3708                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3709                }
3710                let inner_offset;
3711                let mut inner_depth = depth.clone();
3712                if inlined {
3713                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3714                    inner_offset = next_offset;
3715                } else {
3716                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3717                    inner_depth.increment()?;
3718                }
3719                let val_ref = self
3720                    .sta_address
3721                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
3722                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
3723                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3724                {
3725                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3726                }
3727                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3728                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3729                }
3730            }
3731
3732            next_offset += envelope_size;
3733
3734            // Decode the remaining unknown envelopes.
3735            while next_offset < end_offset {
3736                _next_ordinal_to_read += 1;
3737                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3738                next_offset += envelope_size;
3739            }
3740
3741            Ok(())
3742        }
3743    }
3744
3745    impl DeviceMonitorCreateIfaceResponse {
3746        #[inline(always)]
3747        fn max_ordinal_present(&self) -> u64 {
3748            if let Some(_) = self.iface_id {
3749                return 1;
3750            }
3751            0
3752        }
3753    }
3754
3755    impl fidl::encoding::ValueTypeMarker for DeviceMonitorCreateIfaceResponse {
3756        type Borrowed<'a> = &'a Self;
3757        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3758            value
3759        }
3760    }
3761
3762    unsafe impl fidl::encoding::TypeMarker for DeviceMonitorCreateIfaceResponse {
3763        type Owned = Self;
3764
3765        #[inline(always)]
3766        fn inline_align(_context: fidl::encoding::Context) -> usize {
3767            8
3768        }
3769
3770        #[inline(always)]
3771        fn inline_size(_context: fidl::encoding::Context) -> usize {
3772            16
3773        }
3774    }
3775
3776    unsafe impl<D: fidl::encoding::ResourceDialect>
3777        fidl::encoding::Encode<DeviceMonitorCreateIfaceResponse, D>
3778        for &DeviceMonitorCreateIfaceResponse
3779    {
3780        unsafe fn encode(
3781            self,
3782            encoder: &mut fidl::encoding::Encoder<'_, D>,
3783            offset: usize,
3784            mut depth: fidl::encoding::Depth,
3785        ) -> fidl::Result<()> {
3786            encoder.debug_check_bounds::<DeviceMonitorCreateIfaceResponse>(offset);
3787            // Vector header
3788            let max_ordinal: u64 = self.max_ordinal_present();
3789            encoder.write_num(max_ordinal, offset);
3790            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3791            // Calling encoder.out_of_line_offset(0) is not allowed.
3792            if max_ordinal == 0 {
3793                return Ok(());
3794            }
3795            depth.increment()?;
3796            let envelope_size = 8;
3797            let bytes_len = max_ordinal as usize * envelope_size;
3798            #[allow(unused_variables)]
3799            let offset = encoder.out_of_line_offset(bytes_len);
3800            let mut _prev_end_offset: usize = 0;
3801            if 1 > max_ordinal {
3802                return Ok(());
3803            }
3804
3805            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3806            // are envelope_size bytes.
3807            let cur_offset: usize = (1 - 1) * envelope_size;
3808
3809            // Zero reserved fields.
3810            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3811
3812            // Safety:
3813            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3814            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3815            //   envelope_size bytes, there is always sufficient room.
3816            fidl::encoding::encode_in_envelope_optional::<u16, D>(
3817                self.iface_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3818                encoder,
3819                offset + cur_offset,
3820                depth,
3821            )?;
3822
3823            _prev_end_offset = cur_offset + envelope_size;
3824
3825            Ok(())
3826        }
3827    }
3828
3829    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3830        for DeviceMonitorCreateIfaceResponse
3831    {
3832        #[inline(always)]
3833        fn new_empty() -> Self {
3834            Self::default()
3835        }
3836
3837        unsafe fn decode(
3838            &mut self,
3839            decoder: &mut fidl::encoding::Decoder<'_, D>,
3840            offset: usize,
3841            mut depth: fidl::encoding::Depth,
3842        ) -> fidl::Result<()> {
3843            decoder.debug_check_bounds::<Self>(offset);
3844            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3845                None => return Err(fidl::Error::NotNullable),
3846                Some(len) => len,
3847            };
3848            // Calling decoder.out_of_line_offset(0) is not allowed.
3849            if len == 0 {
3850                return Ok(());
3851            };
3852            depth.increment()?;
3853            let envelope_size = 8;
3854            let bytes_len = len * envelope_size;
3855            let offset = decoder.out_of_line_offset(bytes_len)?;
3856            // Decode the envelope for each type.
3857            let mut _next_ordinal_to_read = 0;
3858            let mut next_offset = offset;
3859            let end_offset = offset + bytes_len;
3860            _next_ordinal_to_read += 1;
3861            if next_offset >= end_offset {
3862                return Ok(());
3863            }
3864
3865            // Decode unknown envelopes for gaps in ordinals.
3866            while _next_ordinal_to_read < 1 {
3867                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3868                _next_ordinal_to_read += 1;
3869                next_offset += envelope_size;
3870            }
3871
3872            let next_out_of_line = decoder.next_out_of_line();
3873            let handles_before = decoder.remaining_handles();
3874            if let Some((inlined, num_bytes, num_handles)) =
3875                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3876            {
3877                let member_inline_size =
3878                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3879                if inlined != (member_inline_size <= 4) {
3880                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3881                }
3882                let inner_offset;
3883                let mut inner_depth = depth.clone();
3884                if inlined {
3885                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3886                    inner_offset = next_offset;
3887                } else {
3888                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3889                    inner_depth.increment()?;
3890                }
3891                let val_ref = self.iface_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
3892                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3893                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3894                {
3895                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3896                }
3897                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3898                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3899                }
3900            }
3901
3902            next_offset += envelope_size;
3903
3904            // Decode the remaining unknown envelopes.
3905            while next_offset < end_offset {
3906                _next_ordinal_to_read += 1;
3907                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3908                next_offset += envelope_size;
3909            }
3910
3911            Ok(())
3912        }
3913    }
3914
3915    impl fidl::encoding::ValueTypeMarker for GetIfaceHistogramStatsResponse {
3916        type Borrowed<'a> = &'a Self;
3917        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3918            value
3919        }
3920    }
3921
3922    unsafe impl fidl::encoding::TypeMarker for GetIfaceHistogramStatsResponse {
3923        type Owned = Self;
3924
3925        #[inline(always)]
3926        fn inline_align(_context: fidl::encoding::Context) -> usize {
3927            8
3928        }
3929
3930        #[inline(always)]
3931        fn inline_size(_context: fidl::encoding::Context) -> usize {
3932            16
3933        }
3934    }
3935
3936    unsafe impl<D: fidl::encoding::ResourceDialect>
3937        fidl::encoding::Encode<GetIfaceHistogramStatsResponse, D>
3938        for &GetIfaceHistogramStatsResponse
3939    {
3940        #[inline]
3941        unsafe fn encode(
3942            self,
3943            encoder: &mut fidl::encoding::Encoder<'_, D>,
3944            offset: usize,
3945            _depth: fidl::encoding::Depth,
3946        ) -> fidl::Result<()> {
3947            encoder.debug_check_bounds::<GetIfaceHistogramStatsResponse>(offset);
3948            encoder.write_num::<u64>(self.ordinal(), offset);
3949            match self {
3950            GetIfaceHistogramStatsResponse::Stats(ref val) => {
3951                fidl::encoding::encode_in_envelope::<fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D>(
3952                    <fidl_fuchsia_wlan_stats__common::IfaceHistogramStats as fidl::encoding::ValueTypeMarker>::borrow(val),
3953                    encoder, offset + 8, _depth
3954                )
3955            }
3956            GetIfaceHistogramStatsResponse::ErrorStatus(ref val) => {
3957                fidl::encoding::encode_in_envelope::<i32, D>(
3958                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
3959                    encoder, offset + 8, _depth
3960                )
3961            }
3962        }
3963        }
3964    }
3965
3966    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3967        for GetIfaceHistogramStatsResponse
3968    {
3969        #[inline(always)]
3970        fn new_empty() -> Self {
3971            Self::Stats(fidl::new_empty!(fidl_fuchsia_wlan_stats__common::IfaceHistogramStats, D))
3972        }
3973
3974        #[inline]
3975        unsafe fn decode(
3976            &mut self,
3977            decoder: &mut fidl::encoding::Decoder<'_, D>,
3978            offset: usize,
3979            mut depth: fidl::encoding::Depth,
3980        ) -> fidl::Result<()> {
3981            decoder.debug_check_bounds::<Self>(offset);
3982            #[allow(unused_variables)]
3983            let next_out_of_line = decoder.next_out_of_line();
3984            let handles_before = decoder.remaining_handles();
3985            let (ordinal, inlined, num_bytes, num_handles) =
3986                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
3987
3988            let member_inline_size = match ordinal {
3989            1 => <fidl_fuchsia_wlan_stats__common::IfaceHistogramStats as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3990            2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3991            _ => return Err(fidl::Error::UnknownUnionTag),
3992        };
3993
3994            if inlined != (member_inline_size <= 4) {
3995                return Err(fidl::Error::InvalidInlineBitInEnvelope);
3996            }
3997            let _inner_offset;
3998            if inlined {
3999                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4000                _inner_offset = offset + 8;
4001            } else {
4002                depth.increment()?;
4003                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4004            }
4005            match ordinal {
4006                1 => {
4007                    #[allow(irrefutable_let_patterns)]
4008                    if let GetIfaceHistogramStatsResponse::Stats(_) = self {
4009                        // Do nothing, read the value into the object
4010                    } else {
4011                        // Initialize `self` to the right variant
4012                        *self = GetIfaceHistogramStatsResponse::Stats(fidl::new_empty!(
4013                            fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
4014                            D
4015                        ));
4016                    }
4017                    #[allow(irrefutable_let_patterns)]
4018                    if let GetIfaceHistogramStatsResponse::Stats(ref mut val) = self {
4019                        fidl::decode!(
4020                            fidl_fuchsia_wlan_stats__common::IfaceHistogramStats,
4021                            D,
4022                            val,
4023                            decoder,
4024                            _inner_offset,
4025                            depth
4026                        )?;
4027                    } else {
4028                        unreachable!()
4029                    }
4030                }
4031                2 => {
4032                    #[allow(irrefutable_let_patterns)]
4033                    if let GetIfaceHistogramStatsResponse::ErrorStatus(_) = self {
4034                        // Do nothing, read the value into the object
4035                    } else {
4036                        // Initialize `self` to the right variant
4037                        *self =
4038                            GetIfaceHistogramStatsResponse::ErrorStatus(fidl::new_empty!(i32, D));
4039                    }
4040                    #[allow(irrefutable_let_patterns)]
4041                    if let GetIfaceHistogramStatsResponse::ErrorStatus(ref mut val) = self {
4042                        fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
4043                    } else {
4044                        unreachable!()
4045                    }
4046                }
4047                ordinal => panic!("unexpected ordinal {:?}", ordinal),
4048            }
4049            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
4050                return Err(fidl::Error::InvalidNumBytesInEnvelope);
4051            }
4052            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4053                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4054            }
4055            Ok(())
4056        }
4057    }
4058}