fidl_fuchsia_recovery_ui__common/
fidl_fuchsia_recovery_ui__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
12#[repr(u32)]
13pub enum Status {
14    Active = 1,
15    Paused = 2,
16    Error = 3,
17    Cancelled = 4,
18    Complete = 5,
19}
20
21impl Status {
22    #[inline]
23    pub fn from_primitive(prim: u32) -> Option<Self> {
24        match prim {
25            1 => Some(Self::Active),
26            2 => Some(Self::Paused),
27            3 => Some(Self::Error),
28            4 => Some(Self::Cancelled),
29            5 => Some(Self::Complete),
30            _ => None,
31        }
32    }
33
34    #[inline]
35    pub const fn into_primitive(self) -> u32 {
36        self as u32
37    }
38}
39
40#[derive(Clone, Debug, PartialEq)]
41pub struct FactoryResetCountdownWatchResponse {
42    pub state: FactoryResetCountdownState,
43}
44
45impl fidl::Persistable for FactoryResetCountdownWatchResponse {}
46
47#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
48pub struct ProgressRendererRenderRequest {
49    pub status: Status,
50    pub percent_complete: f32,
51}
52
53impl fidl::Persistable for ProgressRendererRenderRequest {}
54
55/// Information provided through the FactoryResetCountdown protocol on the
56/// current factory reset state.
57#[derive(Clone, Debug, Default, PartialEq)]
58pub struct FactoryResetCountdownState {
59    /// The time of when factory reset is scheduled to be triggered when a
60    /// countdown for factory reset is in progress with respect to the monotonic
61    /// clock. This field is left unpopulated if no reset is scheduled.
62    pub scheduled_reset_time: Option<i64>,
63    #[doc(hidden)]
64    pub __source_breaking: fidl::marker::SourceBreaking,
65}
66
67impl fidl::Persistable for FactoryResetCountdownState {}
68
69#[derive(Clone, Debug, Default, PartialEq)]
70pub struct ProgressRendererRender2Request {
71    pub status: Option<Status>,
72    /// Optional, only used with status ACTIVE
73    /// No value or an invalid value sets the progress bar to 0%
74    /// Values: [0.0 - 100.0]
75    pub percent_complete: Option<f32>,
76    /// Time to take to move slowly to percent_complete
77    /// Optional, only used with status ACTIVE
78    /// No value indicates an instant jump to percent_complete
79    pub elapsed_time: Option<i64>,
80    #[doc(hidden)]
81    pub __source_breaking: fidl::marker::SourceBreaking,
82}
83
84impl fidl::Persistable for ProgressRendererRender2Request {}
85
86mod internal {
87    use super::*;
88    unsafe impl fidl::encoding::TypeMarker for Status {
89        type Owned = Self;
90
91        #[inline(always)]
92        fn inline_align(_context: fidl::encoding::Context) -> usize {
93            std::mem::align_of::<u32>()
94        }
95
96        #[inline(always)]
97        fn inline_size(_context: fidl::encoding::Context) -> usize {
98            std::mem::size_of::<u32>()
99        }
100
101        #[inline(always)]
102        fn encode_is_copy() -> bool {
103            true
104        }
105
106        #[inline(always)]
107        fn decode_is_copy() -> bool {
108            false
109        }
110    }
111
112    impl fidl::encoding::ValueTypeMarker for Status {
113        type Borrowed<'a> = Self;
114        #[inline(always)]
115        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
116            *value
117        }
118    }
119
120    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Status {
121        #[inline]
122        unsafe fn encode(
123            self,
124            encoder: &mut fidl::encoding::Encoder<'_, D>,
125            offset: usize,
126            _depth: fidl::encoding::Depth,
127        ) -> fidl::Result<()> {
128            encoder.debug_check_bounds::<Self>(offset);
129            encoder.write_num(self.into_primitive(), offset);
130            Ok(())
131        }
132    }
133
134    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Status {
135        #[inline(always)]
136        fn new_empty() -> Self {
137            Self::Active
138        }
139
140        #[inline]
141        unsafe fn decode(
142            &mut self,
143            decoder: &mut fidl::encoding::Decoder<'_, D>,
144            offset: usize,
145            _depth: fidl::encoding::Depth,
146        ) -> fidl::Result<()> {
147            decoder.debug_check_bounds::<Self>(offset);
148            let prim = decoder.read_num::<u32>(offset);
149
150            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
151            Ok(())
152        }
153    }
154
155    impl fidl::encoding::ValueTypeMarker for FactoryResetCountdownWatchResponse {
156        type Borrowed<'a> = &'a Self;
157        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
158            value
159        }
160    }
161
162    unsafe impl fidl::encoding::TypeMarker for FactoryResetCountdownWatchResponse {
163        type Owned = Self;
164
165        #[inline(always)]
166        fn inline_align(_context: fidl::encoding::Context) -> usize {
167            8
168        }
169
170        #[inline(always)]
171        fn inline_size(_context: fidl::encoding::Context) -> usize {
172            16
173        }
174    }
175
176    unsafe impl<D: fidl::encoding::ResourceDialect>
177        fidl::encoding::Encode<FactoryResetCountdownWatchResponse, D>
178        for &FactoryResetCountdownWatchResponse
179    {
180        #[inline]
181        unsafe fn encode(
182            self,
183            encoder: &mut fidl::encoding::Encoder<'_, D>,
184            offset: usize,
185            _depth: fidl::encoding::Depth,
186        ) -> fidl::Result<()> {
187            encoder.debug_check_bounds::<FactoryResetCountdownWatchResponse>(offset);
188            // Delegate to tuple encoding.
189            fidl::encoding::Encode::<FactoryResetCountdownWatchResponse, D>::encode(
190                (<FactoryResetCountdownState as fidl::encoding::ValueTypeMarker>::borrow(
191                    &self.state,
192                ),),
193                encoder,
194                offset,
195                _depth,
196            )
197        }
198    }
199    unsafe impl<
200            D: fidl::encoding::ResourceDialect,
201            T0: fidl::encoding::Encode<FactoryResetCountdownState, D>,
202        > fidl::encoding::Encode<FactoryResetCountdownWatchResponse, D> for (T0,)
203    {
204        #[inline]
205        unsafe fn encode(
206            self,
207            encoder: &mut fidl::encoding::Encoder<'_, D>,
208            offset: usize,
209            depth: fidl::encoding::Depth,
210        ) -> fidl::Result<()> {
211            encoder.debug_check_bounds::<FactoryResetCountdownWatchResponse>(offset);
212            // Zero out padding regions. There's no need to apply masks
213            // because the unmasked parts will be overwritten by fields.
214            // Write the fields.
215            self.0.encode(encoder, offset + 0, depth)?;
216            Ok(())
217        }
218    }
219
220    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
221        for FactoryResetCountdownWatchResponse
222    {
223        #[inline(always)]
224        fn new_empty() -> Self {
225            Self { state: fidl::new_empty!(FactoryResetCountdownState, D) }
226        }
227
228        #[inline]
229        unsafe fn decode(
230            &mut self,
231            decoder: &mut fidl::encoding::Decoder<'_, D>,
232            offset: usize,
233            _depth: fidl::encoding::Depth,
234        ) -> fidl::Result<()> {
235            decoder.debug_check_bounds::<Self>(offset);
236            // Verify that padding bytes are zero.
237            fidl::decode!(
238                FactoryResetCountdownState,
239                D,
240                &mut self.state,
241                decoder,
242                offset + 0,
243                _depth
244            )?;
245            Ok(())
246        }
247    }
248
249    impl fidl::encoding::ValueTypeMarker for ProgressRendererRenderRequest {
250        type Borrowed<'a> = &'a Self;
251        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
252            value
253        }
254    }
255
256    unsafe impl fidl::encoding::TypeMarker for ProgressRendererRenderRequest {
257        type Owned = Self;
258
259        #[inline(always)]
260        fn inline_align(_context: fidl::encoding::Context) -> usize {
261            4
262        }
263
264        #[inline(always)]
265        fn inline_size(_context: fidl::encoding::Context) -> usize {
266            8
267        }
268    }
269
270    unsafe impl<D: fidl::encoding::ResourceDialect>
271        fidl::encoding::Encode<ProgressRendererRenderRequest, D>
272        for &ProgressRendererRenderRequest
273    {
274        #[inline]
275        unsafe fn encode(
276            self,
277            encoder: &mut fidl::encoding::Encoder<'_, D>,
278            offset: usize,
279            _depth: fidl::encoding::Depth,
280        ) -> fidl::Result<()> {
281            encoder.debug_check_bounds::<ProgressRendererRenderRequest>(offset);
282            // Delegate to tuple encoding.
283            fidl::encoding::Encode::<ProgressRendererRenderRequest, D>::encode(
284                (
285                    <Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
286                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.percent_complete),
287                ),
288                encoder,
289                offset,
290                _depth,
291            )
292        }
293    }
294    unsafe impl<
295            D: fidl::encoding::ResourceDialect,
296            T0: fidl::encoding::Encode<Status, D>,
297            T1: fidl::encoding::Encode<f32, D>,
298        > fidl::encoding::Encode<ProgressRendererRenderRequest, D> for (T0, T1)
299    {
300        #[inline]
301        unsafe fn encode(
302            self,
303            encoder: &mut fidl::encoding::Encoder<'_, D>,
304            offset: usize,
305            depth: fidl::encoding::Depth,
306        ) -> fidl::Result<()> {
307            encoder.debug_check_bounds::<ProgressRendererRenderRequest>(offset);
308            // Zero out padding regions. There's no need to apply masks
309            // because the unmasked parts will be overwritten by fields.
310            // Write the fields.
311            self.0.encode(encoder, offset + 0, depth)?;
312            self.1.encode(encoder, offset + 4, depth)?;
313            Ok(())
314        }
315    }
316
317    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
318        for ProgressRendererRenderRequest
319    {
320        #[inline(always)]
321        fn new_empty() -> Self {
322            Self { status: fidl::new_empty!(Status, D), percent_complete: fidl::new_empty!(f32, D) }
323        }
324
325        #[inline]
326        unsafe fn decode(
327            &mut self,
328            decoder: &mut fidl::encoding::Decoder<'_, D>,
329            offset: usize,
330            _depth: fidl::encoding::Depth,
331        ) -> fidl::Result<()> {
332            decoder.debug_check_bounds::<Self>(offset);
333            // Verify that padding bytes are zero.
334            fidl::decode!(Status, D, &mut self.status, decoder, offset + 0, _depth)?;
335            fidl::decode!(f32, D, &mut self.percent_complete, decoder, offset + 4, _depth)?;
336            Ok(())
337        }
338    }
339
340    impl FactoryResetCountdownState {
341        #[inline(always)]
342        fn max_ordinal_present(&self) -> u64 {
343            if let Some(_) = self.scheduled_reset_time {
344                return 1;
345            }
346            0
347        }
348    }
349
350    impl fidl::encoding::ValueTypeMarker for FactoryResetCountdownState {
351        type Borrowed<'a> = &'a Self;
352        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
353            value
354        }
355    }
356
357    unsafe impl fidl::encoding::TypeMarker for FactoryResetCountdownState {
358        type Owned = Self;
359
360        #[inline(always)]
361        fn inline_align(_context: fidl::encoding::Context) -> usize {
362            8
363        }
364
365        #[inline(always)]
366        fn inline_size(_context: fidl::encoding::Context) -> usize {
367            16
368        }
369    }
370
371    unsafe impl<D: fidl::encoding::ResourceDialect>
372        fidl::encoding::Encode<FactoryResetCountdownState, D> for &FactoryResetCountdownState
373    {
374        unsafe fn encode(
375            self,
376            encoder: &mut fidl::encoding::Encoder<'_, D>,
377            offset: usize,
378            mut depth: fidl::encoding::Depth,
379        ) -> fidl::Result<()> {
380            encoder.debug_check_bounds::<FactoryResetCountdownState>(offset);
381            // Vector header
382            let max_ordinal: u64 = self.max_ordinal_present();
383            encoder.write_num(max_ordinal, offset);
384            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
385            // Calling encoder.out_of_line_offset(0) is not allowed.
386            if max_ordinal == 0 {
387                return Ok(());
388            }
389            depth.increment()?;
390            let envelope_size = 8;
391            let bytes_len = max_ordinal as usize * envelope_size;
392            #[allow(unused_variables)]
393            let offset = encoder.out_of_line_offset(bytes_len);
394            let mut _prev_end_offset: usize = 0;
395            if 1 > max_ordinal {
396                return Ok(());
397            }
398
399            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
400            // are envelope_size bytes.
401            let cur_offset: usize = (1 - 1) * envelope_size;
402
403            // Zero reserved fields.
404            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
405
406            // Safety:
407            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
408            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
409            //   envelope_size bytes, there is always sufficient room.
410            fidl::encoding::encode_in_envelope_optional::<i64, D>(
411                self.scheduled_reset_time
412                    .as_ref()
413                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
414                encoder,
415                offset + cur_offset,
416                depth,
417            )?;
418
419            _prev_end_offset = cur_offset + envelope_size;
420
421            Ok(())
422        }
423    }
424
425    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
426        for FactoryResetCountdownState
427    {
428        #[inline(always)]
429        fn new_empty() -> Self {
430            Self::default()
431        }
432
433        unsafe fn decode(
434            &mut self,
435            decoder: &mut fidl::encoding::Decoder<'_, D>,
436            offset: usize,
437            mut depth: fidl::encoding::Depth,
438        ) -> fidl::Result<()> {
439            decoder.debug_check_bounds::<Self>(offset);
440            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
441                None => return Err(fidl::Error::NotNullable),
442                Some(len) => len,
443            };
444            // Calling decoder.out_of_line_offset(0) is not allowed.
445            if len == 0 {
446                return Ok(());
447            };
448            depth.increment()?;
449            let envelope_size = 8;
450            let bytes_len = len * envelope_size;
451            let offset = decoder.out_of_line_offset(bytes_len)?;
452            // Decode the envelope for each type.
453            let mut _next_ordinal_to_read = 0;
454            let mut next_offset = offset;
455            let end_offset = offset + bytes_len;
456            _next_ordinal_to_read += 1;
457            if next_offset >= end_offset {
458                return Ok(());
459            }
460
461            // Decode unknown envelopes for gaps in ordinals.
462            while _next_ordinal_to_read < 1 {
463                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
464                _next_ordinal_to_read += 1;
465                next_offset += envelope_size;
466            }
467
468            let next_out_of_line = decoder.next_out_of_line();
469            let handles_before = decoder.remaining_handles();
470            if let Some((inlined, num_bytes, num_handles)) =
471                fidl::encoding::decode_envelope_header(decoder, next_offset)?
472            {
473                let member_inline_size =
474                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
475                if inlined != (member_inline_size <= 4) {
476                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
477                }
478                let inner_offset;
479                let mut inner_depth = depth.clone();
480                if inlined {
481                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
482                    inner_offset = next_offset;
483                } else {
484                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
485                    inner_depth.increment()?;
486                }
487                let val_ref =
488                    self.scheduled_reset_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
489                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
490                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
491                {
492                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
493                }
494                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
495                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
496                }
497            }
498
499            next_offset += envelope_size;
500
501            // Decode the remaining unknown envelopes.
502            while next_offset < end_offset {
503                _next_ordinal_to_read += 1;
504                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
505                next_offset += envelope_size;
506            }
507
508            Ok(())
509        }
510    }
511
512    impl ProgressRendererRender2Request {
513        #[inline(always)]
514        fn max_ordinal_present(&self) -> u64 {
515            if let Some(_) = self.elapsed_time {
516                return 3;
517            }
518            if let Some(_) = self.percent_complete {
519                return 2;
520            }
521            if let Some(_) = self.status {
522                return 1;
523            }
524            0
525        }
526    }
527
528    impl fidl::encoding::ValueTypeMarker for ProgressRendererRender2Request {
529        type Borrowed<'a> = &'a Self;
530        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
531            value
532        }
533    }
534
535    unsafe impl fidl::encoding::TypeMarker for ProgressRendererRender2Request {
536        type Owned = Self;
537
538        #[inline(always)]
539        fn inline_align(_context: fidl::encoding::Context) -> usize {
540            8
541        }
542
543        #[inline(always)]
544        fn inline_size(_context: fidl::encoding::Context) -> usize {
545            16
546        }
547    }
548
549    unsafe impl<D: fidl::encoding::ResourceDialect>
550        fidl::encoding::Encode<ProgressRendererRender2Request, D>
551        for &ProgressRendererRender2Request
552    {
553        unsafe fn encode(
554            self,
555            encoder: &mut fidl::encoding::Encoder<'_, D>,
556            offset: usize,
557            mut depth: fidl::encoding::Depth,
558        ) -> fidl::Result<()> {
559            encoder.debug_check_bounds::<ProgressRendererRender2Request>(offset);
560            // Vector header
561            let max_ordinal: u64 = self.max_ordinal_present();
562            encoder.write_num(max_ordinal, offset);
563            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
564            // Calling encoder.out_of_line_offset(0) is not allowed.
565            if max_ordinal == 0 {
566                return Ok(());
567            }
568            depth.increment()?;
569            let envelope_size = 8;
570            let bytes_len = max_ordinal as usize * envelope_size;
571            #[allow(unused_variables)]
572            let offset = encoder.out_of_line_offset(bytes_len);
573            let mut _prev_end_offset: usize = 0;
574            if 1 > max_ordinal {
575                return Ok(());
576            }
577
578            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
579            // are envelope_size bytes.
580            let cur_offset: usize = (1 - 1) * envelope_size;
581
582            // Zero reserved fields.
583            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
584
585            // Safety:
586            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
587            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
588            //   envelope_size bytes, there is always sufficient room.
589            fidl::encoding::encode_in_envelope_optional::<Status, D>(
590                self.status.as_ref().map(<Status as fidl::encoding::ValueTypeMarker>::borrow),
591                encoder,
592                offset + cur_offset,
593                depth,
594            )?;
595
596            _prev_end_offset = cur_offset + envelope_size;
597            if 2 > max_ordinal {
598                return Ok(());
599            }
600
601            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
602            // are envelope_size bytes.
603            let cur_offset: usize = (2 - 1) * envelope_size;
604
605            // Zero reserved fields.
606            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
607
608            // Safety:
609            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
610            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
611            //   envelope_size bytes, there is always sufficient room.
612            fidl::encoding::encode_in_envelope_optional::<f32, D>(
613                self.percent_complete
614                    .as_ref()
615                    .map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
616                encoder,
617                offset + cur_offset,
618                depth,
619            )?;
620
621            _prev_end_offset = cur_offset + envelope_size;
622            if 3 > max_ordinal {
623                return Ok(());
624            }
625
626            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
627            // are envelope_size bytes.
628            let cur_offset: usize = (3 - 1) * envelope_size;
629
630            // Zero reserved fields.
631            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
632
633            // Safety:
634            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
635            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
636            //   envelope_size bytes, there is always sufficient room.
637            fidl::encoding::encode_in_envelope_optional::<i64, D>(
638                self.elapsed_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
639                encoder,
640                offset + cur_offset,
641                depth,
642            )?;
643
644            _prev_end_offset = cur_offset + envelope_size;
645
646            Ok(())
647        }
648    }
649
650    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
651        for ProgressRendererRender2Request
652    {
653        #[inline(always)]
654        fn new_empty() -> Self {
655            Self::default()
656        }
657
658        unsafe fn decode(
659            &mut self,
660            decoder: &mut fidl::encoding::Decoder<'_, D>,
661            offset: usize,
662            mut depth: fidl::encoding::Depth,
663        ) -> fidl::Result<()> {
664            decoder.debug_check_bounds::<Self>(offset);
665            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
666                None => return Err(fidl::Error::NotNullable),
667                Some(len) => len,
668            };
669            // Calling decoder.out_of_line_offset(0) is not allowed.
670            if len == 0 {
671                return Ok(());
672            };
673            depth.increment()?;
674            let envelope_size = 8;
675            let bytes_len = len * envelope_size;
676            let offset = decoder.out_of_line_offset(bytes_len)?;
677            // Decode the envelope for each type.
678            let mut _next_ordinal_to_read = 0;
679            let mut next_offset = offset;
680            let end_offset = offset + bytes_len;
681            _next_ordinal_to_read += 1;
682            if next_offset >= end_offset {
683                return Ok(());
684            }
685
686            // Decode unknown envelopes for gaps in ordinals.
687            while _next_ordinal_to_read < 1 {
688                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
689                _next_ordinal_to_read += 1;
690                next_offset += envelope_size;
691            }
692
693            let next_out_of_line = decoder.next_out_of_line();
694            let handles_before = decoder.remaining_handles();
695            if let Some((inlined, num_bytes, num_handles)) =
696                fidl::encoding::decode_envelope_header(decoder, next_offset)?
697            {
698                let member_inline_size =
699                    <Status as fidl::encoding::TypeMarker>::inline_size(decoder.context);
700                if inlined != (member_inline_size <= 4) {
701                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
702                }
703                let inner_offset;
704                let mut inner_depth = depth.clone();
705                if inlined {
706                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
707                    inner_offset = next_offset;
708                } else {
709                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
710                    inner_depth.increment()?;
711                }
712                let val_ref = self.status.get_or_insert_with(|| fidl::new_empty!(Status, D));
713                fidl::decode!(Status, D, val_ref, decoder, inner_offset, inner_depth)?;
714                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
715                {
716                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
717                }
718                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
719                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
720                }
721            }
722
723            next_offset += envelope_size;
724            _next_ordinal_to_read += 1;
725            if next_offset >= end_offset {
726                return Ok(());
727            }
728
729            // Decode unknown envelopes for gaps in ordinals.
730            while _next_ordinal_to_read < 2 {
731                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
732                _next_ordinal_to_read += 1;
733                next_offset += envelope_size;
734            }
735
736            let next_out_of_line = decoder.next_out_of_line();
737            let handles_before = decoder.remaining_handles();
738            if let Some((inlined, num_bytes, num_handles)) =
739                fidl::encoding::decode_envelope_header(decoder, next_offset)?
740            {
741                let member_inline_size =
742                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
743                if inlined != (member_inline_size <= 4) {
744                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
745                }
746                let inner_offset;
747                let mut inner_depth = depth.clone();
748                if inlined {
749                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
750                    inner_offset = next_offset;
751                } else {
752                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
753                    inner_depth.increment()?;
754                }
755                let val_ref = self.percent_complete.get_or_insert_with(|| fidl::new_empty!(f32, D));
756                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
757                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
758                {
759                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
760                }
761                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
762                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
763                }
764            }
765
766            next_offset += envelope_size;
767            _next_ordinal_to_read += 1;
768            if next_offset >= end_offset {
769                return Ok(());
770            }
771
772            // Decode unknown envelopes for gaps in ordinals.
773            while _next_ordinal_to_read < 3 {
774                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
775                _next_ordinal_to_read += 1;
776                next_offset += envelope_size;
777            }
778
779            let next_out_of_line = decoder.next_out_of_line();
780            let handles_before = decoder.remaining_handles();
781            if let Some((inlined, num_bytes, num_handles)) =
782                fidl::encoding::decode_envelope_header(decoder, next_offset)?
783            {
784                let member_inline_size =
785                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
786                if inlined != (member_inline_size <= 4) {
787                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
788                }
789                let inner_offset;
790                let mut inner_depth = depth.clone();
791                if inlined {
792                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
793                    inner_offset = next_offset;
794                } else {
795                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
796                    inner_depth.increment()?;
797                }
798                let val_ref = self.elapsed_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
799                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
800                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
801                {
802                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
803                }
804                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
805                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
806                }
807            }
808
809            next_offset += envelope_size;
810
811            // Decode the remaining unknown envelopes.
812            while next_offset < end_offset {
813                _next_ordinal_to_read += 1;
814                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
815                next_offset += envelope_size;
816            }
817
818            Ok(())
819        }
820    }
821}