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