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