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