fidl_fuchsia_hardware_hidbus__common/
fidl_fuchsia_hardware_hidbus__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
11pub type ReportId = u8;
12
13pub const MAX_DESC_LEN: u16 = 8192;
14
15pub const MAX_REPORT_DATA: u16 = 8192;
16
17pub const MAX_REPORT_LEN: u16 = 8192;
18
19/// HID 1.11 Chapter 4.3 Protocols
20#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
21#[repr(u8)]
22pub enum HidBootProtocol {
23    None = 0,
24    Kbd = 1,
25    Pointer = 2,
26    Other = 3,
27}
28
29impl HidBootProtocol {
30    #[inline]
31    pub fn from_primitive(prim: u8) -> Option<Self> {
32        match prim {
33            0 => Some(Self::None),
34            1 => Some(Self::Kbd),
35            2 => Some(Self::Pointer),
36            3 => Some(Self::Other),
37            _ => None,
38        }
39    }
40
41    #[inline]
42    pub const fn into_primitive(self) -> u8 {
43        self as u8
44    }
45}
46
47/// HID 1.11 Chapter 7.1 Class Descriptor Types
48#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
49#[repr(u8)]
50pub enum HidDescriptorType {
51    Hid = 33,
52    Report = 34,
53    Physical = 35,
54}
55
56impl HidDescriptorType {
57    #[inline]
58    pub fn from_primitive(prim: u8) -> Option<Self> {
59        match prim {
60            33 => Some(Self::Hid),
61            34 => Some(Self::Report),
62            35 => Some(Self::Physical),
63            _ => None,
64        }
65    }
66
67    #[inline]
68    pub const fn into_primitive(self) -> u8 {
69        self as u8
70    }
71}
72
73/// HID 1.11 Chapter 4.2 Subclass
74#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
75#[repr(u8)]
76pub enum HidProtocol {
77    Boot = 0,
78    Report = 1,
79}
80
81impl HidProtocol {
82    #[inline]
83    pub fn from_primitive(prim: u8) -> Option<Self> {
84        match prim {
85            0 => Some(Self::Boot),
86            1 => Some(Self::Report),
87            _ => None,
88        }
89    }
90
91    #[inline]
92    pub const fn into_primitive(self) -> u8 {
93        self as u8
94    }
95}
96
97#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
98#[repr(u8)]
99pub enum ReportType {
100    Input = 1,
101    Output = 2,
102    Feature = 3,
103}
104
105impl ReportType {
106    #[inline]
107    pub fn from_primitive(prim: u8) -> Option<Self> {
108        match prim {
109            1 => Some(Self::Input),
110            2 => Some(Self::Output),
111            3 => Some(Self::Feature),
112            _ => None,
113        }
114    }
115
116    #[inline]
117    pub const fn into_primitive(self) -> u8 {
118        self as u8
119    }
120}
121
122#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
123pub struct HidbusGetDescriptorRequest {
124    pub desc_type: HidDescriptorType,
125}
126
127impl fidl::Persistable for HidbusGetDescriptorRequest {}
128
129#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
130#[repr(C)]
131pub struct HidbusGetIdleRequest {
132    pub rpt_id: u8,
133}
134
135impl fidl::Persistable for HidbusGetIdleRequest {}
136
137#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
138pub struct HidbusGetReportRequest {
139    pub rpt_type: ReportType,
140    pub rpt_id: u8,
141    pub len: u64,
142}
143
144impl fidl::Persistable for HidbusGetReportRequest {}
145
146#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
147pub struct HidbusSetDescriptorRequest {
148    pub desc_type: HidDescriptorType,
149    pub data: Vec<u8>,
150}
151
152impl fidl::Persistable for HidbusSetDescriptorRequest {}
153
154#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
155#[repr(C)]
156pub struct HidbusSetIdleRequest {
157    pub rpt_id: u8,
158    pub duration: i64,
159}
160
161impl fidl::Persistable for HidbusSetIdleRequest {}
162
163#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
164pub struct HidbusSetProtocolRequest {
165    pub protocol: HidProtocol,
166}
167
168impl fidl::Persistable for HidbusSetProtocolRequest {}
169
170#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
171pub struct HidbusSetReportRequest {
172    pub rpt_type: ReportType,
173    pub rpt_id: u8,
174    pub data: Vec<u8>,
175}
176
177impl fidl::Persistable for HidbusSetReportRequest {}
178
179#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
180pub struct HidbusGetDescriptorResponse {
181    pub data: Vec<u8>,
182}
183
184impl fidl::Persistable for HidbusGetDescriptorResponse {}
185
186#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
187#[repr(C)]
188pub struct HidbusGetIdleResponse {
189    pub duration: i64,
190}
191
192impl fidl::Persistable for HidbusGetIdleResponse {}
193
194#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
195pub struct HidbusGetProtocolResponse {
196    pub protocol: HidProtocol,
197}
198
199impl fidl::Persistable for HidbusGetProtocolResponse {}
200
201#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
202pub struct HidbusGetReportResponse {
203    pub data: Vec<u8>,
204}
205
206impl fidl::Persistable for HidbusGetReportResponse {}
207
208#[derive(Clone, Debug, PartialEq)]
209pub struct HidbusQueryResponse {
210    pub info: HidInfo,
211}
212
213impl fidl::Persistable for HidbusQueryResponse {}
214
215#[derive(Clone, Debug, Default, PartialEq)]
216pub struct HidInfo {
217    pub dev_num: Option<u8>,
218    pub boot_protocol: Option<HidBootProtocol>,
219    pub vendor_id: Option<u32>,
220    pub product_id: Option<u32>,
221    pub version: Option<u32>,
222    /// polling rate if applicable in usec
223    pub polling_rate: Option<i64>,
224    #[doc(hidden)]
225    pub __source_breaking: fidl::marker::SourceBreaking,
226}
227
228impl fidl::Persistable for HidInfo {}
229
230pub mod hidbus_ordinals {
231    pub const QUERY: u64 = 0x23eb61f83d06efa9;
232    pub const START: u64 = 0x1ba15adf96bade4a;
233    pub const STOP: u64 = 0x61b973ecd69cfff8;
234    pub const ON_REPORT_RECEIVED: u64 = 0x6093963f2efe1e56;
235    pub const GET_DESCRIPTOR: u64 = 0x29343a1289ceb2e5;
236    pub const SET_DESCRIPTOR: u64 = 0x7567278eba076777;
237    pub const GET_REPORT: u64 = 0x69b5538a28dc472c;
238    pub const SET_REPORT: u64 = 0x1172863081673c55;
239    pub const GET_IDLE: u64 = 0xa95c2c504d9aa0b;
240    pub const SET_IDLE: u64 = 0x7c387cbaa4c09b3c;
241    pub const GET_PROTOCOL: u64 = 0x3ec61a9b2d5c50eb;
242    pub const SET_PROTOCOL: u64 = 0x1655cdfd0f316b0b;
243}
244
245mod internal {
246    use super::*;
247    unsafe impl fidl::encoding::TypeMarker for HidBootProtocol {
248        type Owned = Self;
249
250        #[inline(always)]
251        fn inline_align(_context: fidl::encoding::Context) -> usize {
252            std::mem::align_of::<u8>()
253        }
254
255        #[inline(always)]
256        fn inline_size(_context: fidl::encoding::Context) -> usize {
257            std::mem::size_of::<u8>()
258        }
259
260        #[inline(always)]
261        fn encode_is_copy() -> bool {
262            true
263        }
264
265        #[inline(always)]
266        fn decode_is_copy() -> bool {
267            false
268        }
269    }
270
271    impl fidl::encoding::ValueTypeMarker for HidBootProtocol {
272        type Borrowed<'a> = Self;
273        #[inline(always)]
274        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
275            *value
276        }
277    }
278
279    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
280        for HidBootProtocol
281    {
282        #[inline]
283        unsafe fn encode(
284            self,
285            encoder: &mut fidl::encoding::Encoder<'_, D>,
286            offset: usize,
287            _depth: fidl::encoding::Depth,
288        ) -> fidl::Result<()> {
289            encoder.debug_check_bounds::<Self>(offset);
290            encoder.write_num(self.into_primitive(), offset);
291            Ok(())
292        }
293    }
294
295    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidBootProtocol {
296        #[inline(always)]
297        fn new_empty() -> Self {
298            Self::None
299        }
300
301        #[inline]
302        unsafe fn decode(
303            &mut self,
304            decoder: &mut fidl::encoding::Decoder<'_, D>,
305            offset: usize,
306            _depth: fidl::encoding::Depth,
307        ) -> fidl::Result<()> {
308            decoder.debug_check_bounds::<Self>(offset);
309            let prim = decoder.read_num::<u8>(offset);
310
311            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
312            Ok(())
313        }
314    }
315    unsafe impl fidl::encoding::TypeMarker for HidDescriptorType {
316        type Owned = Self;
317
318        #[inline(always)]
319        fn inline_align(_context: fidl::encoding::Context) -> usize {
320            std::mem::align_of::<u8>()
321        }
322
323        #[inline(always)]
324        fn inline_size(_context: fidl::encoding::Context) -> usize {
325            std::mem::size_of::<u8>()
326        }
327
328        #[inline(always)]
329        fn encode_is_copy() -> bool {
330            true
331        }
332
333        #[inline(always)]
334        fn decode_is_copy() -> bool {
335            false
336        }
337    }
338
339    impl fidl::encoding::ValueTypeMarker for HidDescriptorType {
340        type Borrowed<'a> = Self;
341        #[inline(always)]
342        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
343            *value
344        }
345    }
346
347    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
348        for HidDescriptorType
349    {
350        #[inline]
351        unsafe fn encode(
352            self,
353            encoder: &mut fidl::encoding::Encoder<'_, D>,
354            offset: usize,
355            _depth: fidl::encoding::Depth,
356        ) -> fidl::Result<()> {
357            encoder.debug_check_bounds::<Self>(offset);
358            encoder.write_num(self.into_primitive(), offset);
359            Ok(())
360        }
361    }
362
363    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidDescriptorType {
364        #[inline(always)]
365        fn new_empty() -> Self {
366            Self::Hid
367        }
368
369        #[inline]
370        unsafe fn decode(
371            &mut self,
372            decoder: &mut fidl::encoding::Decoder<'_, D>,
373            offset: usize,
374            _depth: fidl::encoding::Depth,
375        ) -> fidl::Result<()> {
376            decoder.debug_check_bounds::<Self>(offset);
377            let prim = decoder.read_num::<u8>(offset);
378
379            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
380            Ok(())
381        }
382    }
383    unsafe impl fidl::encoding::TypeMarker for HidProtocol {
384        type Owned = Self;
385
386        #[inline(always)]
387        fn inline_align(_context: fidl::encoding::Context) -> usize {
388            std::mem::align_of::<u8>()
389        }
390
391        #[inline(always)]
392        fn inline_size(_context: fidl::encoding::Context) -> usize {
393            std::mem::size_of::<u8>()
394        }
395
396        #[inline(always)]
397        fn encode_is_copy() -> bool {
398            true
399        }
400
401        #[inline(always)]
402        fn decode_is_copy() -> bool {
403            false
404        }
405    }
406
407    impl fidl::encoding::ValueTypeMarker for HidProtocol {
408        type Borrowed<'a> = Self;
409        #[inline(always)]
410        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
411            *value
412        }
413    }
414
415    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for HidProtocol {
416        #[inline]
417        unsafe fn encode(
418            self,
419            encoder: &mut fidl::encoding::Encoder<'_, D>,
420            offset: usize,
421            _depth: fidl::encoding::Depth,
422        ) -> fidl::Result<()> {
423            encoder.debug_check_bounds::<Self>(offset);
424            encoder.write_num(self.into_primitive(), offset);
425            Ok(())
426        }
427    }
428
429    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidProtocol {
430        #[inline(always)]
431        fn new_empty() -> Self {
432            Self::Boot
433        }
434
435        #[inline]
436        unsafe fn decode(
437            &mut self,
438            decoder: &mut fidl::encoding::Decoder<'_, D>,
439            offset: usize,
440            _depth: fidl::encoding::Depth,
441        ) -> fidl::Result<()> {
442            decoder.debug_check_bounds::<Self>(offset);
443            let prim = decoder.read_num::<u8>(offset);
444
445            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
446            Ok(())
447        }
448    }
449    unsafe impl fidl::encoding::TypeMarker for ReportType {
450        type Owned = Self;
451
452        #[inline(always)]
453        fn inline_align(_context: fidl::encoding::Context) -> usize {
454            std::mem::align_of::<u8>()
455        }
456
457        #[inline(always)]
458        fn inline_size(_context: fidl::encoding::Context) -> usize {
459            std::mem::size_of::<u8>()
460        }
461
462        #[inline(always)]
463        fn encode_is_copy() -> bool {
464            true
465        }
466
467        #[inline(always)]
468        fn decode_is_copy() -> bool {
469            false
470        }
471    }
472
473    impl fidl::encoding::ValueTypeMarker for ReportType {
474        type Borrowed<'a> = Self;
475        #[inline(always)]
476        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
477            *value
478        }
479    }
480
481    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ReportType {
482        #[inline]
483        unsafe fn encode(
484            self,
485            encoder: &mut fidl::encoding::Encoder<'_, D>,
486            offset: usize,
487            _depth: fidl::encoding::Depth,
488        ) -> fidl::Result<()> {
489            encoder.debug_check_bounds::<Self>(offset);
490            encoder.write_num(self.into_primitive(), offset);
491            Ok(())
492        }
493    }
494
495    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ReportType {
496        #[inline(always)]
497        fn new_empty() -> Self {
498            Self::Input
499        }
500
501        #[inline]
502        unsafe fn decode(
503            &mut self,
504            decoder: &mut fidl::encoding::Decoder<'_, D>,
505            offset: usize,
506            _depth: fidl::encoding::Depth,
507        ) -> fidl::Result<()> {
508            decoder.debug_check_bounds::<Self>(offset);
509            let prim = decoder.read_num::<u8>(offset);
510
511            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
512            Ok(())
513        }
514    }
515
516    impl fidl::encoding::ValueTypeMarker for HidbusGetDescriptorRequest {
517        type Borrowed<'a> = &'a Self;
518        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
519            value
520        }
521    }
522
523    unsafe impl fidl::encoding::TypeMarker for HidbusGetDescriptorRequest {
524        type Owned = Self;
525
526        #[inline(always)]
527        fn inline_align(_context: fidl::encoding::Context) -> usize {
528            1
529        }
530
531        #[inline(always)]
532        fn inline_size(_context: fidl::encoding::Context) -> usize {
533            1
534        }
535    }
536
537    unsafe impl<D: fidl::encoding::ResourceDialect>
538        fidl::encoding::Encode<HidbusGetDescriptorRequest, D> for &HidbusGetDescriptorRequest
539    {
540        #[inline]
541        unsafe fn encode(
542            self,
543            encoder: &mut fidl::encoding::Encoder<'_, D>,
544            offset: usize,
545            _depth: fidl::encoding::Depth,
546        ) -> fidl::Result<()> {
547            encoder.debug_check_bounds::<HidbusGetDescriptorRequest>(offset);
548            // Delegate to tuple encoding.
549            fidl::encoding::Encode::<HidbusGetDescriptorRequest, D>::encode(
550                (<HidDescriptorType as fidl::encoding::ValueTypeMarker>::borrow(&self.desc_type),),
551                encoder,
552                offset,
553                _depth,
554            )
555        }
556    }
557    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<HidDescriptorType, D>>
558        fidl::encoding::Encode<HidbusGetDescriptorRequest, D> for (T0,)
559    {
560        #[inline]
561        unsafe fn encode(
562            self,
563            encoder: &mut fidl::encoding::Encoder<'_, D>,
564            offset: usize,
565            depth: fidl::encoding::Depth,
566        ) -> fidl::Result<()> {
567            encoder.debug_check_bounds::<HidbusGetDescriptorRequest>(offset);
568            // Zero out padding regions. There's no need to apply masks
569            // because the unmasked parts will be overwritten by fields.
570            // Write the fields.
571            self.0.encode(encoder, offset + 0, depth)?;
572            Ok(())
573        }
574    }
575
576    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
577        for HidbusGetDescriptorRequest
578    {
579        #[inline(always)]
580        fn new_empty() -> Self {
581            Self { desc_type: fidl::new_empty!(HidDescriptorType, D) }
582        }
583
584        #[inline]
585        unsafe fn decode(
586            &mut self,
587            decoder: &mut fidl::encoding::Decoder<'_, D>,
588            offset: usize,
589            _depth: fidl::encoding::Depth,
590        ) -> fidl::Result<()> {
591            decoder.debug_check_bounds::<Self>(offset);
592            // Verify that padding bytes are zero.
593            fidl::decode!(HidDescriptorType, D, &mut self.desc_type, decoder, offset + 0, _depth)?;
594            Ok(())
595        }
596    }
597
598    impl fidl::encoding::ValueTypeMarker for HidbusGetIdleRequest {
599        type Borrowed<'a> = &'a Self;
600        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
601            value
602        }
603    }
604
605    unsafe impl fidl::encoding::TypeMarker for HidbusGetIdleRequest {
606        type Owned = Self;
607
608        #[inline(always)]
609        fn inline_align(_context: fidl::encoding::Context) -> usize {
610            1
611        }
612
613        #[inline(always)]
614        fn inline_size(_context: fidl::encoding::Context) -> usize {
615            1
616        }
617        #[inline(always)]
618        fn encode_is_copy() -> bool {
619            true
620        }
621
622        #[inline(always)]
623        fn decode_is_copy() -> bool {
624            true
625        }
626    }
627
628    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HidbusGetIdleRequest, D>
629        for &HidbusGetIdleRequest
630    {
631        #[inline]
632        unsafe fn encode(
633            self,
634            encoder: &mut fidl::encoding::Encoder<'_, D>,
635            offset: usize,
636            _depth: fidl::encoding::Depth,
637        ) -> fidl::Result<()> {
638            encoder.debug_check_bounds::<HidbusGetIdleRequest>(offset);
639            unsafe {
640                // Copy the object into the buffer.
641                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
642                (buf_ptr as *mut HidbusGetIdleRequest)
643                    .write_unaligned((self as *const HidbusGetIdleRequest).read());
644                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
645                // done second because the memcpy will write garbage to these bytes.
646            }
647            Ok(())
648        }
649    }
650    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
651        fidl::encoding::Encode<HidbusGetIdleRequest, D> for (T0,)
652    {
653        #[inline]
654        unsafe fn encode(
655            self,
656            encoder: &mut fidl::encoding::Encoder<'_, D>,
657            offset: usize,
658            depth: fidl::encoding::Depth,
659        ) -> fidl::Result<()> {
660            encoder.debug_check_bounds::<HidbusGetIdleRequest>(offset);
661            // Zero out padding regions. There's no need to apply masks
662            // because the unmasked parts will be overwritten by fields.
663            // Write the fields.
664            self.0.encode(encoder, offset + 0, depth)?;
665            Ok(())
666        }
667    }
668
669    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidbusGetIdleRequest {
670        #[inline(always)]
671        fn new_empty() -> Self {
672            Self { rpt_id: fidl::new_empty!(u8, D) }
673        }
674
675        #[inline]
676        unsafe fn decode(
677            &mut self,
678            decoder: &mut fidl::encoding::Decoder<'_, D>,
679            offset: usize,
680            _depth: fidl::encoding::Depth,
681        ) -> fidl::Result<()> {
682            decoder.debug_check_bounds::<Self>(offset);
683            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
684            // Verify that padding bytes are zero.
685            // Copy from the buffer into the object.
686            unsafe {
687                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
688            }
689            Ok(())
690        }
691    }
692
693    impl fidl::encoding::ValueTypeMarker for HidbusGetReportRequest {
694        type Borrowed<'a> = &'a Self;
695        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
696            value
697        }
698    }
699
700    unsafe impl fidl::encoding::TypeMarker for HidbusGetReportRequest {
701        type Owned = Self;
702
703        #[inline(always)]
704        fn inline_align(_context: fidl::encoding::Context) -> usize {
705            8
706        }
707
708        #[inline(always)]
709        fn inline_size(_context: fidl::encoding::Context) -> usize {
710            16
711        }
712    }
713
714    unsafe impl<D: fidl::encoding::ResourceDialect>
715        fidl::encoding::Encode<HidbusGetReportRequest, D> for &HidbusGetReportRequest
716    {
717        #[inline]
718        unsafe fn encode(
719            self,
720            encoder: &mut fidl::encoding::Encoder<'_, D>,
721            offset: usize,
722            _depth: fidl::encoding::Depth,
723        ) -> fidl::Result<()> {
724            encoder.debug_check_bounds::<HidbusGetReportRequest>(offset);
725            // Delegate to tuple encoding.
726            fidl::encoding::Encode::<HidbusGetReportRequest, D>::encode(
727                (
728                    <ReportType as fidl::encoding::ValueTypeMarker>::borrow(&self.rpt_type),
729                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.rpt_id),
730                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.len),
731                ),
732                encoder,
733                offset,
734                _depth,
735            )
736        }
737    }
738    unsafe impl<
739            D: fidl::encoding::ResourceDialect,
740            T0: fidl::encoding::Encode<ReportType, D>,
741            T1: fidl::encoding::Encode<u8, D>,
742            T2: fidl::encoding::Encode<u64, D>,
743        > fidl::encoding::Encode<HidbusGetReportRequest, D> for (T0, T1, T2)
744    {
745        #[inline]
746        unsafe fn encode(
747            self,
748            encoder: &mut fidl::encoding::Encoder<'_, D>,
749            offset: usize,
750            depth: fidl::encoding::Depth,
751        ) -> fidl::Result<()> {
752            encoder.debug_check_bounds::<HidbusGetReportRequest>(offset);
753            // Zero out padding regions. There's no need to apply masks
754            // because the unmasked parts will be overwritten by fields.
755            unsafe {
756                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
757                (ptr as *mut u64).write_unaligned(0);
758            }
759            // Write the fields.
760            self.0.encode(encoder, offset + 0, depth)?;
761            self.1.encode(encoder, offset + 1, depth)?;
762            self.2.encode(encoder, offset + 8, depth)?;
763            Ok(())
764        }
765    }
766
767    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
768        for HidbusGetReportRequest
769    {
770        #[inline(always)]
771        fn new_empty() -> Self {
772            Self {
773                rpt_type: fidl::new_empty!(ReportType, D),
774                rpt_id: fidl::new_empty!(u8, D),
775                len: fidl::new_empty!(u64, D),
776            }
777        }
778
779        #[inline]
780        unsafe fn decode(
781            &mut self,
782            decoder: &mut fidl::encoding::Decoder<'_, D>,
783            offset: usize,
784            _depth: fidl::encoding::Depth,
785        ) -> fidl::Result<()> {
786            decoder.debug_check_bounds::<Self>(offset);
787            // Verify that padding bytes are zero.
788            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
789            let padval = unsafe { (ptr as *const u64).read_unaligned() };
790            let mask = 0xffffffffffff0000u64;
791            let maskedval = padval & mask;
792            if maskedval != 0 {
793                return Err(fidl::Error::NonZeroPadding {
794                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
795                });
796            }
797            fidl::decode!(ReportType, D, &mut self.rpt_type, decoder, offset + 0, _depth)?;
798            fidl::decode!(u8, D, &mut self.rpt_id, decoder, offset + 1, _depth)?;
799            fidl::decode!(u64, D, &mut self.len, decoder, offset + 8, _depth)?;
800            Ok(())
801        }
802    }
803
804    impl fidl::encoding::ValueTypeMarker for HidbusSetDescriptorRequest {
805        type Borrowed<'a> = &'a Self;
806        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
807            value
808        }
809    }
810
811    unsafe impl fidl::encoding::TypeMarker for HidbusSetDescriptorRequest {
812        type Owned = Self;
813
814        #[inline(always)]
815        fn inline_align(_context: fidl::encoding::Context) -> usize {
816            8
817        }
818
819        #[inline(always)]
820        fn inline_size(_context: fidl::encoding::Context) -> usize {
821            24
822        }
823    }
824
825    unsafe impl<D: fidl::encoding::ResourceDialect>
826        fidl::encoding::Encode<HidbusSetDescriptorRequest, D> for &HidbusSetDescriptorRequest
827    {
828        #[inline]
829        unsafe fn encode(
830            self,
831            encoder: &mut fidl::encoding::Encoder<'_, D>,
832            offset: usize,
833            _depth: fidl::encoding::Depth,
834        ) -> fidl::Result<()> {
835            encoder.debug_check_bounds::<HidbusSetDescriptorRequest>(offset);
836            // Delegate to tuple encoding.
837            fidl::encoding::Encode::<HidbusSetDescriptorRequest, D>::encode(
838                (
839                    <HidDescriptorType as fidl::encoding::ValueTypeMarker>::borrow(&self.desc_type),
840                    <fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
841                        &self.data,
842                    ),
843                ),
844                encoder,
845                offset,
846                _depth,
847            )
848        }
849    }
850    unsafe impl<
851            D: fidl::encoding::ResourceDialect,
852            T0: fidl::encoding::Encode<HidDescriptorType, D>,
853            T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
854        > fidl::encoding::Encode<HidbusSetDescriptorRequest, D> for (T0, T1)
855    {
856        #[inline]
857        unsafe fn encode(
858            self,
859            encoder: &mut fidl::encoding::Encoder<'_, D>,
860            offset: usize,
861            depth: fidl::encoding::Depth,
862        ) -> fidl::Result<()> {
863            encoder.debug_check_bounds::<HidbusSetDescriptorRequest>(offset);
864            // Zero out padding regions. There's no need to apply masks
865            // because the unmasked parts will be overwritten by fields.
866            unsafe {
867                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
868                (ptr as *mut u64).write_unaligned(0);
869            }
870            // Write the fields.
871            self.0.encode(encoder, offset + 0, depth)?;
872            self.1.encode(encoder, offset + 8, depth)?;
873            Ok(())
874        }
875    }
876
877    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
878        for HidbusSetDescriptorRequest
879    {
880        #[inline(always)]
881        fn new_empty() -> Self {
882            Self {
883                desc_type: fidl::new_empty!(HidDescriptorType, D),
884                data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D),
885            }
886        }
887
888        #[inline]
889        unsafe fn decode(
890            &mut self,
891            decoder: &mut fidl::encoding::Decoder<'_, D>,
892            offset: usize,
893            _depth: fidl::encoding::Depth,
894        ) -> fidl::Result<()> {
895            decoder.debug_check_bounds::<Self>(offset);
896            // Verify that padding bytes are zero.
897            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
898            let padval = unsafe { (ptr as *const u64).read_unaligned() };
899            let mask = 0xffffffffffffff00u64;
900            let maskedval = padval & mask;
901            if maskedval != 0 {
902                return Err(fidl::Error::NonZeroPadding {
903                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
904                });
905            }
906            fidl::decode!(HidDescriptorType, D, &mut self.desc_type, decoder, offset + 0, _depth)?;
907            fidl::decode!(fidl::encoding::Vector<u8, 8192>, D, &mut self.data, decoder, offset + 8, _depth)?;
908            Ok(())
909        }
910    }
911
912    impl fidl::encoding::ValueTypeMarker for HidbusSetIdleRequest {
913        type Borrowed<'a> = &'a Self;
914        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
915            value
916        }
917    }
918
919    unsafe impl fidl::encoding::TypeMarker for HidbusSetIdleRequest {
920        type Owned = Self;
921
922        #[inline(always)]
923        fn inline_align(_context: fidl::encoding::Context) -> usize {
924            8
925        }
926
927        #[inline(always)]
928        fn inline_size(_context: fidl::encoding::Context) -> usize {
929            16
930        }
931    }
932
933    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HidbusSetIdleRequest, D>
934        for &HidbusSetIdleRequest
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::<HidbusSetIdleRequest>(offset);
944            unsafe {
945                // Copy the object into the buffer.
946                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
947                (buf_ptr as *mut HidbusSetIdleRequest)
948                    .write_unaligned((self as *const HidbusSetIdleRequest).read());
949                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
950                // done second because the memcpy will write garbage to these bytes.
951                let padding_ptr = buf_ptr.offset(0) as *mut u64;
952                let padding_mask = 0xffffffffffffff00u64;
953                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
954            }
955            Ok(())
956        }
957    }
958    unsafe impl<
959            D: fidl::encoding::ResourceDialect,
960            T0: fidl::encoding::Encode<u8, D>,
961            T1: fidl::encoding::Encode<i64, D>,
962        > fidl::encoding::Encode<HidbusSetIdleRequest, D> for (T0, T1)
963    {
964        #[inline]
965        unsafe fn encode(
966            self,
967            encoder: &mut fidl::encoding::Encoder<'_, D>,
968            offset: usize,
969            depth: fidl::encoding::Depth,
970        ) -> fidl::Result<()> {
971            encoder.debug_check_bounds::<HidbusSetIdleRequest>(offset);
972            // Zero out padding regions. There's no need to apply masks
973            // because the unmasked parts will be overwritten by fields.
974            unsafe {
975                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
976                (ptr as *mut u64).write_unaligned(0);
977            }
978            // Write the fields.
979            self.0.encode(encoder, offset + 0, depth)?;
980            self.1.encode(encoder, offset + 8, depth)?;
981            Ok(())
982        }
983    }
984
985    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidbusSetIdleRequest {
986        #[inline(always)]
987        fn new_empty() -> Self {
988            Self { rpt_id: fidl::new_empty!(u8, D), duration: fidl::new_empty!(i64, D) }
989        }
990
991        #[inline]
992        unsafe fn decode(
993            &mut self,
994            decoder: &mut fidl::encoding::Decoder<'_, D>,
995            offset: usize,
996            _depth: fidl::encoding::Depth,
997        ) -> fidl::Result<()> {
998            decoder.debug_check_bounds::<Self>(offset);
999            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1000            // Verify that padding bytes are zero.
1001            let ptr = unsafe { buf_ptr.offset(0) };
1002            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1003            let mask = 0xffffffffffffff00u64;
1004            let maskedval = padval & mask;
1005            if maskedval != 0 {
1006                return Err(fidl::Error::NonZeroPadding {
1007                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1008                });
1009            }
1010            // Copy from the buffer into the object.
1011            unsafe {
1012                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
1013            }
1014            Ok(())
1015        }
1016    }
1017
1018    impl fidl::encoding::ValueTypeMarker for HidbusSetProtocolRequest {
1019        type Borrowed<'a> = &'a Self;
1020        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1021            value
1022        }
1023    }
1024
1025    unsafe impl fidl::encoding::TypeMarker for HidbusSetProtocolRequest {
1026        type Owned = Self;
1027
1028        #[inline(always)]
1029        fn inline_align(_context: fidl::encoding::Context) -> usize {
1030            1
1031        }
1032
1033        #[inline(always)]
1034        fn inline_size(_context: fidl::encoding::Context) -> usize {
1035            1
1036        }
1037    }
1038
1039    unsafe impl<D: fidl::encoding::ResourceDialect>
1040        fidl::encoding::Encode<HidbusSetProtocolRequest, D> for &HidbusSetProtocolRequest
1041    {
1042        #[inline]
1043        unsafe fn encode(
1044            self,
1045            encoder: &mut fidl::encoding::Encoder<'_, D>,
1046            offset: usize,
1047            _depth: fidl::encoding::Depth,
1048        ) -> fidl::Result<()> {
1049            encoder.debug_check_bounds::<HidbusSetProtocolRequest>(offset);
1050            // Delegate to tuple encoding.
1051            fidl::encoding::Encode::<HidbusSetProtocolRequest, D>::encode(
1052                (<HidProtocol as fidl::encoding::ValueTypeMarker>::borrow(&self.protocol),),
1053                encoder,
1054                offset,
1055                _depth,
1056            )
1057        }
1058    }
1059    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<HidProtocol, D>>
1060        fidl::encoding::Encode<HidbusSetProtocolRequest, D> for (T0,)
1061    {
1062        #[inline]
1063        unsafe fn encode(
1064            self,
1065            encoder: &mut fidl::encoding::Encoder<'_, D>,
1066            offset: usize,
1067            depth: fidl::encoding::Depth,
1068        ) -> fidl::Result<()> {
1069            encoder.debug_check_bounds::<HidbusSetProtocolRequest>(offset);
1070            // Zero out padding regions. There's no need to apply masks
1071            // because the unmasked parts will be overwritten by fields.
1072            // Write the fields.
1073            self.0.encode(encoder, offset + 0, depth)?;
1074            Ok(())
1075        }
1076    }
1077
1078    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1079        for HidbusSetProtocolRequest
1080    {
1081        #[inline(always)]
1082        fn new_empty() -> Self {
1083            Self { protocol: fidl::new_empty!(HidProtocol, D) }
1084        }
1085
1086        #[inline]
1087        unsafe fn decode(
1088            &mut self,
1089            decoder: &mut fidl::encoding::Decoder<'_, D>,
1090            offset: usize,
1091            _depth: fidl::encoding::Depth,
1092        ) -> fidl::Result<()> {
1093            decoder.debug_check_bounds::<Self>(offset);
1094            // Verify that padding bytes are zero.
1095            fidl::decode!(HidProtocol, D, &mut self.protocol, decoder, offset + 0, _depth)?;
1096            Ok(())
1097        }
1098    }
1099
1100    impl fidl::encoding::ValueTypeMarker for HidbusSetReportRequest {
1101        type Borrowed<'a> = &'a Self;
1102        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1103            value
1104        }
1105    }
1106
1107    unsafe impl fidl::encoding::TypeMarker for HidbusSetReportRequest {
1108        type Owned = Self;
1109
1110        #[inline(always)]
1111        fn inline_align(_context: fidl::encoding::Context) -> usize {
1112            8
1113        }
1114
1115        #[inline(always)]
1116        fn inline_size(_context: fidl::encoding::Context) -> usize {
1117            24
1118        }
1119    }
1120
1121    unsafe impl<D: fidl::encoding::ResourceDialect>
1122        fidl::encoding::Encode<HidbusSetReportRequest, D> for &HidbusSetReportRequest
1123    {
1124        #[inline]
1125        unsafe fn encode(
1126            self,
1127            encoder: &mut fidl::encoding::Encoder<'_, D>,
1128            offset: usize,
1129            _depth: fidl::encoding::Depth,
1130        ) -> fidl::Result<()> {
1131            encoder.debug_check_bounds::<HidbusSetReportRequest>(offset);
1132            // Delegate to tuple encoding.
1133            fidl::encoding::Encode::<HidbusSetReportRequest, D>::encode(
1134                (
1135                    <ReportType as fidl::encoding::ValueTypeMarker>::borrow(&self.rpt_type),
1136                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.rpt_id),
1137                    <fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
1138                        &self.data,
1139                    ),
1140                ),
1141                encoder,
1142                offset,
1143                _depth,
1144            )
1145        }
1146    }
1147    unsafe impl<
1148            D: fidl::encoding::ResourceDialect,
1149            T0: fidl::encoding::Encode<ReportType, D>,
1150            T1: fidl::encoding::Encode<u8, D>,
1151            T2: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
1152        > fidl::encoding::Encode<HidbusSetReportRequest, D> for (T0, T1, T2)
1153    {
1154        #[inline]
1155        unsafe fn encode(
1156            self,
1157            encoder: &mut fidl::encoding::Encoder<'_, D>,
1158            offset: usize,
1159            depth: fidl::encoding::Depth,
1160        ) -> fidl::Result<()> {
1161            encoder.debug_check_bounds::<HidbusSetReportRequest>(offset);
1162            // Zero out padding regions. There's no need to apply masks
1163            // because the unmasked parts will be overwritten by fields.
1164            unsafe {
1165                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1166                (ptr as *mut u64).write_unaligned(0);
1167            }
1168            // Write the fields.
1169            self.0.encode(encoder, offset + 0, depth)?;
1170            self.1.encode(encoder, offset + 1, depth)?;
1171            self.2.encode(encoder, offset + 8, depth)?;
1172            Ok(())
1173        }
1174    }
1175
1176    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1177        for HidbusSetReportRequest
1178    {
1179        #[inline(always)]
1180        fn new_empty() -> Self {
1181            Self {
1182                rpt_type: fidl::new_empty!(ReportType, D),
1183                rpt_id: fidl::new_empty!(u8, D),
1184                data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D),
1185            }
1186        }
1187
1188        #[inline]
1189        unsafe fn decode(
1190            &mut self,
1191            decoder: &mut fidl::encoding::Decoder<'_, D>,
1192            offset: usize,
1193            _depth: fidl::encoding::Depth,
1194        ) -> fidl::Result<()> {
1195            decoder.debug_check_bounds::<Self>(offset);
1196            // Verify that padding bytes are zero.
1197            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1198            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1199            let mask = 0xffffffffffff0000u64;
1200            let maskedval = padval & mask;
1201            if maskedval != 0 {
1202                return Err(fidl::Error::NonZeroPadding {
1203                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1204                });
1205            }
1206            fidl::decode!(ReportType, D, &mut self.rpt_type, decoder, offset + 0, _depth)?;
1207            fidl::decode!(u8, D, &mut self.rpt_id, decoder, offset + 1, _depth)?;
1208            fidl::decode!(fidl::encoding::Vector<u8, 8192>, D, &mut self.data, decoder, offset + 8, _depth)?;
1209            Ok(())
1210        }
1211    }
1212
1213    impl fidl::encoding::ValueTypeMarker for HidbusGetDescriptorResponse {
1214        type Borrowed<'a> = &'a Self;
1215        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1216            value
1217        }
1218    }
1219
1220    unsafe impl fidl::encoding::TypeMarker for HidbusGetDescriptorResponse {
1221        type Owned = Self;
1222
1223        #[inline(always)]
1224        fn inline_align(_context: fidl::encoding::Context) -> usize {
1225            8
1226        }
1227
1228        #[inline(always)]
1229        fn inline_size(_context: fidl::encoding::Context) -> usize {
1230            16
1231        }
1232    }
1233
1234    unsafe impl<D: fidl::encoding::ResourceDialect>
1235        fidl::encoding::Encode<HidbusGetDescriptorResponse, D> for &HidbusGetDescriptorResponse
1236    {
1237        #[inline]
1238        unsafe fn encode(
1239            self,
1240            encoder: &mut fidl::encoding::Encoder<'_, D>,
1241            offset: usize,
1242            _depth: fidl::encoding::Depth,
1243        ) -> fidl::Result<()> {
1244            encoder.debug_check_bounds::<HidbusGetDescriptorResponse>(offset);
1245            // Delegate to tuple encoding.
1246            fidl::encoding::Encode::<HidbusGetDescriptorResponse, D>::encode(
1247                (<fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
1248                    &self.data,
1249                ),),
1250                encoder,
1251                offset,
1252                _depth,
1253            )
1254        }
1255    }
1256    unsafe impl<
1257            D: fidl::encoding::ResourceDialect,
1258            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
1259        > fidl::encoding::Encode<HidbusGetDescriptorResponse, D> for (T0,)
1260    {
1261        #[inline]
1262        unsafe fn encode(
1263            self,
1264            encoder: &mut fidl::encoding::Encoder<'_, D>,
1265            offset: usize,
1266            depth: fidl::encoding::Depth,
1267        ) -> fidl::Result<()> {
1268            encoder.debug_check_bounds::<HidbusGetDescriptorResponse>(offset);
1269            // Zero out padding regions. There's no need to apply masks
1270            // because the unmasked parts will be overwritten by fields.
1271            // Write the fields.
1272            self.0.encode(encoder, offset + 0, depth)?;
1273            Ok(())
1274        }
1275    }
1276
1277    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1278        for HidbusGetDescriptorResponse
1279    {
1280        #[inline(always)]
1281        fn new_empty() -> Self {
1282            Self { data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D) }
1283        }
1284
1285        #[inline]
1286        unsafe fn decode(
1287            &mut self,
1288            decoder: &mut fidl::encoding::Decoder<'_, D>,
1289            offset: usize,
1290            _depth: fidl::encoding::Depth,
1291        ) -> fidl::Result<()> {
1292            decoder.debug_check_bounds::<Self>(offset);
1293            // Verify that padding bytes are zero.
1294            fidl::decode!(fidl::encoding::Vector<u8, 8192>, D, &mut self.data, decoder, offset + 0, _depth)?;
1295            Ok(())
1296        }
1297    }
1298
1299    impl fidl::encoding::ValueTypeMarker for HidbusGetIdleResponse {
1300        type Borrowed<'a> = &'a Self;
1301        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1302            value
1303        }
1304    }
1305
1306    unsafe impl fidl::encoding::TypeMarker for HidbusGetIdleResponse {
1307        type Owned = Self;
1308
1309        #[inline(always)]
1310        fn inline_align(_context: fidl::encoding::Context) -> usize {
1311            8
1312        }
1313
1314        #[inline(always)]
1315        fn inline_size(_context: fidl::encoding::Context) -> usize {
1316            8
1317        }
1318        #[inline(always)]
1319        fn encode_is_copy() -> bool {
1320            true
1321        }
1322
1323        #[inline(always)]
1324        fn decode_is_copy() -> bool {
1325            true
1326        }
1327    }
1328
1329    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HidbusGetIdleResponse, D>
1330        for &HidbusGetIdleResponse
1331    {
1332        #[inline]
1333        unsafe fn encode(
1334            self,
1335            encoder: &mut fidl::encoding::Encoder<'_, D>,
1336            offset: usize,
1337            _depth: fidl::encoding::Depth,
1338        ) -> fidl::Result<()> {
1339            encoder.debug_check_bounds::<HidbusGetIdleResponse>(offset);
1340            unsafe {
1341                // Copy the object into the buffer.
1342                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1343                (buf_ptr as *mut HidbusGetIdleResponse)
1344                    .write_unaligned((self as *const HidbusGetIdleResponse).read());
1345                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1346                // done second because the memcpy will write garbage to these bytes.
1347            }
1348            Ok(())
1349        }
1350    }
1351    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i64, D>>
1352        fidl::encoding::Encode<HidbusGetIdleResponse, D> for (T0,)
1353    {
1354        #[inline]
1355        unsafe fn encode(
1356            self,
1357            encoder: &mut fidl::encoding::Encoder<'_, D>,
1358            offset: usize,
1359            depth: fidl::encoding::Depth,
1360        ) -> fidl::Result<()> {
1361            encoder.debug_check_bounds::<HidbusGetIdleResponse>(offset);
1362            // Zero out padding regions. There's no need to apply masks
1363            // because the unmasked parts will be overwritten by fields.
1364            // Write the fields.
1365            self.0.encode(encoder, offset + 0, depth)?;
1366            Ok(())
1367        }
1368    }
1369
1370    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidbusGetIdleResponse {
1371        #[inline(always)]
1372        fn new_empty() -> Self {
1373            Self { duration: fidl::new_empty!(i64, D) }
1374        }
1375
1376        #[inline]
1377        unsafe fn decode(
1378            &mut self,
1379            decoder: &mut fidl::encoding::Decoder<'_, D>,
1380            offset: usize,
1381            _depth: fidl::encoding::Depth,
1382        ) -> fidl::Result<()> {
1383            decoder.debug_check_bounds::<Self>(offset);
1384            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1385            // Verify that padding bytes are zero.
1386            // Copy from the buffer into the object.
1387            unsafe {
1388                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
1389            }
1390            Ok(())
1391        }
1392    }
1393
1394    impl fidl::encoding::ValueTypeMarker for HidbusGetProtocolResponse {
1395        type Borrowed<'a> = &'a Self;
1396        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1397            value
1398        }
1399    }
1400
1401    unsafe impl fidl::encoding::TypeMarker for HidbusGetProtocolResponse {
1402        type Owned = Self;
1403
1404        #[inline(always)]
1405        fn inline_align(_context: fidl::encoding::Context) -> usize {
1406            1
1407        }
1408
1409        #[inline(always)]
1410        fn inline_size(_context: fidl::encoding::Context) -> usize {
1411            1
1412        }
1413    }
1414
1415    unsafe impl<D: fidl::encoding::ResourceDialect>
1416        fidl::encoding::Encode<HidbusGetProtocolResponse, D> for &HidbusGetProtocolResponse
1417    {
1418        #[inline]
1419        unsafe fn encode(
1420            self,
1421            encoder: &mut fidl::encoding::Encoder<'_, D>,
1422            offset: usize,
1423            _depth: fidl::encoding::Depth,
1424        ) -> fidl::Result<()> {
1425            encoder.debug_check_bounds::<HidbusGetProtocolResponse>(offset);
1426            // Delegate to tuple encoding.
1427            fidl::encoding::Encode::<HidbusGetProtocolResponse, D>::encode(
1428                (<HidProtocol as fidl::encoding::ValueTypeMarker>::borrow(&self.protocol),),
1429                encoder,
1430                offset,
1431                _depth,
1432            )
1433        }
1434    }
1435    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<HidProtocol, D>>
1436        fidl::encoding::Encode<HidbusGetProtocolResponse, D> for (T0,)
1437    {
1438        #[inline]
1439        unsafe fn encode(
1440            self,
1441            encoder: &mut fidl::encoding::Encoder<'_, D>,
1442            offset: usize,
1443            depth: fidl::encoding::Depth,
1444        ) -> fidl::Result<()> {
1445            encoder.debug_check_bounds::<HidbusGetProtocolResponse>(offset);
1446            // Zero out padding regions. There's no need to apply masks
1447            // because the unmasked parts will be overwritten by fields.
1448            // Write the fields.
1449            self.0.encode(encoder, offset + 0, depth)?;
1450            Ok(())
1451        }
1452    }
1453
1454    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1455        for HidbusGetProtocolResponse
1456    {
1457        #[inline(always)]
1458        fn new_empty() -> Self {
1459            Self { protocol: fidl::new_empty!(HidProtocol, D) }
1460        }
1461
1462        #[inline]
1463        unsafe fn decode(
1464            &mut self,
1465            decoder: &mut fidl::encoding::Decoder<'_, D>,
1466            offset: usize,
1467            _depth: fidl::encoding::Depth,
1468        ) -> fidl::Result<()> {
1469            decoder.debug_check_bounds::<Self>(offset);
1470            // Verify that padding bytes are zero.
1471            fidl::decode!(HidProtocol, D, &mut self.protocol, decoder, offset + 0, _depth)?;
1472            Ok(())
1473        }
1474    }
1475
1476    impl fidl::encoding::ValueTypeMarker for HidbusGetReportResponse {
1477        type Borrowed<'a> = &'a Self;
1478        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1479            value
1480        }
1481    }
1482
1483    unsafe impl fidl::encoding::TypeMarker for HidbusGetReportResponse {
1484        type Owned = Self;
1485
1486        #[inline(always)]
1487        fn inline_align(_context: fidl::encoding::Context) -> usize {
1488            8
1489        }
1490
1491        #[inline(always)]
1492        fn inline_size(_context: fidl::encoding::Context) -> usize {
1493            16
1494        }
1495    }
1496
1497    unsafe impl<D: fidl::encoding::ResourceDialect>
1498        fidl::encoding::Encode<HidbusGetReportResponse, D> for &HidbusGetReportResponse
1499    {
1500        #[inline]
1501        unsafe fn encode(
1502            self,
1503            encoder: &mut fidl::encoding::Encoder<'_, D>,
1504            offset: usize,
1505            _depth: fidl::encoding::Depth,
1506        ) -> fidl::Result<()> {
1507            encoder.debug_check_bounds::<HidbusGetReportResponse>(offset);
1508            // Delegate to tuple encoding.
1509            fidl::encoding::Encode::<HidbusGetReportResponse, D>::encode(
1510                (<fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
1511                    &self.data,
1512                ),),
1513                encoder,
1514                offset,
1515                _depth,
1516            )
1517        }
1518    }
1519    unsafe impl<
1520            D: fidl::encoding::ResourceDialect,
1521            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
1522        > fidl::encoding::Encode<HidbusGetReportResponse, D> for (T0,)
1523    {
1524        #[inline]
1525        unsafe fn encode(
1526            self,
1527            encoder: &mut fidl::encoding::Encoder<'_, D>,
1528            offset: usize,
1529            depth: fidl::encoding::Depth,
1530        ) -> fidl::Result<()> {
1531            encoder.debug_check_bounds::<HidbusGetReportResponse>(offset);
1532            // Zero out padding regions. There's no need to apply masks
1533            // because the unmasked parts will be overwritten by fields.
1534            // Write the fields.
1535            self.0.encode(encoder, offset + 0, depth)?;
1536            Ok(())
1537        }
1538    }
1539
1540    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1541        for HidbusGetReportResponse
1542    {
1543        #[inline(always)]
1544        fn new_empty() -> Self {
1545            Self { data: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D) }
1546        }
1547
1548        #[inline]
1549        unsafe fn decode(
1550            &mut self,
1551            decoder: &mut fidl::encoding::Decoder<'_, D>,
1552            offset: usize,
1553            _depth: fidl::encoding::Depth,
1554        ) -> fidl::Result<()> {
1555            decoder.debug_check_bounds::<Self>(offset);
1556            // Verify that padding bytes are zero.
1557            fidl::decode!(fidl::encoding::Vector<u8, 8192>, D, &mut self.data, decoder, offset + 0, _depth)?;
1558            Ok(())
1559        }
1560    }
1561
1562    impl fidl::encoding::ValueTypeMarker for HidbusQueryResponse {
1563        type Borrowed<'a> = &'a Self;
1564        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1565            value
1566        }
1567    }
1568
1569    unsafe impl fidl::encoding::TypeMarker for HidbusQueryResponse {
1570        type Owned = Self;
1571
1572        #[inline(always)]
1573        fn inline_align(_context: fidl::encoding::Context) -> usize {
1574            8
1575        }
1576
1577        #[inline(always)]
1578        fn inline_size(_context: fidl::encoding::Context) -> usize {
1579            16
1580        }
1581    }
1582
1583    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HidbusQueryResponse, D>
1584        for &HidbusQueryResponse
1585    {
1586        #[inline]
1587        unsafe fn encode(
1588            self,
1589            encoder: &mut fidl::encoding::Encoder<'_, D>,
1590            offset: usize,
1591            _depth: fidl::encoding::Depth,
1592        ) -> fidl::Result<()> {
1593            encoder.debug_check_bounds::<HidbusQueryResponse>(offset);
1594            // Delegate to tuple encoding.
1595            fidl::encoding::Encode::<HidbusQueryResponse, D>::encode(
1596                (<HidInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
1597                encoder,
1598                offset,
1599                _depth,
1600            )
1601        }
1602    }
1603    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<HidInfo, D>>
1604        fidl::encoding::Encode<HidbusQueryResponse, D> for (T0,)
1605    {
1606        #[inline]
1607        unsafe fn encode(
1608            self,
1609            encoder: &mut fidl::encoding::Encoder<'_, D>,
1610            offset: usize,
1611            depth: fidl::encoding::Depth,
1612        ) -> fidl::Result<()> {
1613            encoder.debug_check_bounds::<HidbusQueryResponse>(offset);
1614            // Zero out padding regions. There's no need to apply masks
1615            // because the unmasked parts will be overwritten by fields.
1616            // Write the fields.
1617            self.0.encode(encoder, offset + 0, depth)?;
1618            Ok(())
1619        }
1620    }
1621
1622    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidbusQueryResponse {
1623        #[inline(always)]
1624        fn new_empty() -> Self {
1625            Self { info: fidl::new_empty!(HidInfo, D) }
1626        }
1627
1628        #[inline]
1629        unsafe fn decode(
1630            &mut self,
1631            decoder: &mut fidl::encoding::Decoder<'_, D>,
1632            offset: usize,
1633            _depth: fidl::encoding::Depth,
1634        ) -> fidl::Result<()> {
1635            decoder.debug_check_bounds::<Self>(offset);
1636            // Verify that padding bytes are zero.
1637            fidl::decode!(HidInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
1638            Ok(())
1639        }
1640    }
1641
1642    impl HidInfo {
1643        #[inline(always)]
1644        fn max_ordinal_present(&self) -> u64 {
1645            if let Some(_) = self.polling_rate {
1646                return 6;
1647            }
1648            if let Some(_) = self.version {
1649                return 5;
1650            }
1651            if let Some(_) = self.product_id {
1652                return 4;
1653            }
1654            if let Some(_) = self.vendor_id {
1655                return 3;
1656            }
1657            if let Some(_) = self.boot_protocol {
1658                return 2;
1659            }
1660            if let Some(_) = self.dev_num {
1661                return 1;
1662            }
1663            0
1664        }
1665    }
1666
1667    impl fidl::encoding::ValueTypeMarker for HidInfo {
1668        type Borrowed<'a> = &'a Self;
1669        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1670            value
1671        }
1672    }
1673
1674    unsafe impl fidl::encoding::TypeMarker for HidInfo {
1675        type Owned = Self;
1676
1677        #[inline(always)]
1678        fn inline_align(_context: fidl::encoding::Context) -> usize {
1679            8
1680        }
1681
1682        #[inline(always)]
1683        fn inline_size(_context: fidl::encoding::Context) -> usize {
1684            16
1685        }
1686    }
1687
1688    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HidInfo, D> for &HidInfo {
1689        unsafe fn encode(
1690            self,
1691            encoder: &mut fidl::encoding::Encoder<'_, D>,
1692            offset: usize,
1693            mut depth: fidl::encoding::Depth,
1694        ) -> fidl::Result<()> {
1695            encoder.debug_check_bounds::<HidInfo>(offset);
1696            // Vector header
1697            let max_ordinal: u64 = self.max_ordinal_present();
1698            encoder.write_num(max_ordinal, offset);
1699            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1700            // Calling encoder.out_of_line_offset(0) is not allowed.
1701            if max_ordinal == 0 {
1702                return Ok(());
1703            }
1704            depth.increment()?;
1705            let envelope_size = 8;
1706            let bytes_len = max_ordinal as usize * envelope_size;
1707            #[allow(unused_variables)]
1708            let offset = encoder.out_of_line_offset(bytes_len);
1709            let mut _prev_end_offset: usize = 0;
1710            if 1 > max_ordinal {
1711                return Ok(());
1712            }
1713
1714            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1715            // are envelope_size bytes.
1716            let cur_offset: usize = (1 - 1) * envelope_size;
1717
1718            // Zero reserved fields.
1719            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1720
1721            // Safety:
1722            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1723            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1724            //   envelope_size bytes, there is always sufficient room.
1725            fidl::encoding::encode_in_envelope_optional::<u8, D>(
1726                self.dev_num.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
1727                encoder,
1728                offset + cur_offset,
1729                depth,
1730            )?;
1731
1732            _prev_end_offset = cur_offset + envelope_size;
1733            if 2 > max_ordinal {
1734                return Ok(());
1735            }
1736
1737            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1738            // are envelope_size bytes.
1739            let cur_offset: usize = (2 - 1) * envelope_size;
1740
1741            // Zero reserved fields.
1742            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1743
1744            // Safety:
1745            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1746            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1747            //   envelope_size bytes, there is always sufficient room.
1748            fidl::encoding::encode_in_envelope_optional::<HidBootProtocol, D>(
1749                self.boot_protocol
1750                    .as_ref()
1751                    .map(<HidBootProtocol as fidl::encoding::ValueTypeMarker>::borrow),
1752                encoder,
1753                offset + cur_offset,
1754                depth,
1755            )?;
1756
1757            _prev_end_offset = cur_offset + envelope_size;
1758            if 3 > max_ordinal {
1759                return Ok(());
1760            }
1761
1762            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1763            // are envelope_size bytes.
1764            let cur_offset: usize = (3 - 1) * envelope_size;
1765
1766            // Zero reserved fields.
1767            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1768
1769            // Safety:
1770            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1771            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1772            //   envelope_size bytes, there is always sufficient room.
1773            fidl::encoding::encode_in_envelope_optional::<u32, D>(
1774                self.vendor_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1775                encoder,
1776                offset + cur_offset,
1777                depth,
1778            )?;
1779
1780            _prev_end_offset = cur_offset + envelope_size;
1781            if 4 > max_ordinal {
1782                return Ok(());
1783            }
1784
1785            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1786            // are envelope_size bytes.
1787            let cur_offset: usize = (4 - 1) * envelope_size;
1788
1789            // Zero reserved fields.
1790            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1791
1792            // Safety:
1793            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1794            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1795            //   envelope_size bytes, there is always sufficient room.
1796            fidl::encoding::encode_in_envelope_optional::<u32, D>(
1797                self.product_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1798                encoder,
1799                offset + cur_offset,
1800                depth,
1801            )?;
1802
1803            _prev_end_offset = cur_offset + envelope_size;
1804            if 5 > max_ordinal {
1805                return Ok(());
1806            }
1807
1808            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1809            // are envelope_size bytes.
1810            let cur_offset: usize = (5 - 1) * envelope_size;
1811
1812            // Zero reserved fields.
1813            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1814
1815            // Safety:
1816            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1817            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1818            //   envelope_size bytes, there is always sufficient room.
1819            fidl::encoding::encode_in_envelope_optional::<u32, D>(
1820                self.version.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1821                encoder,
1822                offset + cur_offset,
1823                depth,
1824            )?;
1825
1826            _prev_end_offset = cur_offset + envelope_size;
1827            if 6 > max_ordinal {
1828                return Ok(());
1829            }
1830
1831            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1832            // are envelope_size bytes.
1833            let cur_offset: usize = (6 - 1) * envelope_size;
1834
1835            // Zero reserved fields.
1836            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1837
1838            // Safety:
1839            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1840            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1841            //   envelope_size bytes, there is always sufficient room.
1842            fidl::encoding::encode_in_envelope_optional::<i64, D>(
1843                self.polling_rate.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
1844                encoder,
1845                offset + cur_offset,
1846                depth,
1847            )?;
1848
1849            _prev_end_offset = cur_offset + envelope_size;
1850
1851            Ok(())
1852        }
1853    }
1854
1855    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HidInfo {
1856        #[inline(always)]
1857        fn new_empty() -> Self {
1858            Self::default()
1859        }
1860
1861        unsafe fn decode(
1862            &mut self,
1863            decoder: &mut fidl::encoding::Decoder<'_, D>,
1864            offset: usize,
1865            mut depth: fidl::encoding::Depth,
1866        ) -> fidl::Result<()> {
1867            decoder.debug_check_bounds::<Self>(offset);
1868            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1869                None => return Err(fidl::Error::NotNullable),
1870                Some(len) => len,
1871            };
1872            // Calling decoder.out_of_line_offset(0) is not allowed.
1873            if len == 0 {
1874                return Ok(());
1875            };
1876            depth.increment()?;
1877            let envelope_size = 8;
1878            let bytes_len = len * envelope_size;
1879            let offset = decoder.out_of_line_offset(bytes_len)?;
1880            // Decode the envelope for each type.
1881            let mut _next_ordinal_to_read = 0;
1882            let mut next_offset = offset;
1883            let end_offset = offset + bytes_len;
1884            _next_ordinal_to_read += 1;
1885            if next_offset >= end_offset {
1886                return Ok(());
1887            }
1888
1889            // Decode unknown envelopes for gaps in ordinals.
1890            while _next_ordinal_to_read < 1 {
1891                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1892                _next_ordinal_to_read += 1;
1893                next_offset += envelope_size;
1894            }
1895
1896            let next_out_of_line = decoder.next_out_of_line();
1897            let handles_before = decoder.remaining_handles();
1898            if let Some((inlined, num_bytes, num_handles)) =
1899                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1900            {
1901                let member_inline_size =
1902                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1903                if inlined != (member_inline_size <= 4) {
1904                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1905                }
1906                let inner_offset;
1907                let mut inner_depth = depth.clone();
1908                if inlined {
1909                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1910                    inner_offset = next_offset;
1911                } else {
1912                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1913                    inner_depth.increment()?;
1914                }
1915                let val_ref = self.dev_num.get_or_insert_with(|| fidl::new_empty!(u8, D));
1916                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
1917                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1918                {
1919                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1920                }
1921                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1922                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1923                }
1924            }
1925
1926            next_offset += envelope_size;
1927            _next_ordinal_to_read += 1;
1928            if next_offset >= end_offset {
1929                return Ok(());
1930            }
1931
1932            // Decode unknown envelopes for gaps in ordinals.
1933            while _next_ordinal_to_read < 2 {
1934                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1935                _next_ordinal_to_read += 1;
1936                next_offset += envelope_size;
1937            }
1938
1939            let next_out_of_line = decoder.next_out_of_line();
1940            let handles_before = decoder.remaining_handles();
1941            if let Some((inlined, num_bytes, num_handles)) =
1942                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1943            {
1944                let member_inline_size =
1945                    <HidBootProtocol as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1946                if inlined != (member_inline_size <= 4) {
1947                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1948                }
1949                let inner_offset;
1950                let mut inner_depth = depth.clone();
1951                if inlined {
1952                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1953                    inner_offset = next_offset;
1954                } else {
1955                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1956                    inner_depth.increment()?;
1957                }
1958                let val_ref =
1959                    self.boot_protocol.get_or_insert_with(|| fidl::new_empty!(HidBootProtocol, D));
1960                fidl::decode!(HidBootProtocol, D, val_ref, decoder, inner_offset, inner_depth)?;
1961                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1962                {
1963                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1964                }
1965                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1966                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1967                }
1968            }
1969
1970            next_offset += envelope_size;
1971            _next_ordinal_to_read += 1;
1972            if next_offset >= end_offset {
1973                return Ok(());
1974            }
1975
1976            // Decode unknown envelopes for gaps in ordinals.
1977            while _next_ordinal_to_read < 3 {
1978                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1979                _next_ordinal_to_read += 1;
1980                next_offset += envelope_size;
1981            }
1982
1983            let next_out_of_line = decoder.next_out_of_line();
1984            let handles_before = decoder.remaining_handles();
1985            if let Some((inlined, num_bytes, num_handles)) =
1986                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1987            {
1988                let member_inline_size =
1989                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1990                if inlined != (member_inline_size <= 4) {
1991                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1992                }
1993                let inner_offset;
1994                let mut inner_depth = depth.clone();
1995                if inlined {
1996                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1997                    inner_offset = next_offset;
1998                } else {
1999                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2000                    inner_depth.increment()?;
2001                }
2002                let val_ref = self.vendor_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
2003                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2004                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2005                {
2006                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2007                }
2008                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2009                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2010                }
2011            }
2012
2013            next_offset += envelope_size;
2014            _next_ordinal_to_read += 1;
2015            if next_offset >= end_offset {
2016                return Ok(());
2017            }
2018
2019            // Decode unknown envelopes for gaps in ordinals.
2020            while _next_ordinal_to_read < 4 {
2021                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2022                _next_ordinal_to_read += 1;
2023                next_offset += envelope_size;
2024            }
2025
2026            let next_out_of_line = decoder.next_out_of_line();
2027            let handles_before = decoder.remaining_handles();
2028            if let Some((inlined, num_bytes, num_handles)) =
2029                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2030            {
2031                let member_inline_size =
2032                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2033                if inlined != (member_inline_size <= 4) {
2034                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2035                }
2036                let inner_offset;
2037                let mut inner_depth = depth.clone();
2038                if inlined {
2039                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2040                    inner_offset = next_offset;
2041                } else {
2042                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2043                    inner_depth.increment()?;
2044                }
2045                let val_ref = self.product_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
2046                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2047                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2048                {
2049                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2050                }
2051                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2052                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2053                }
2054            }
2055
2056            next_offset += envelope_size;
2057            _next_ordinal_to_read += 1;
2058            if next_offset >= end_offset {
2059                return Ok(());
2060            }
2061
2062            // Decode unknown envelopes for gaps in ordinals.
2063            while _next_ordinal_to_read < 5 {
2064                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2065                _next_ordinal_to_read += 1;
2066                next_offset += envelope_size;
2067            }
2068
2069            let next_out_of_line = decoder.next_out_of_line();
2070            let handles_before = decoder.remaining_handles();
2071            if let Some((inlined, num_bytes, num_handles)) =
2072                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2073            {
2074                let member_inline_size =
2075                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2076                if inlined != (member_inline_size <= 4) {
2077                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2078                }
2079                let inner_offset;
2080                let mut inner_depth = depth.clone();
2081                if inlined {
2082                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2083                    inner_offset = next_offset;
2084                } else {
2085                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2086                    inner_depth.increment()?;
2087                }
2088                let val_ref = self.version.get_or_insert_with(|| fidl::new_empty!(u32, D));
2089                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
2090                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2091                {
2092                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2093                }
2094                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2095                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2096                }
2097            }
2098
2099            next_offset += envelope_size;
2100            _next_ordinal_to_read += 1;
2101            if next_offset >= end_offset {
2102                return Ok(());
2103            }
2104
2105            // Decode unknown envelopes for gaps in ordinals.
2106            while _next_ordinal_to_read < 6 {
2107                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2108                _next_ordinal_to_read += 1;
2109                next_offset += envelope_size;
2110            }
2111
2112            let next_out_of_line = decoder.next_out_of_line();
2113            let handles_before = decoder.remaining_handles();
2114            if let Some((inlined, num_bytes, num_handles)) =
2115                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2116            {
2117                let member_inline_size =
2118                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2119                if inlined != (member_inline_size <= 4) {
2120                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2121                }
2122                let inner_offset;
2123                let mut inner_depth = depth.clone();
2124                if inlined {
2125                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2126                    inner_offset = next_offset;
2127                } else {
2128                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2129                    inner_depth.increment()?;
2130                }
2131                let val_ref = self.polling_rate.get_or_insert_with(|| fidl::new_empty!(i64, D));
2132                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
2133                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2134                {
2135                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2136                }
2137                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2138                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2139                }
2140            }
2141
2142            next_offset += envelope_size;
2143
2144            // Decode the remaining unknown envelopes.
2145            while next_offset < end_offset {
2146                _next_ordinal_to_read += 1;
2147                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2148                next_offset += envelope_size;
2149            }
2150
2151            Ok(())
2152        }
2153    }
2154}