fidl_fuchsia_update_installer__common/
fidl_fuchsia_update_installer__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub type AttemptId = String;
12
13/// Why cancel failed.
14#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
15#[repr(u32)]
16pub enum CancelError {
17    /// There is no update attempt in progress.
18    NoUpdateInProgress = 1,
19    /// The update attempt has past the point that can be canceled.
20    UpdateCannotBeCanceled = 2,
21    /// The given attempt id does not match the current update attempt.
22    AttemptIdMismatch = 3,
23    /// The number of cancel requests has exceeded the limit.
24    CancelLimitExceeded = 4,
25}
26
27impl CancelError {
28    #[inline]
29    pub fn from_primitive(prim: u32) -> Option<Self> {
30        match prim {
31            1 => Some(Self::NoUpdateInProgress),
32            2 => Some(Self::UpdateCannotBeCanceled),
33            3 => Some(Self::AttemptIdMismatch),
34            4 => Some(Self::CancelLimitExceeded),
35            _ => None,
36        }
37    }
38
39    #[inline]
40    pub const fn into_primitive(self) -> u32 {
41        self as u32
42    }
43}
44
45/// The set of values provided when an installation attempt fails on [`State.fetch`].
46#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
47#[repr(u32)]
48pub enum FetchFailureReason {
49    /// The fetch failed because of some other reason.
50    Internal = 0,
51    /// The fetch failed because the system does not have enough space to fetch a package.
52    OutOfSpace = 1,
53}
54
55impl FetchFailureReason {
56    #[inline]
57    pub fn from_primitive(prim: u32) -> Option<Self> {
58        match prim {
59            0 => Some(Self::Internal),
60            1 => Some(Self::OutOfSpace),
61            _ => None,
62        }
63    }
64
65    #[inline]
66    pub const fn into_primitive(self) -> u32 {
67        self as u32
68    }
69}
70
71/// Who or what initiated the update installation.
72#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
73#[repr(u32)]
74pub enum Initiator {
75    /// The install was initiated by an interactive user, or the user is
76    /// otherwise blocked and waiting for the result of this update.
77    User = 0,
78    /// The install was initiated by a service, in the background.
79    Service = 1,
80}
81
82impl Initiator {
83    #[inline]
84    pub fn from_primitive(prim: u32) -> Option<Self> {
85        match prim {
86            0 => Some(Self::User),
87            1 => Some(Self::Service),
88            _ => None,
89        }
90    }
91
92    #[inline]
93    pub const fn into_primitive(self) -> u32 {
94        self as u32
95    }
96}
97
98/// The set of values provided when an installation attempt fails on [`State.prepare`].
99#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
100#[repr(u32)]
101pub enum PrepareFailureReason {
102    /// The prepare failed because of some other reason.
103    Internal = 0,
104    /// The prepare failed because the system does not have enough space to fetch
105    /// the update package.
106    OutOfSpace = 1,
107    /// The prepare failed because the system cannot downgrade across a version boundary. Not all
108    /// unsupported downgrades will fail with this error -- just the ones the system can detect. For
109    /// more context, see [RFC-0071](/docs/contribute/governance/rfcs/0071_ota_backstop.md).
110    UnsupportedDowngrade = 2,
111}
112
113impl PrepareFailureReason {
114    #[inline]
115    pub fn from_primitive(prim: u32) -> Option<Self> {
116        match prim {
117            0 => Some(Self::Internal),
118            1 => Some(Self::OutOfSpace),
119            2 => Some(Self::UnsupportedDowngrade),
120            _ => None,
121        }
122    }
123
124    #[inline]
125    pub const fn into_primitive(self) -> u32 {
126        self as u32
127    }
128}
129
130/// Why resume failed.
131#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
132#[repr(u32)]
133pub enum ResumeError {
134    /// There is no update attempt in progress.
135    NoUpdateInProgress = 1,
136    /// The given attempt id does not match the current update attempt.
137    AttemptIdMismatch = 2,
138}
139
140impl ResumeError {
141    #[inline]
142    pub fn from_primitive(prim: u32) -> Option<Self> {
143        match prim {
144            1 => Some(Self::NoUpdateInProgress),
145            2 => Some(Self::AttemptIdMismatch),
146            _ => None,
147        }
148    }
149
150    #[inline]
151    pub const fn into_primitive(self) -> u32 {
152        self as u32
153    }
154}
155
156/// The set of values provided when an installation attempt fails on [`State.stage`].
157#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
158#[repr(u32)]
159pub enum StageFailureReason {
160    /// The stage failed because of some other reason.
161    Internal = 0,
162    /// The stage failed because the system does not have enough space to fetch a package.
163    OutOfSpace = 1,
164}
165
166impl StageFailureReason {
167    #[inline]
168    pub fn from_primitive(prim: u32) -> Option<Self> {
169        match prim {
170            0 => Some(Self::Internal),
171            1 => Some(Self::OutOfSpace),
172            _ => None,
173        }
174    }
175
176    #[inline]
177    pub const fn into_primitive(self) -> u32 {
178        self as u32
179    }
180}
181
182/// Why suspend failed.
183#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
184#[repr(u32)]
185pub enum SuspendError {
186    /// There is no update attempt in progress.
187    NoUpdateInProgress = 1,
188    /// The current update attempt has reached its suspend limit.
189    SuspendLimitExceeded = 2,
190    /// The given attempt id does not match the current update attempt.
191    AttemptIdMismatch = 3,
192}
193
194impl SuspendError {
195    #[inline]
196    pub fn from_primitive(prim: u32) -> Option<Self> {
197        match prim {
198            1 => Some(Self::NoUpdateInProgress),
199            2 => Some(Self::SuspendLimitExceeded),
200            3 => Some(Self::AttemptIdMismatch),
201            _ => None,
202        }
203    }
204
205    #[inline]
206    pub const fn into_primitive(self) -> u32 {
207        self as u32
208    }
209}
210
211/// The set of values that are returned by an request to start an update.
212#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
213#[repr(u32)]
214pub enum UpdateNotStartedReason {
215    /// There was already another update attempt in progress when this request was
216    /// made.  A new update attempt will not be started.
217    AlreadyInProgress = 1,
218}
219
220impl UpdateNotStartedReason {
221    #[inline]
222    pub fn from_primitive(prim: u32) -> Option<Self> {
223        match prim {
224            1 => Some(Self::AlreadyInProgress),
225            _ => None,
226        }
227    }
228
229    #[inline]
230    pub const fn into_primitive(self) -> u32 {
231        self as u32
232    }
233}
234
235#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
236pub struct InstallerCancelUpdateRequest {
237    pub attempt_id: Option<String>,
238}
239
240impl fidl::Persistable for InstallerCancelUpdateRequest {}
241
242#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
243pub struct InstallerMonitorUpdateResponse {
244    pub attached: bool,
245}
246
247impl fidl::Persistable for InstallerMonitorUpdateResponse {}
248
249#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
250pub struct InstallerResumeUpdateRequest {
251    pub attempt_id: Option<String>,
252}
253
254impl fidl::Persistable for InstallerResumeUpdateRequest {}
255
256#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
257pub struct InstallerSuspendUpdateRequest {
258    pub attempt_id: Option<String>,
259}
260
261impl fidl::Persistable for InstallerSuspendUpdateRequest {}
262
263#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
264pub struct InstallerStartUpdateResponse {
265    pub attempt_id: String,
266}
267
268impl fidl::Persistable for InstallerStartUpdateResponse {}
269
270#[derive(Clone, Debug, PartialEq)]
271pub struct MonitorOnStateRequest {
272    pub state: State,
273}
274
275impl fidl::Persistable for MonitorOnStateRequest {}
276
277/// Data associated with [`State.canceled`].
278#[derive(Clone, Debug, Default, PartialEq)]
279pub struct CanceledData {
280    #[doc(hidden)]
281    pub __source_breaking: fidl::marker::SourceBreaking,
282}
283
284impl fidl::Persistable for CanceledData {}
285
286/// Data associated with [`State.commit`].
287#[derive(Clone, Debug, Default, PartialEq)]
288pub struct CommitData {
289    pub info: Option<UpdateInfo>,
290    pub progress: Option<InstallationProgress>,
291    #[doc(hidden)]
292    pub __source_breaking: fidl::marker::SourceBreaking,
293}
294
295impl fidl::Persistable for CommitData {}
296
297/// Data associated with [`State.complete`].
298#[derive(Clone, Debug, Default, PartialEq)]
299pub struct CompleteData {
300    pub info: Option<UpdateInfo>,
301    pub progress: Option<InstallationProgress>,
302    #[doc(hidden)]
303    pub __source_breaking: fidl::marker::SourceBreaking,
304}
305
306impl fidl::Persistable for CompleteData {}
307
308/// Data associated with [`State.defer_reboot`].
309#[derive(Clone, Debug, Default, PartialEq)]
310pub struct DeferRebootData {
311    pub info: Option<UpdateInfo>,
312    pub progress: Option<InstallationProgress>,
313    #[doc(hidden)]
314    pub __source_breaking: fidl::marker::SourceBreaking,
315}
316
317impl fidl::Persistable for DeferRebootData {}
318
319/// Data associated with [`State.fail_commit`].
320#[derive(Clone, Debug, Default, PartialEq)]
321pub struct FailCommitData {
322    pub info: Option<UpdateInfo>,
323    pub progress: Option<InstallationProgress>,
324    #[doc(hidden)]
325    pub __source_breaking: fidl::marker::SourceBreaking,
326}
327
328impl fidl::Persistable for FailCommitData {}
329
330/// Data associated with [`State.fail_fetch`].
331#[derive(Clone, Debug, Default, PartialEq)]
332pub struct FailFetchData {
333    pub info: Option<UpdateInfo>,
334    pub progress: Option<InstallationProgress>,
335    pub reason: Option<FetchFailureReason>,
336    #[doc(hidden)]
337    pub __source_breaking: fidl::marker::SourceBreaking,
338}
339
340impl fidl::Persistable for FailFetchData {}
341
342/// Data associated with [`State.fail_prepare`].
343#[derive(Clone, Debug, Default, PartialEq)]
344pub struct FailPrepareData {
345    pub reason: Option<PrepareFailureReason>,
346    #[doc(hidden)]
347    pub __source_breaking: fidl::marker::SourceBreaking,
348}
349
350impl fidl::Persistable for FailPrepareData {}
351
352/// Data associated with [`State.fail_stage`].
353#[derive(Clone, Debug, Default, PartialEq)]
354pub struct FailStageData {
355    pub info: Option<UpdateInfo>,
356    pub progress: Option<InstallationProgress>,
357    pub reason: Option<StageFailureReason>,
358    #[doc(hidden)]
359    pub __source_breaking: fidl::marker::SourceBreaking,
360}
361
362impl fidl::Persistable for FailStageData {}
363
364/// Data associated with [`State.fetch`].
365#[derive(Clone, Debug, Default, PartialEq)]
366pub struct FetchData {
367    pub info: Option<UpdateInfo>,
368    pub progress: Option<InstallationProgress>,
369    #[doc(hidden)]
370    pub __source_breaking: fidl::marker::SourceBreaking,
371}
372
373impl fidl::Persistable for FetchData {}
374
375/// Current progress for an installation attempt.
376#[derive(Clone, Debug, Default, PartialEq)]
377pub struct InstallationProgress {
378    /// The fraction [0-1.0f] of the installation that has been completed.
379    pub fraction_completed: Option<f32>,
380    /// The number of bytes downloaded during this installation attempt. Less
381    /// than or equal to [`UpdateInfo.download_size`] and only present if that
382    /// field is also present.
383    pub bytes_downloaded: Option<u64>,
384    #[doc(hidden)]
385    pub __source_breaking: fidl::marker::SourceBreaking,
386}
387
388impl fidl::Persistable for InstallationProgress {}
389
390/// Configuration options for an update attempt.
391#[derive(Clone, Debug, Default, PartialEq)]
392pub struct Options {
393    /// What initiated this update attempt. Required.
394    pub initiator: Option<Initiator>,
395    /// If an update is already in progress, it's acceptable to instead attach a
396    /// Monitor to that in-progress update instead of failing this request to
397    /// install the update.  Setting this option to true may convert situations
398    /// that would have resulted in the ALREADY_IN_PROGRESS to be treated as
399    /// non-error cases. A controller, if provided, will be ignored if the
400    /// running update attempt already has a controller.
401    pub allow_attach_to_existing_attempt: Option<bool>,
402    /// Determines if the installer should update the recovery partition if an
403    /// update is available.  Defaults to true.
404    pub should_write_recovery: Option<bool>,
405    #[doc(hidden)]
406    pub __source_breaking: fidl::marker::SourceBreaking,
407}
408
409impl fidl::Persistable for Options {}
410
411/// Data associated with [`State.prepare`].
412#[derive(Clone, Debug, Default, PartialEq)]
413pub struct PrepareData {
414    #[doc(hidden)]
415    pub __source_breaking: fidl::marker::SourceBreaking,
416}
417
418impl fidl::Persistable for PrepareData {}
419
420/// Data associated with [`State.reboot`].
421#[derive(Clone, Debug, Default, PartialEq)]
422pub struct RebootData {
423    pub info: Option<UpdateInfo>,
424    pub progress: Option<InstallationProgress>,
425    #[doc(hidden)]
426    pub __source_breaking: fidl::marker::SourceBreaking,
427}
428
429impl fidl::Persistable for RebootData {}
430
431/// Data associated with [`State.stage`].
432#[derive(Clone, Debug, Default, PartialEq)]
433pub struct StageData {
434    pub info: Option<UpdateInfo>,
435    pub progress: Option<InstallationProgress>,
436    #[doc(hidden)]
437    pub __source_breaking: fidl::marker::SourceBreaking,
438}
439
440impl fidl::Persistable for StageData {}
441
442/// Metadata for an update.  Once a field is populated during an installation
443/// attempt, the value will not change.
444#[derive(Clone, Debug, Default, PartialEq)]
445pub struct UpdateInfo {
446    /// The total number of bytes that may be downloaded to apply this update.
447    /// Optional, the installer may not be able to provide this value.
448    pub download_size: Option<u64>,
449    #[doc(hidden)]
450    pub __source_breaking: fidl::marker::SourceBreaking,
451}
452
453impl fidl::Persistable for UpdateInfo {}
454
455/// Data associated with [`State.wait_to_reboot`].
456#[derive(Clone, Debug, Default, PartialEq)]
457pub struct WaitToRebootData {
458    pub info: Option<UpdateInfo>,
459    pub progress: Option<InstallationProgress>,
460    #[doc(hidden)]
461    pub __source_breaking: fidl::marker::SourceBreaking,
462}
463
464impl fidl::Persistable for WaitToRebootData {}
465
466/// The set of states that a [`Monitor`] can receive during an update
467/// installation attempt.
468///
469/// An installation attempt ends when it enters a terminal state, denoted below
470/// as the states on the right-hand side of the diagram with no arrows leading
471/// out of them.
472///
473/// # State Machine Diagram
474///
475/// ```
476///                       +----------------+     +----------------+
477///            +----------|    prepare     |---->|  fail_prepare  |
478///            |          +----------------+     +----------------+
479///            |                  |
480///            |                  v
481///            |          +----------------+     +----------------+
482///            +----------|     stage      |---->|   fail_stage   |
483///            |          +----------------+     +----------------+
484///            |                  |
485///            |                  v
486///            |          +----------------+     +----------------+
487///            +----------|     fetch      |---->|   fail_fetch   |
488///            |          +----------------+     +----------------+
489///            |                  |
490///            |                  v
491///            |          +----------------+     +----------------+
492///            +----------|     commit     |---->|   fail_commit  |
493///            |          +----------------+     +----------------+
494///            v                  |
495///    +----------------+         |              +----------------+
496///    |    canceled    |         +------------> |    complete    |
497///    +----------------+         |              +----------------+
498///                               v
499///                       +----------------+     +----------------+
500///                       | wait_to_reboot |---->|  defer_reboot  |
501///                       +----------------+     +----------------+
502///                               |
503///                               |              +----------------+
504///                               +------------->|     reboot     |
505///                                              +----------------+
506/// ```
507#[derive(Clone, Debug, PartialEq)]
508pub enum State {
509    /// Fetching required metadata to begin the update and verifying system
510    /// state.
511    ///
512    /// Next States:
513    /// * `stage` system is ready to install the update.
514    /// * `fail_prepare` on error.
515    /// * `canceled` on cancel.
516    Prepare(PrepareData),
517    /// Fetching and writing kernel and firmware images.
518    ///
519    /// Next States:
520    /// * `fetch`  required kernel and firmware images are written.
521    /// * `fail_stage`  on error.
522    /// * `canceled` on cancel.
523    Stage(StageData),
524    /// Fetching packages.
525    ///
526    /// Next States:
527    /// * `commit` packages were fetched successfully.
528    /// * `fail_fetch` on error.
529    /// * `canceled` on cancel.
530    Fetch(FetchData),
531    /// Prepare to switch over to the new system by writing the packages
532    /// and switching the active partition.
533    ///
534    /// Next States:
535    /// * `wait_to_reboot` if a reboot is necessary to complete the update.
536    /// * `complete` if no reboot is necessary to complete the update.
537    /// * `fail_commit` on error.
538    /// * `canceled` on cancel.
539    Commit(CommitData),
540    /// The system is configured to boot the updated OS on next boot, and the
541    /// installer is waiting for the trigger to reboot the system.
542    ///
543    /// Next States:
544    /// * `reboot` when the installer decides it is time to initiate the reboot.
545    /// * `defer_reboot` if the initiator specifically requests to not reboot.
546    WaitToReboot(WaitToRebootData),
547    /// The installer has initiated a system reboot into the updated OS.
548    ///
549    /// **This is a terminal state**
550    Reboot(RebootData),
551    /// The initiator specifically requested to skip the reboot, but a reboot is
552    /// still required to complete the update.
553    ///
554    /// **This is a terminal state**
555    DeferReboot(DeferRebootData),
556    /// The update is complete and no reboot was required.
557    ///
558    /// **This is a terminal state**
559    Complete(CompleteData),
560    /// An error occurred while preparing the install.
561    ///
562    /// **This is a terminal state**
563    FailPrepare(FailPrepareData),
564    /// An error occurred while staging the images for the OS.
565    ///
566    /// **This is a terminal state**
567    FailStage(FailStageData),
568    /// An error occurred while fetching the required artifacts.
569    ///
570    /// **This is a terminal state**
571    FailFetch(FailFetchData),
572    /// An error occured while switching partitions.
573    ///
574    /// **This is a terminal state**
575    FailCommit(FailCommitData),
576    /// The update is canceled.
577    ///
578    /// **This is a terminal state**
579    Canceled(CanceledData),
580}
581
582impl State {
583    #[inline]
584    pub fn ordinal(&self) -> u64 {
585        match *self {
586            Self::Prepare(_) => 1,
587            Self::Stage(_) => 2,
588            Self::Fetch(_) => 3,
589            Self::Commit(_) => 4,
590            Self::WaitToReboot(_) => 5,
591            Self::Reboot(_) => 6,
592            Self::DeferReboot(_) => 7,
593            Self::Complete(_) => 8,
594            Self::FailPrepare(_) => 9,
595            Self::FailStage(_) => 10,
596            Self::FailFetch(_) => 11,
597            Self::FailCommit(_) => 12,
598            Self::Canceled(_) => 13,
599        }
600    }
601}
602
603impl fidl::Persistable for State {}
604
605pub mod installer_ordinals {
606    pub const START_UPDATE: u64 = 0x2b1c5ba9167c320b;
607    pub const MONITOR_UPDATE: u64 = 0x21d54aa1fd825a32;
608    pub const SUSPEND_UPDATE: u64 = 0x788de328461f9950;
609    pub const RESUME_UPDATE: u64 = 0x7479e805fec33dd3;
610    pub const CANCEL_UPDATE: u64 = 0x472dec9160a1d0f;
611}
612
613pub mod monitor_ordinals {
614    pub const ON_STATE: u64 = 0x574105820d16cf26;
615}
616
617pub mod reboot_controller_ordinals {
618    pub const UNBLOCK: u64 = 0x5705625395e3d520;
619    pub const DETACH: u64 = 0x1daa560411955f16;
620}
621
622mod internal {
623    use super::*;
624    unsafe impl fidl::encoding::TypeMarker for CancelError {
625        type Owned = Self;
626
627        #[inline(always)]
628        fn inline_align(_context: fidl::encoding::Context) -> usize {
629            std::mem::align_of::<u32>()
630        }
631
632        #[inline(always)]
633        fn inline_size(_context: fidl::encoding::Context) -> usize {
634            std::mem::size_of::<u32>()
635        }
636
637        #[inline(always)]
638        fn encode_is_copy() -> bool {
639            true
640        }
641
642        #[inline(always)]
643        fn decode_is_copy() -> bool {
644            false
645        }
646    }
647
648    impl fidl::encoding::ValueTypeMarker for CancelError {
649        type Borrowed<'a> = Self;
650        #[inline(always)]
651        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
652            *value
653        }
654    }
655
656    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CancelError {
657        #[inline]
658        unsafe fn encode(
659            self,
660            encoder: &mut fidl::encoding::Encoder<'_, D>,
661            offset: usize,
662            _depth: fidl::encoding::Depth,
663        ) -> fidl::Result<()> {
664            encoder.debug_check_bounds::<Self>(offset);
665            encoder.write_num(self.into_primitive(), offset);
666            Ok(())
667        }
668    }
669
670    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CancelError {
671        #[inline(always)]
672        fn new_empty() -> Self {
673            Self::NoUpdateInProgress
674        }
675
676        #[inline]
677        unsafe fn decode(
678            &mut self,
679            decoder: &mut fidl::encoding::Decoder<'_, D>,
680            offset: usize,
681            _depth: fidl::encoding::Depth,
682        ) -> fidl::Result<()> {
683            decoder.debug_check_bounds::<Self>(offset);
684            let prim = decoder.read_num::<u32>(offset);
685
686            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
687            Ok(())
688        }
689    }
690    unsafe impl fidl::encoding::TypeMarker for FetchFailureReason {
691        type Owned = Self;
692
693        #[inline(always)]
694        fn inline_align(_context: fidl::encoding::Context) -> usize {
695            std::mem::align_of::<u32>()
696        }
697
698        #[inline(always)]
699        fn inline_size(_context: fidl::encoding::Context) -> usize {
700            std::mem::size_of::<u32>()
701        }
702
703        #[inline(always)]
704        fn encode_is_copy() -> bool {
705            true
706        }
707
708        #[inline(always)]
709        fn decode_is_copy() -> bool {
710            false
711        }
712    }
713
714    impl fidl::encoding::ValueTypeMarker for FetchFailureReason {
715        type Borrowed<'a> = Self;
716        #[inline(always)]
717        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
718            *value
719        }
720    }
721
722    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
723        for FetchFailureReason
724    {
725        #[inline]
726        unsafe fn encode(
727            self,
728            encoder: &mut fidl::encoding::Encoder<'_, D>,
729            offset: usize,
730            _depth: fidl::encoding::Depth,
731        ) -> fidl::Result<()> {
732            encoder.debug_check_bounds::<Self>(offset);
733            encoder.write_num(self.into_primitive(), offset);
734            Ok(())
735        }
736    }
737
738    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FetchFailureReason {
739        #[inline(always)]
740        fn new_empty() -> Self {
741            Self::Internal
742        }
743
744        #[inline]
745        unsafe fn decode(
746            &mut self,
747            decoder: &mut fidl::encoding::Decoder<'_, D>,
748            offset: usize,
749            _depth: fidl::encoding::Depth,
750        ) -> fidl::Result<()> {
751            decoder.debug_check_bounds::<Self>(offset);
752            let prim = decoder.read_num::<u32>(offset);
753
754            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
755            Ok(())
756        }
757    }
758    unsafe impl fidl::encoding::TypeMarker for Initiator {
759        type Owned = Self;
760
761        #[inline(always)]
762        fn inline_align(_context: fidl::encoding::Context) -> usize {
763            std::mem::align_of::<u32>()
764        }
765
766        #[inline(always)]
767        fn inline_size(_context: fidl::encoding::Context) -> usize {
768            std::mem::size_of::<u32>()
769        }
770
771        #[inline(always)]
772        fn encode_is_copy() -> bool {
773            true
774        }
775
776        #[inline(always)]
777        fn decode_is_copy() -> bool {
778            false
779        }
780    }
781
782    impl fidl::encoding::ValueTypeMarker for Initiator {
783        type Borrowed<'a> = Self;
784        #[inline(always)]
785        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
786            *value
787        }
788    }
789
790    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Initiator {
791        #[inline]
792        unsafe fn encode(
793            self,
794            encoder: &mut fidl::encoding::Encoder<'_, D>,
795            offset: usize,
796            _depth: fidl::encoding::Depth,
797        ) -> fidl::Result<()> {
798            encoder.debug_check_bounds::<Self>(offset);
799            encoder.write_num(self.into_primitive(), offset);
800            Ok(())
801        }
802    }
803
804    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Initiator {
805        #[inline(always)]
806        fn new_empty() -> Self {
807            Self::User
808        }
809
810        #[inline]
811        unsafe fn decode(
812            &mut self,
813            decoder: &mut fidl::encoding::Decoder<'_, D>,
814            offset: usize,
815            _depth: fidl::encoding::Depth,
816        ) -> fidl::Result<()> {
817            decoder.debug_check_bounds::<Self>(offset);
818            let prim = decoder.read_num::<u32>(offset);
819
820            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
821            Ok(())
822        }
823    }
824    unsafe impl fidl::encoding::TypeMarker for PrepareFailureReason {
825        type Owned = Self;
826
827        #[inline(always)]
828        fn inline_align(_context: fidl::encoding::Context) -> usize {
829            std::mem::align_of::<u32>()
830        }
831
832        #[inline(always)]
833        fn inline_size(_context: fidl::encoding::Context) -> usize {
834            std::mem::size_of::<u32>()
835        }
836
837        #[inline(always)]
838        fn encode_is_copy() -> bool {
839            true
840        }
841
842        #[inline(always)]
843        fn decode_is_copy() -> bool {
844            false
845        }
846    }
847
848    impl fidl::encoding::ValueTypeMarker for PrepareFailureReason {
849        type Borrowed<'a> = Self;
850        #[inline(always)]
851        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
852            *value
853        }
854    }
855
856    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
857        for PrepareFailureReason
858    {
859        #[inline]
860        unsafe fn encode(
861            self,
862            encoder: &mut fidl::encoding::Encoder<'_, D>,
863            offset: usize,
864            _depth: fidl::encoding::Depth,
865        ) -> fidl::Result<()> {
866            encoder.debug_check_bounds::<Self>(offset);
867            encoder.write_num(self.into_primitive(), offset);
868            Ok(())
869        }
870    }
871
872    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PrepareFailureReason {
873        #[inline(always)]
874        fn new_empty() -> Self {
875            Self::Internal
876        }
877
878        #[inline]
879        unsafe fn decode(
880            &mut self,
881            decoder: &mut fidl::encoding::Decoder<'_, D>,
882            offset: usize,
883            _depth: fidl::encoding::Depth,
884        ) -> fidl::Result<()> {
885            decoder.debug_check_bounds::<Self>(offset);
886            let prim = decoder.read_num::<u32>(offset);
887
888            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
889            Ok(())
890        }
891    }
892    unsafe impl fidl::encoding::TypeMarker for ResumeError {
893        type Owned = Self;
894
895        #[inline(always)]
896        fn inline_align(_context: fidl::encoding::Context) -> usize {
897            std::mem::align_of::<u32>()
898        }
899
900        #[inline(always)]
901        fn inline_size(_context: fidl::encoding::Context) -> usize {
902            std::mem::size_of::<u32>()
903        }
904
905        #[inline(always)]
906        fn encode_is_copy() -> bool {
907            true
908        }
909
910        #[inline(always)]
911        fn decode_is_copy() -> bool {
912            false
913        }
914    }
915
916    impl fidl::encoding::ValueTypeMarker for ResumeError {
917        type Borrowed<'a> = Self;
918        #[inline(always)]
919        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
920            *value
921        }
922    }
923
924    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ResumeError {
925        #[inline]
926        unsafe fn encode(
927            self,
928            encoder: &mut fidl::encoding::Encoder<'_, D>,
929            offset: usize,
930            _depth: fidl::encoding::Depth,
931        ) -> fidl::Result<()> {
932            encoder.debug_check_bounds::<Self>(offset);
933            encoder.write_num(self.into_primitive(), offset);
934            Ok(())
935        }
936    }
937
938    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResumeError {
939        #[inline(always)]
940        fn new_empty() -> Self {
941            Self::NoUpdateInProgress
942        }
943
944        #[inline]
945        unsafe fn decode(
946            &mut self,
947            decoder: &mut fidl::encoding::Decoder<'_, D>,
948            offset: usize,
949            _depth: fidl::encoding::Depth,
950        ) -> fidl::Result<()> {
951            decoder.debug_check_bounds::<Self>(offset);
952            let prim = decoder.read_num::<u32>(offset);
953
954            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
955            Ok(())
956        }
957    }
958    unsafe impl fidl::encoding::TypeMarker for StageFailureReason {
959        type Owned = Self;
960
961        #[inline(always)]
962        fn inline_align(_context: fidl::encoding::Context) -> usize {
963            std::mem::align_of::<u32>()
964        }
965
966        #[inline(always)]
967        fn inline_size(_context: fidl::encoding::Context) -> usize {
968            std::mem::size_of::<u32>()
969        }
970
971        #[inline(always)]
972        fn encode_is_copy() -> bool {
973            true
974        }
975
976        #[inline(always)]
977        fn decode_is_copy() -> bool {
978            false
979        }
980    }
981
982    impl fidl::encoding::ValueTypeMarker for StageFailureReason {
983        type Borrowed<'a> = Self;
984        #[inline(always)]
985        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
986            *value
987        }
988    }
989
990    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
991        for StageFailureReason
992    {
993        #[inline]
994        unsafe fn encode(
995            self,
996            encoder: &mut fidl::encoding::Encoder<'_, D>,
997            offset: usize,
998            _depth: fidl::encoding::Depth,
999        ) -> fidl::Result<()> {
1000            encoder.debug_check_bounds::<Self>(offset);
1001            encoder.write_num(self.into_primitive(), offset);
1002            Ok(())
1003        }
1004    }
1005
1006    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StageFailureReason {
1007        #[inline(always)]
1008        fn new_empty() -> Self {
1009            Self::Internal
1010        }
1011
1012        #[inline]
1013        unsafe fn decode(
1014            &mut self,
1015            decoder: &mut fidl::encoding::Decoder<'_, D>,
1016            offset: usize,
1017            _depth: fidl::encoding::Depth,
1018        ) -> fidl::Result<()> {
1019            decoder.debug_check_bounds::<Self>(offset);
1020            let prim = decoder.read_num::<u32>(offset);
1021
1022            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1023            Ok(())
1024        }
1025    }
1026    unsafe impl fidl::encoding::TypeMarker for SuspendError {
1027        type Owned = Self;
1028
1029        #[inline(always)]
1030        fn inline_align(_context: fidl::encoding::Context) -> usize {
1031            std::mem::align_of::<u32>()
1032        }
1033
1034        #[inline(always)]
1035        fn inline_size(_context: fidl::encoding::Context) -> usize {
1036            std::mem::size_of::<u32>()
1037        }
1038
1039        #[inline(always)]
1040        fn encode_is_copy() -> bool {
1041            true
1042        }
1043
1044        #[inline(always)]
1045        fn decode_is_copy() -> bool {
1046            false
1047        }
1048    }
1049
1050    impl fidl::encoding::ValueTypeMarker for SuspendError {
1051        type Borrowed<'a> = Self;
1052        #[inline(always)]
1053        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1054            *value
1055        }
1056    }
1057
1058    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SuspendError {
1059        #[inline]
1060        unsafe fn encode(
1061            self,
1062            encoder: &mut fidl::encoding::Encoder<'_, D>,
1063            offset: usize,
1064            _depth: fidl::encoding::Depth,
1065        ) -> fidl::Result<()> {
1066            encoder.debug_check_bounds::<Self>(offset);
1067            encoder.write_num(self.into_primitive(), offset);
1068            Ok(())
1069        }
1070    }
1071
1072    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SuspendError {
1073        #[inline(always)]
1074        fn new_empty() -> Self {
1075            Self::NoUpdateInProgress
1076        }
1077
1078        #[inline]
1079        unsafe fn decode(
1080            &mut self,
1081            decoder: &mut fidl::encoding::Decoder<'_, D>,
1082            offset: usize,
1083            _depth: fidl::encoding::Depth,
1084        ) -> fidl::Result<()> {
1085            decoder.debug_check_bounds::<Self>(offset);
1086            let prim = decoder.read_num::<u32>(offset);
1087
1088            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1089            Ok(())
1090        }
1091    }
1092    unsafe impl fidl::encoding::TypeMarker for UpdateNotStartedReason {
1093        type Owned = Self;
1094
1095        #[inline(always)]
1096        fn inline_align(_context: fidl::encoding::Context) -> usize {
1097            std::mem::align_of::<u32>()
1098        }
1099
1100        #[inline(always)]
1101        fn inline_size(_context: fidl::encoding::Context) -> usize {
1102            std::mem::size_of::<u32>()
1103        }
1104
1105        #[inline(always)]
1106        fn encode_is_copy() -> bool {
1107            true
1108        }
1109
1110        #[inline(always)]
1111        fn decode_is_copy() -> bool {
1112            false
1113        }
1114    }
1115
1116    impl fidl::encoding::ValueTypeMarker for UpdateNotStartedReason {
1117        type Borrowed<'a> = Self;
1118        #[inline(always)]
1119        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1120            *value
1121        }
1122    }
1123
1124    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1125        for UpdateNotStartedReason
1126    {
1127        #[inline]
1128        unsafe fn encode(
1129            self,
1130            encoder: &mut fidl::encoding::Encoder<'_, D>,
1131            offset: usize,
1132            _depth: fidl::encoding::Depth,
1133        ) -> fidl::Result<()> {
1134            encoder.debug_check_bounds::<Self>(offset);
1135            encoder.write_num(self.into_primitive(), offset);
1136            Ok(())
1137        }
1138    }
1139
1140    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1141        for UpdateNotStartedReason
1142    {
1143        #[inline(always)]
1144        fn new_empty() -> Self {
1145            Self::AlreadyInProgress
1146        }
1147
1148        #[inline]
1149        unsafe fn decode(
1150            &mut self,
1151            decoder: &mut fidl::encoding::Decoder<'_, D>,
1152            offset: usize,
1153            _depth: fidl::encoding::Depth,
1154        ) -> fidl::Result<()> {
1155            decoder.debug_check_bounds::<Self>(offset);
1156            let prim = decoder.read_num::<u32>(offset);
1157
1158            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1159            Ok(())
1160        }
1161    }
1162
1163    impl fidl::encoding::ValueTypeMarker for InstallerCancelUpdateRequest {
1164        type Borrowed<'a> = &'a Self;
1165        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1166            value
1167        }
1168    }
1169
1170    unsafe impl fidl::encoding::TypeMarker for InstallerCancelUpdateRequest {
1171        type Owned = Self;
1172
1173        #[inline(always)]
1174        fn inline_align(_context: fidl::encoding::Context) -> usize {
1175            8
1176        }
1177
1178        #[inline(always)]
1179        fn inline_size(_context: fidl::encoding::Context) -> usize {
1180            16
1181        }
1182    }
1183
1184    unsafe impl<D: fidl::encoding::ResourceDialect>
1185        fidl::encoding::Encode<InstallerCancelUpdateRequest, D> for &InstallerCancelUpdateRequest
1186    {
1187        #[inline]
1188        unsafe fn encode(
1189            self,
1190            encoder: &mut fidl::encoding::Encoder<'_, D>,
1191            offset: usize,
1192            _depth: fidl::encoding::Depth,
1193        ) -> fidl::Result<()> {
1194            encoder.debug_check_bounds::<InstallerCancelUpdateRequest>(offset);
1195            // Delegate to tuple encoding.
1196            fidl::encoding::Encode::<InstallerCancelUpdateRequest, D>::encode(
1197                (
1198                    <fidl::encoding::Optional<fidl::encoding::BoundedString<36>> as fidl::encoding::ValueTypeMarker>::borrow(&self.attempt_id),
1199                ),
1200                encoder, offset, _depth
1201            )
1202        }
1203    }
1204    unsafe impl<
1205            D: fidl::encoding::ResourceDialect,
1206            T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<36>>, D>,
1207        > fidl::encoding::Encode<InstallerCancelUpdateRequest, D> for (T0,)
1208    {
1209        #[inline]
1210        unsafe fn encode(
1211            self,
1212            encoder: &mut fidl::encoding::Encoder<'_, D>,
1213            offset: usize,
1214            depth: fidl::encoding::Depth,
1215        ) -> fidl::Result<()> {
1216            encoder.debug_check_bounds::<InstallerCancelUpdateRequest>(offset);
1217            // Zero out padding regions. There's no need to apply masks
1218            // because the unmasked parts will be overwritten by fields.
1219            // Write the fields.
1220            self.0.encode(encoder, offset + 0, depth)?;
1221            Ok(())
1222        }
1223    }
1224
1225    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1226        for InstallerCancelUpdateRequest
1227    {
1228        #[inline(always)]
1229        fn new_empty() -> Self {
1230            Self {
1231                attempt_id: fidl::new_empty!(
1232                    fidl::encoding::Optional<fidl::encoding::BoundedString<36>>,
1233                    D
1234                ),
1235            }
1236        }
1237
1238        #[inline]
1239        unsafe fn decode(
1240            &mut self,
1241            decoder: &mut fidl::encoding::Decoder<'_, D>,
1242            offset: usize,
1243            _depth: fidl::encoding::Depth,
1244        ) -> fidl::Result<()> {
1245            decoder.debug_check_bounds::<Self>(offset);
1246            // Verify that padding bytes are zero.
1247            fidl::decode!(
1248                fidl::encoding::Optional<fidl::encoding::BoundedString<36>>,
1249                D,
1250                &mut self.attempt_id,
1251                decoder,
1252                offset + 0,
1253                _depth
1254            )?;
1255            Ok(())
1256        }
1257    }
1258
1259    impl fidl::encoding::ValueTypeMarker for InstallerMonitorUpdateResponse {
1260        type Borrowed<'a> = &'a Self;
1261        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1262            value
1263        }
1264    }
1265
1266    unsafe impl fidl::encoding::TypeMarker for InstallerMonitorUpdateResponse {
1267        type Owned = Self;
1268
1269        #[inline(always)]
1270        fn inline_align(_context: fidl::encoding::Context) -> usize {
1271            1
1272        }
1273
1274        #[inline(always)]
1275        fn inline_size(_context: fidl::encoding::Context) -> usize {
1276            1
1277        }
1278    }
1279
1280    unsafe impl<D: fidl::encoding::ResourceDialect>
1281        fidl::encoding::Encode<InstallerMonitorUpdateResponse, D>
1282        for &InstallerMonitorUpdateResponse
1283    {
1284        #[inline]
1285        unsafe fn encode(
1286            self,
1287            encoder: &mut fidl::encoding::Encoder<'_, D>,
1288            offset: usize,
1289            _depth: fidl::encoding::Depth,
1290        ) -> fidl::Result<()> {
1291            encoder.debug_check_bounds::<InstallerMonitorUpdateResponse>(offset);
1292            // Delegate to tuple encoding.
1293            fidl::encoding::Encode::<InstallerMonitorUpdateResponse, D>::encode(
1294                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.attached),),
1295                encoder,
1296                offset,
1297                _depth,
1298            )
1299        }
1300    }
1301    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
1302        fidl::encoding::Encode<InstallerMonitorUpdateResponse, D> for (T0,)
1303    {
1304        #[inline]
1305        unsafe fn encode(
1306            self,
1307            encoder: &mut fidl::encoding::Encoder<'_, D>,
1308            offset: usize,
1309            depth: fidl::encoding::Depth,
1310        ) -> fidl::Result<()> {
1311            encoder.debug_check_bounds::<InstallerMonitorUpdateResponse>(offset);
1312            // Zero out padding regions. There's no need to apply masks
1313            // because the unmasked parts will be overwritten by fields.
1314            // Write the fields.
1315            self.0.encode(encoder, offset + 0, depth)?;
1316            Ok(())
1317        }
1318    }
1319
1320    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1321        for InstallerMonitorUpdateResponse
1322    {
1323        #[inline(always)]
1324        fn new_empty() -> Self {
1325            Self { attached: fidl::new_empty!(bool, D) }
1326        }
1327
1328        #[inline]
1329        unsafe fn decode(
1330            &mut self,
1331            decoder: &mut fidl::encoding::Decoder<'_, D>,
1332            offset: usize,
1333            _depth: fidl::encoding::Depth,
1334        ) -> fidl::Result<()> {
1335            decoder.debug_check_bounds::<Self>(offset);
1336            // Verify that padding bytes are zero.
1337            fidl::decode!(bool, D, &mut self.attached, decoder, offset + 0, _depth)?;
1338            Ok(())
1339        }
1340    }
1341
1342    impl fidl::encoding::ValueTypeMarker for InstallerResumeUpdateRequest {
1343        type Borrowed<'a> = &'a Self;
1344        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1345            value
1346        }
1347    }
1348
1349    unsafe impl fidl::encoding::TypeMarker for InstallerResumeUpdateRequest {
1350        type Owned = Self;
1351
1352        #[inline(always)]
1353        fn inline_align(_context: fidl::encoding::Context) -> usize {
1354            8
1355        }
1356
1357        #[inline(always)]
1358        fn inline_size(_context: fidl::encoding::Context) -> usize {
1359            16
1360        }
1361    }
1362
1363    unsafe impl<D: fidl::encoding::ResourceDialect>
1364        fidl::encoding::Encode<InstallerResumeUpdateRequest, D> for &InstallerResumeUpdateRequest
1365    {
1366        #[inline]
1367        unsafe fn encode(
1368            self,
1369            encoder: &mut fidl::encoding::Encoder<'_, D>,
1370            offset: usize,
1371            _depth: fidl::encoding::Depth,
1372        ) -> fidl::Result<()> {
1373            encoder.debug_check_bounds::<InstallerResumeUpdateRequest>(offset);
1374            // Delegate to tuple encoding.
1375            fidl::encoding::Encode::<InstallerResumeUpdateRequest, D>::encode(
1376                (
1377                    <fidl::encoding::Optional<fidl::encoding::BoundedString<36>> as fidl::encoding::ValueTypeMarker>::borrow(&self.attempt_id),
1378                ),
1379                encoder, offset, _depth
1380            )
1381        }
1382    }
1383    unsafe impl<
1384            D: fidl::encoding::ResourceDialect,
1385            T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<36>>, D>,
1386        > fidl::encoding::Encode<InstallerResumeUpdateRequest, D> for (T0,)
1387    {
1388        #[inline]
1389        unsafe fn encode(
1390            self,
1391            encoder: &mut fidl::encoding::Encoder<'_, D>,
1392            offset: usize,
1393            depth: fidl::encoding::Depth,
1394        ) -> fidl::Result<()> {
1395            encoder.debug_check_bounds::<InstallerResumeUpdateRequest>(offset);
1396            // Zero out padding regions. There's no need to apply masks
1397            // because the unmasked parts will be overwritten by fields.
1398            // Write the fields.
1399            self.0.encode(encoder, offset + 0, depth)?;
1400            Ok(())
1401        }
1402    }
1403
1404    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1405        for InstallerResumeUpdateRequest
1406    {
1407        #[inline(always)]
1408        fn new_empty() -> Self {
1409            Self {
1410                attempt_id: fidl::new_empty!(
1411                    fidl::encoding::Optional<fidl::encoding::BoundedString<36>>,
1412                    D
1413                ),
1414            }
1415        }
1416
1417        #[inline]
1418        unsafe fn decode(
1419            &mut self,
1420            decoder: &mut fidl::encoding::Decoder<'_, D>,
1421            offset: usize,
1422            _depth: fidl::encoding::Depth,
1423        ) -> fidl::Result<()> {
1424            decoder.debug_check_bounds::<Self>(offset);
1425            // Verify that padding bytes are zero.
1426            fidl::decode!(
1427                fidl::encoding::Optional<fidl::encoding::BoundedString<36>>,
1428                D,
1429                &mut self.attempt_id,
1430                decoder,
1431                offset + 0,
1432                _depth
1433            )?;
1434            Ok(())
1435        }
1436    }
1437
1438    impl fidl::encoding::ValueTypeMarker for InstallerSuspendUpdateRequest {
1439        type Borrowed<'a> = &'a Self;
1440        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1441            value
1442        }
1443    }
1444
1445    unsafe impl fidl::encoding::TypeMarker for InstallerSuspendUpdateRequest {
1446        type Owned = Self;
1447
1448        #[inline(always)]
1449        fn inline_align(_context: fidl::encoding::Context) -> usize {
1450            8
1451        }
1452
1453        #[inline(always)]
1454        fn inline_size(_context: fidl::encoding::Context) -> usize {
1455            16
1456        }
1457    }
1458
1459    unsafe impl<D: fidl::encoding::ResourceDialect>
1460        fidl::encoding::Encode<InstallerSuspendUpdateRequest, D>
1461        for &InstallerSuspendUpdateRequest
1462    {
1463        #[inline]
1464        unsafe fn encode(
1465            self,
1466            encoder: &mut fidl::encoding::Encoder<'_, D>,
1467            offset: usize,
1468            _depth: fidl::encoding::Depth,
1469        ) -> fidl::Result<()> {
1470            encoder.debug_check_bounds::<InstallerSuspendUpdateRequest>(offset);
1471            // Delegate to tuple encoding.
1472            fidl::encoding::Encode::<InstallerSuspendUpdateRequest, D>::encode(
1473                (
1474                    <fidl::encoding::Optional<fidl::encoding::BoundedString<36>> as fidl::encoding::ValueTypeMarker>::borrow(&self.attempt_id),
1475                ),
1476                encoder, offset, _depth
1477            )
1478        }
1479    }
1480    unsafe impl<
1481            D: fidl::encoding::ResourceDialect,
1482            T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<36>>, D>,
1483        > fidl::encoding::Encode<InstallerSuspendUpdateRequest, D> for (T0,)
1484    {
1485        #[inline]
1486        unsafe fn encode(
1487            self,
1488            encoder: &mut fidl::encoding::Encoder<'_, D>,
1489            offset: usize,
1490            depth: fidl::encoding::Depth,
1491        ) -> fidl::Result<()> {
1492            encoder.debug_check_bounds::<InstallerSuspendUpdateRequest>(offset);
1493            // Zero out padding regions. There's no need to apply masks
1494            // because the unmasked parts will be overwritten by fields.
1495            // Write the fields.
1496            self.0.encode(encoder, offset + 0, depth)?;
1497            Ok(())
1498        }
1499    }
1500
1501    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1502        for InstallerSuspendUpdateRequest
1503    {
1504        #[inline(always)]
1505        fn new_empty() -> Self {
1506            Self {
1507                attempt_id: fidl::new_empty!(
1508                    fidl::encoding::Optional<fidl::encoding::BoundedString<36>>,
1509                    D
1510                ),
1511            }
1512        }
1513
1514        #[inline]
1515        unsafe fn decode(
1516            &mut self,
1517            decoder: &mut fidl::encoding::Decoder<'_, D>,
1518            offset: usize,
1519            _depth: fidl::encoding::Depth,
1520        ) -> fidl::Result<()> {
1521            decoder.debug_check_bounds::<Self>(offset);
1522            // Verify that padding bytes are zero.
1523            fidl::decode!(
1524                fidl::encoding::Optional<fidl::encoding::BoundedString<36>>,
1525                D,
1526                &mut self.attempt_id,
1527                decoder,
1528                offset + 0,
1529                _depth
1530            )?;
1531            Ok(())
1532        }
1533    }
1534
1535    impl fidl::encoding::ValueTypeMarker for InstallerStartUpdateResponse {
1536        type Borrowed<'a> = &'a Self;
1537        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1538            value
1539        }
1540    }
1541
1542    unsafe impl fidl::encoding::TypeMarker for InstallerStartUpdateResponse {
1543        type Owned = Self;
1544
1545        #[inline(always)]
1546        fn inline_align(_context: fidl::encoding::Context) -> usize {
1547            8
1548        }
1549
1550        #[inline(always)]
1551        fn inline_size(_context: fidl::encoding::Context) -> usize {
1552            16
1553        }
1554    }
1555
1556    unsafe impl<D: fidl::encoding::ResourceDialect>
1557        fidl::encoding::Encode<InstallerStartUpdateResponse, D> for &InstallerStartUpdateResponse
1558    {
1559        #[inline]
1560        unsafe fn encode(
1561            self,
1562            encoder: &mut fidl::encoding::Encoder<'_, D>,
1563            offset: usize,
1564            _depth: fidl::encoding::Depth,
1565        ) -> fidl::Result<()> {
1566            encoder.debug_check_bounds::<InstallerStartUpdateResponse>(offset);
1567            // Delegate to tuple encoding.
1568            fidl::encoding::Encode::<InstallerStartUpdateResponse, D>::encode(
1569                (<fidl::encoding::BoundedString<36> as fidl::encoding::ValueTypeMarker>::borrow(
1570                    &self.attempt_id,
1571                ),),
1572                encoder,
1573                offset,
1574                _depth,
1575            )
1576        }
1577    }
1578    unsafe impl<
1579            D: fidl::encoding::ResourceDialect,
1580            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<36>, D>,
1581        > fidl::encoding::Encode<InstallerStartUpdateResponse, D> for (T0,)
1582    {
1583        #[inline]
1584        unsafe fn encode(
1585            self,
1586            encoder: &mut fidl::encoding::Encoder<'_, D>,
1587            offset: usize,
1588            depth: fidl::encoding::Depth,
1589        ) -> fidl::Result<()> {
1590            encoder.debug_check_bounds::<InstallerStartUpdateResponse>(offset);
1591            // Zero out padding regions. There's no need to apply masks
1592            // because the unmasked parts will be overwritten by fields.
1593            // Write the fields.
1594            self.0.encode(encoder, offset + 0, depth)?;
1595            Ok(())
1596        }
1597    }
1598
1599    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1600        for InstallerStartUpdateResponse
1601    {
1602        #[inline(always)]
1603        fn new_empty() -> Self {
1604            Self { attempt_id: fidl::new_empty!(fidl::encoding::BoundedString<36>, D) }
1605        }
1606
1607        #[inline]
1608        unsafe fn decode(
1609            &mut self,
1610            decoder: &mut fidl::encoding::Decoder<'_, D>,
1611            offset: usize,
1612            _depth: fidl::encoding::Depth,
1613        ) -> fidl::Result<()> {
1614            decoder.debug_check_bounds::<Self>(offset);
1615            // Verify that padding bytes are zero.
1616            fidl::decode!(
1617                fidl::encoding::BoundedString<36>,
1618                D,
1619                &mut self.attempt_id,
1620                decoder,
1621                offset + 0,
1622                _depth
1623            )?;
1624            Ok(())
1625        }
1626    }
1627
1628    impl fidl::encoding::ValueTypeMarker for MonitorOnStateRequest {
1629        type Borrowed<'a> = &'a Self;
1630        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1631            value
1632        }
1633    }
1634
1635    unsafe impl fidl::encoding::TypeMarker for MonitorOnStateRequest {
1636        type Owned = Self;
1637
1638        #[inline(always)]
1639        fn inline_align(_context: fidl::encoding::Context) -> usize {
1640            8
1641        }
1642
1643        #[inline(always)]
1644        fn inline_size(_context: fidl::encoding::Context) -> usize {
1645            16
1646        }
1647    }
1648
1649    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MonitorOnStateRequest, D>
1650        for &MonitorOnStateRequest
1651    {
1652        #[inline]
1653        unsafe fn encode(
1654            self,
1655            encoder: &mut fidl::encoding::Encoder<'_, D>,
1656            offset: usize,
1657            _depth: fidl::encoding::Depth,
1658        ) -> fidl::Result<()> {
1659            encoder.debug_check_bounds::<MonitorOnStateRequest>(offset);
1660            // Delegate to tuple encoding.
1661            fidl::encoding::Encode::<MonitorOnStateRequest, D>::encode(
1662                (<State as fidl::encoding::ValueTypeMarker>::borrow(&self.state),),
1663                encoder,
1664                offset,
1665                _depth,
1666            )
1667        }
1668    }
1669    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<State, D>>
1670        fidl::encoding::Encode<MonitorOnStateRequest, D> for (T0,)
1671    {
1672        #[inline]
1673        unsafe fn encode(
1674            self,
1675            encoder: &mut fidl::encoding::Encoder<'_, D>,
1676            offset: usize,
1677            depth: fidl::encoding::Depth,
1678        ) -> fidl::Result<()> {
1679            encoder.debug_check_bounds::<MonitorOnStateRequest>(offset);
1680            // Zero out padding regions. There's no need to apply masks
1681            // because the unmasked parts will be overwritten by fields.
1682            // Write the fields.
1683            self.0.encode(encoder, offset + 0, depth)?;
1684            Ok(())
1685        }
1686    }
1687
1688    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MonitorOnStateRequest {
1689        #[inline(always)]
1690        fn new_empty() -> Self {
1691            Self { state: fidl::new_empty!(State, D) }
1692        }
1693
1694        #[inline]
1695        unsafe fn decode(
1696            &mut self,
1697            decoder: &mut fidl::encoding::Decoder<'_, D>,
1698            offset: usize,
1699            _depth: fidl::encoding::Depth,
1700        ) -> fidl::Result<()> {
1701            decoder.debug_check_bounds::<Self>(offset);
1702            // Verify that padding bytes are zero.
1703            fidl::decode!(State, D, &mut self.state, decoder, offset + 0, _depth)?;
1704            Ok(())
1705        }
1706    }
1707
1708    impl CanceledData {
1709        #[inline(always)]
1710        fn max_ordinal_present(&self) -> u64 {
1711            0
1712        }
1713    }
1714
1715    impl fidl::encoding::ValueTypeMarker for CanceledData {
1716        type Borrowed<'a> = &'a Self;
1717        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1718            value
1719        }
1720    }
1721
1722    unsafe impl fidl::encoding::TypeMarker for CanceledData {
1723        type Owned = Self;
1724
1725        #[inline(always)]
1726        fn inline_align(_context: fidl::encoding::Context) -> usize {
1727            8
1728        }
1729
1730        #[inline(always)]
1731        fn inline_size(_context: fidl::encoding::Context) -> usize {
1732            16
1733        }
1734    }
1735
1736    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CanceledData, D>
1737        for &CanceledData
1738    {
1739        unsafe fn encode(
1740            self,
1741            encoder: &mut fidl::encoding::Encoder<'_, D>,
1742            offset: usize,
1743            mut depth: fidl::encoding::Depth,
1744        ) -> fidl::Result<()> {
1745            encoder.debug_check_bounds::<CanceledData>(offset);
1746            // Vector header
1747            let max_ordinal: u64 = self.max_ordinal_present();
1748            encoder.write_num(max_ordinal, offset);
1749            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1750            // Calling encoder.out_of_line_offset(0) is not allowed.
1751            if max_ordinal == 0 {
1752                return Ok(());
1753            }
1754            depth.increment()?;
1755            let envelope_size = 8;
1756            let bytes_len = max_ordinal as usize * envelope_size;
1757            #[allow(unused_variables)]
1758            let offset = encoder.out_of_line_offset(bytes_len);
1759            let mut _prev_end_offset: usize = 0;
1760
1761            Ok(())
1762        }
1763    }
1764
1765    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CanceledData {
1766        #[inline(always)]
1767        fn new_empty() -> Self {
1768            Self::default()
1769        }
1770
1771        unsafe fn decode(
1772            &mut self,
1773            decoder: &mut fidl::encoding::Decoder<'_, D>,
1774            offset: usize,
1775            mut depth: fidl::encoding::Depth,
1776        ) -> fidl::Result<()> {
1777            decoder.debug_check_bounds::<Self>(offset);
1778            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1779                None => return Err(fidl::Error::NotNullable),
1780                Some(len) => len,
1781            };
1782            // Calling decoder.out_of_line_offset(0) is not allowed.
1783            if len == 0 {
1784                return Ok(());
1785            };
1786            depth.increment()?;
1787            let envelope_size = 8;
1788            let bytes_len = len * envelope_size;
1789            let offset = decoder.out_of_line_offset(bytes_len)?;
1790            // Decode the envelope for each type.
1791            let mut _next_ordinal_to_read = 0;
1792            let mut next_offset = offset;
1793            let end_offset = offset + bytes_len;
1794
1795            // Decode the remaining unknown envelopes.
1796            while next_offset < end_offset {
1797                _next_ordinal_to_read += 1;
1798                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1799                next_offset += envelope_size;
1800            }
1801
1802            Ok(())
1803        }
1804    }
1805
1806    impl CommitData {
1807        #[inline(always)]
1808        fn max_ordinal_present(&self) -> u64 {
1809            if let Some(_) = self.progress {
1810                return 2;
1811            }
1812            if let Some(_) = self.info {
1813                return 1;
1814            }
1815            0
1816        }
1817    }
1818
1819    impl fidl::encoding::ValueTypeMarker for CommitData {
1820        type Borrowed<'a> = &'a Self;
1821        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1822            value
1823        }
1824    }
1825
1826    unsafe impl fidl::encoding::TypeMarker for CommitData {
1827        type Owned = Self;
1828
1829        #[inline(always)]
1830        fn inline_align(_context: fidl::encoding::Context) -> usize {
1831            8
1832        }
1833
1834        #[inline(always)]
1835        fn inline_size(_context: fidl::encoding::Context) -> usize {
1836            16
1837        }
1838    }
1839
1840    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CommitData, D>
1841        for &CommitData
1842    {
1843        unsafe fn encode(
1844            self,
1845            encoder: &mut fidl::encoding::Encoder<'_, D>,
1846            offset: usize,
1847            mut depth: fidl::encoding::Depth,
1848        ) -> fidl::Result<()> {
1849            encoder.debug_check_bounds::<CommitData>(offset);
1850            // Vector header
1851            let max_ordinal: u64 = self.max_ordinal_present();
1852            encoder.write_num(max_ordinal, offset);
1853            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1854            // Calling encoder.out_of_line_offset(0) is not allowed.
1855            if max_ordinal == 0 {
1856                return Ok(());
1857            }
1858            depth.increment()?;
1859            let envelope_size = 8;
1860            let bytes_len = max_ordinal as usize * envelope_size;
1861            #[allow(unused_variables)]
1862            let offset = encoder.out_of_line_offset(bytes_len);
1863            let mut _prev_end_offset: usize = 0;
1864            if 1 > max_ordinal {
1865                return Ok(());
1866            }
1867
1868            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1869            // are envelope_size bytes.
1870            let cur_offset: usize = (1 - 1) * envelope_size;
1871
1872            // Zero reserved fields.
1873            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1874
1875            // Safety:
1876            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1877            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1878            //   envelope_size bytes, there is always sufficient room.
1879            fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
1880                self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
1881                encoder,
1882                offset + cur_offset,
1883                depth,
1884            )?;
1885
1886            _prev_end_offset = cur_offset + envelope_size;
1887            if 2 > max_ordinal {
1888                return Ok(());
1889            }
1890
1891            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1892            // are envelope_size bytes.
1893            let cur_offset: usize = (2 - 1) * envelope_size;
1894
1895            // Zero reserved fields.
1896            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1897
1898            // Safety:
1899            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1900            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1901            //   envelope_size bytes, there is always sufficient room.
1902            fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
1903                self.progress
1904                    .as_ref()
1905                    .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
1906                encoder,
1907                offset + cur_offset,
1908                depth,
1909            )?;
1910
1911            _prev_end_offset = cur_offset + envelope_size;
1912
1913            Ok(())
1914        }
1915    }
1916
1917    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CommitData {
1918        #[inline(always)]
1919        fn new_empty() -> Self {
1920            Self::default()
1921        }
1922
1923        unsafe fn decode(
1924            &mut self,
1925            decoder: &mut fidl::encoding::Decoder<'_, D>,
1926            offset: usize,
1927            mut depth: fidl::encoding::Depth,
1928        ) -> fidl::Result<()> {
1929            decoder.debug_check_bounds::<Self>(offset);
1930            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1931                None => return Err(fidl::Error::NotNullable),
1932                Some(len) => len,
1933            };
1934            // Calling decoder.out_of_line_offset(0) is not allowed.
1935            if len == 0 {
1936                return Ok(());
1937            };
1938            depth.increment()?;
1939            let envelope_size = 8;
1940            let bytes_len = len * envelope_size;
1941            let offset = decoder.out_of_line_offset(bytes_len)?;
1942            // Decode the envelope for each type.
1943            let mut _next_ordinal_to_read = 0;
1944            let mut next_offset = offset;
1945            let end_offset = offset + bytes_len;
1946            _next_ordinal_to_read += 1;
1947            if next_offset >= end_offset {
1948                return Ok(());
1949            }
1950
1951            // Decode unknown envelopes for gaps in ordinals.
1952            while _next_ordinal_to_read < 1 {
1953                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1954                _next_ordinal_to_read += 1;
1955                next_offset += envelope_size;
1956            }
1957
1958            let next_out_of_line = decoder.next_out_of_line();
1959            let handles_before = decoder.remaining_handles();
1960            if let Some((inlined, num_bytes, num_handles)) =
1961                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1962            {
1963                let member_inline_size =
1964                    <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1965                if inlined != (member_inline_size <= 4) {
1966                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1967                }
1968                let inner_offset;
1969                let mut inner_depth = depth.clone();
1970                if inlined {
1971                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1972                    inner_offset = next_offset;
1973                } else {
1974                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1975                    inner_depth.increment()?;
1976                }
1977                let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
1978                fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
1979                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1980                {
1981                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1982                }
1983                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1984                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1985                }
1986            }
1987
1988            next_offset += envelope_size;
1989            _next_ordinal_to_read += 1;
1990            if next_offset >= end_offset {
1991                return Ok(());
1992            }
1993
1994            // Decode unknown envelopes for gaps in ordinals.
1995            while _next_ordinal_to_read < 2 {
1996                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1997                _next_ordinal_to_read += 1;
1998                next_offset += envelope_size;
1999            }
2000
2001            let next_out_of_line = decoder.next_out_of_line();
2002            let handles_before = decoder.remaining_handles();
2003            if let Some((inlined, num_bytes, num_handles)) =
2004                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2005            {
2006                let member_inline_size =
2007                    <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
2008                        decoder.context,
2009                    );
2010                if inlined != (member_inline_size <= 4) {
2011                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2012                }
2013                let inner_offset;
2014                let mut inner_depth = depth.clone();
2015                if inlined {
2016                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2017                    inner_offset = next_offset;
2018                } else {
2019                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2020                    inner_depth.increment()?;
2021                }
2022                let val_ref =
2023                    self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
2024                fidl::decode!(
2025                    InstallationProgress,
2026                    D,
2027                    val_ref,
2028                    decoder,
2029                    inner_offset,
2030                    inner_depth
2031                )?;
2032                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2033                {
2034                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2035                }
2036                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2037                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2038                }
2039            }
2040
2041            next_offset += envelope_size;
2042
2043            // Decode the remaining unknown envelopes.
2044            while next_offset < end_offset {
2045                _next_ordinal_to_read += 1;
2046                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2047                next_offset += envelope_size;
2048            }
2049
2050            Ok(())
2051        }
2052    }
2053
2054    impl CompleteData {
2055        #[inline(always)]
2056        fn max_ordinal_present(&self) -> u64 {
2057            if let Some(_) = self.progress {
2058                return 2;
2059            }
2060            if let Some(_) = self.info {
2061                return 1;
2062            }
2063            0
2064        }
2065    }
2066
2067    impl fidl::encoding::ValueTypeMarker for CompleteData {
2068        type Borrowed<'a> = &'a Self;
2069        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2070            value
2071        }
2072    }
2073
2074    unsafe impl fidl::encoding::TypeMarker for CompleteData {
2075        type Owned = Self;
2076
2077        #[inline(always)]
2078        fn inline_align(_context: fidl::encoding::Context) -> usize {
2079            8
2080        }
2081
2082        #[inline(always)]
2083        fn inline_size(_context: fidl::encoding::Context) -> usize {
2084            16
2085        }
2086    }
2087
2088    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompleteData, D>
2089        for &CompleteData
2090    {
2091        unsafe fn encode(
2092            self,
2093            encoder: &mut fidl::encoding::Encoder<'_, D>,
2094            offset: usize,
2095            mut depth: fidl::encoding::Depth,
2096        ) -> fidl::Result<()> {
2097            encoder.debug_check_bounds::<CompleteData>(offset);
2098            // Vector header
2099            let max_ordinal: u64 = self.max_ordinal_present();
2100            encoder.write_num(max_ordinal, offset);
2101            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2102            // Calling encoder.out_of_line_offset(0) is not allowed.
2103            if max_ordinal == 0 {
2104                return Ok(());
2105            }
2106            depth.increment()?;
2107            let envelope_size = 8;
2108            let bytes_len = max_ordinal as usize * envelope_size;
2109            #[allow(unused_variables)]
2110            let offset = encoder.out_of_line_offset(bytes_len);
2111            let mut _prev_end_offset: usize = 0;
2112            if 1 > max_ordinal {
2113                return Ok(());
2114            }
2115
2116            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2117            // are envelope_size bytes.
2118            let cur_offset: usize = (1 - 1) * envelope_size;
2119
2120            // Zero reserved fields.
2121            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2122
2123            // Safety:
2124            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2125            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2126            //   envelope_size bytes, there is always sufficient room.
2127            fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
2128                self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
2129                encoder,
2130                offset + cur_offset,
2131                depth,
2132            )?;
2133
2134            _prev_end_offset = cur_offset + envelope_size;
2135            if 2 > max_ordinal {
2136                return Ok(());
2137            }
2138
2139            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2140            // are envelope_size bytes.
2141            let cur_offset: usize = (2 - 1) * envelope_size;
2142
2143            // Zero reserved fields.
2144            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2145
2146            // Safety:
2147            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2148            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2149            //   envelope_size bytes, there is always sufficient room.
2150            fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
2151                self.progress
2152                    .as_ref()
2153                    .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
2154                encoder,
2155                offset + cur_offset,
2156                depth,
2157            )?;
2158
2159            _prev_end_offset = cur_offset + envelope_size;
2160
2161            Ok(())
2162        }
2163    }
2164
2165    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompleteData {
2166        #[inline(always)]
2167        fn new_empty() -> Self {
2168            Self::default()
2169        }
2170
2171        unsafe fn decode(
2172            &mut self,
2173            decoder: &mut fidl::encoding::Decoder<'_, D>,
2174            offset: usize,
2175            mut depth: fidl::encoding::Depth,
2176        ) -> fidl::Result<()> {
2177            decoder.debug_check_bounds::<Self>(offset);
2178            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2179                None => return Err(fidl::Error::NotNullable),
2180                Some(len) => len,
2181            };
2182            // Calling decoder.out_of_line_offset(0) is not allowed.
2183            if len == 0 {
2184                return Ok(());
2185            };
2186            depth.increment()?;
2187            let envelope_size = 8;
2188            let bytes_len = len * envelope_size;
2189            let offset = decoder.out_of_line_offset(bytes_len)?;
2190            // Decode the envelope for each type.
2191            let mut _next_ordinal_to_read = 0;
2192            let mut next_offset = offset;
2193            let end_offset = offset + bytes_len;
2194            _next_ordinal_to_read += 1;
2195            if next_offset >= end_offset {
2196                return Ok(());
2197            }
2198
2199            // Decode unknown envelopes for gaps in ordinals.
2200            while _next_ordinal_to_read < 1 {
2201                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2202                _next_ordinal_to_read += 1;
2203                next_offset += envelope_size;
2204            }
2205
2206            let next_out_of_line = decoder.next_out_of_line();
2207            let handles_before = decoder.remaining_handles();
2208            if let Some((inlined, num_bytes, num_handles)) =
2209                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2210            {
2211                let member_inline_size =
2212                    <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2213                if inlined != (member_inline_size <= 4) {
2214                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2215                }
2216                let inner_offset;
2217                let mut inner_depth = depth.clone();
2218                if inlined {
2219                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2220                    inner_offset = next_offset;
2221                } else {
2222                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2223                    inner_depth.increment()?;
2224                }
2225                let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
2226                fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2227                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2228                {
2229                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2230                }
2231                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2232                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2233                }
2234            }
2235
2236            next_offset += envelope_size;
2237            _next_ordinal_to_read += 1;
2238            if next_offset >= end_offset {
2239                return Ok(());
2240            }
2241
2242            // Decode unknown envelopes for gaps in ordinals.
2243            while _next_ordinal_to_read < 2 {
2244                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2245                _next_ordinal_to_read += 1;
2246                next_offset += envelope_size;
2247            }
2248
2249            let next_out_of_line = decoder.next_out_of_line();
2250            let handles_before = decoder.remaining_handles();
2251            if let Some((inlined, num_bytes, num_handles)) =
2252                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2253            {
2254                let member_inline_size =
2255                    <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
2256                        decoder.context,
2257                    );
2258                if inlined != (member_inline_size <= 4) {
2259                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2260                }
2261                let inner_offset;
2262                let mut inner_depth = depth.clone();
2263                if inlined {
2264                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2265                    inner_offset = next_offset;
2266                } else {
2267                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2268                    inner_depth.increment()?;
2269                }
2270                let val_ref =
2271                    self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
2272                fidl::decode!(
2273                    InstallationProgress,
2274                    D,
2275                    val_ref,
2276                    decoder,
2277                    inner_offset,
2278                    inner_depth
2279                )?;
2280                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2281                {
2282                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2283                }
2284                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2285                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2286                }
2287            }
2288
2289            next_offset += envelope_size;
2290
2291            // Decode the remaining unknown envelopes.
2292            while next_offset < end_offset {
2293                _next_ordinal_to_read += 1;
2294                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2295                next_offset += envelope_size;
2296            }
2297
2298            Ok(())
2299        }
2300    }
2301
2302    impl DeferRebootData {
2303        #[inline(always)]
2304        fn max_ordinal_present(&self) -> u64 {
2305            if let Some(_) = self.progress {
2306                return 2;
2307            }
2308            if let Some(_) = self.info {
2309                return 1;
2310            }
2311            0
2312        }
2313    }
2314
2315    impl fidl::encoding::ValueTypeMarker for DeferRebootData {
2316        type Borrowed<'a> = &'a Self;
2317        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2318            value
2319        }
2320    }
2321
2322    unsafe impl fidl::encoding::TypeMarker for DeferRebootData {
2323        type Owned = Self;
2324
2325        #[inline(always)]
2326        fn inline_align(_context: fidl::encoding::Context) -> usize {
2327            8
2328        }
2329
2330        #[inline(always)]
2331        fn inline_size(_context: fidl::encoding::Context) -> usize {
2332            16
2333        }
2334    }
2335
2336    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeferRebootData, D>
2337        for &DeferRebootData
2338    {
2339        unsafe fn encode(
2340            self,
2341            encoder: &mut fidl::encoding::Encoder<'_, D>,
2342            offset: usize,
2343            mut depth: fidl::encoding::Depth,
2344        ) -> fidl::Result<()> {
2345            encoder.debug_check_bounds::<DeferRebootData>(offset);
2346            // Vector header
2347            let max_ordinal: u64 = self.max_ordinal_present();
2348            encoder.write_num(max_ordinal, offset);
2349            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2350            // Calling encoder.out_of_line_offset(0) is not allowed.
2351            if max_ordinal == 0 {
2352                return Ok(());
2353            }
2354            depth.increment()?;
2355            let envelope_size = 8;
2356            let bytes_len = max_ordinal as usize * envelope_size;
2357            #[allow(unused_variables)]
2358            let offset = encoder.out_of_line_offset(bytes_len);
2359            let mut _prev_end_offset: usize = 0;
2360            if 1 > max_ordinal {
2361                return Ok(());
2362            }
2363
2364            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2365            // are envelope_size bytes.
2366            let cur_offset: usize = (1 - 1) * envelope_size;
2367
2368            // Zero reserved fields.
2369            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2370
2371            // Safety:
2372            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2373            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2374            //   envelope_size bytes, there is always sufficient room.
2375            fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
2376                self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
2377                encoder,
2378                offset + cur_offset,
2379                depth,
2380            )?;
2381
2382            _prev_end_offset = cur_offset + envelope_size;
2383            if 2 > max_ordinal {
2384                return Ok(());
2385            }
2386
2387            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2388            // are envelope_size bytes.
2389            let cur_offset: usize = (2 - 1) * envelope_size;
2390
2391            // Zero reserved fields.
2392            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2393
2394            // Safety:
2395            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2396            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2397            //   envelope_size bytes, there is always sufficient room.
2398            fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
2399                self.progress
2400                    .as_ref()
2401                    .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
2402                encoder,
2403                offset + cur_offset,
2404                depth,
2405            )?;
2406
2407            _prev_end_offset = cur_offset + envelope_size;
2408
2409            Ok(())
2410        }
2411    }
2412
2413    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeferRebootData {
2414        #[inline(always)]
2415        fn new_empty() -> Self {
2416            Self::default()
2417        }
2418
2419        unsafe fn decode(
2420            &mut self,
2421            decoder: &mut fidl::encoding::Decoder<'_, D>,
2422            offset: usize,
2423            mut depth: fidl::encoding::Depth,
2424        ) -> fidl::Result<()> {
2425            decoder.debug_check_bounds::<Self>(offset);
2426            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2427                None => return Err(fidl::Error::NotNullable),
2428                Some(len) => len,
2429            };
2430            // Calling decoder.out_of_line_offset(0) is not allowed.
2431            if len == 0 {
2432                return Ok(());
2433            };
2434            depth.increment()?;
2435            let envelope_size = 8;
2436            let bytes_len = len * envelope_size;
2437            let offset = decoder.out_of_line_offset(bytes_len)?;
2438            // Decode the envelope for each type.
2439            let mut _next_ordinal_to_read = 0;
2440            let mut next_offset = offset;
2441            let end_offset = offset + bytes_len;
2442            _next_ordinal_to_read += 1;
2443            if next_offset >= end_offset {
2444                return Ok(());
2445            }
2446
2447            // Decode unknown envelopes for gaps in ordinals.
2448            while _next_ordinal_to_read < 1 {
2449                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2450                _next_ordinal_to_read += 1;
2451                next_offset += envelope_size;
2452            }
2453
2454            let next_out_of_line = decoder.next_out_of_line();
2455            let handles_before = decoder.remaining_handles();
2456            if let Some((inlined, num_bytes, num_handles)) =
2457                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2458            {
2459                let member_inline_size =
2460                    <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2461                if inlined != (member_inline_size <= 4) {
2462                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2463                }
2464                let inner_offset;
2465                let mut inner_depth = depth.clone();
2466                if inlined {
2467                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2468                    inner_offset = next_offset;
2469                } else {
2470                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2471                    inner_depth.increment()?;
2472                }
2473                let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
2474                fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2475                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2476                {
2477                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2478                }
2479                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2480                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2481                }
2482            }
2483
2484            next_offset += envelope_size;
2485            _next_ordinal_to_read += 1;
2486            if next_offset >= end_offset {
2487                return Ok(());
2488            }
2489
2490            // Decode unknown envelopes for gaps in ordinals.
2491            while _next_ordinal_to_read < 2 {
2492                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2493                _next_ordinal_to_read += 1;
2494                next_offset += envelope_size;
2495            }
2496
2497            let next_out_of_line = decoder.next_out_of_line();
2498            let handles_before = decoder.remaining_handles();
2499            if let Some((inlined, num_bytes, num_handles)) =
2500                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2501            {
2502                let member_inline_size =
2503                    <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
2504                        decoder.context,
2505                    );
2506                if inlined != (member_inline_size <= 4) {
2507                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2508                }
2509                let inner_offset;
2510                let mut inner_depth = depth.clone();
2511                if inlined {
2512                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2513                    inner_offset = next_offset;
2514                } else {
2515                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2516                    inner_depth.increment()?;
2517                }
2518                let val_ref =
2519                    self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
2520                fidl::decode!(
2521                    InstallationProgress,
2522                    D,
2523                    val_ref,
2524                    decoder,
2525                    inner_offset,
2526                    inner_depth
2527                )?;
2528                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2529                {
2530                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2531                }
2532                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2533                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2534                }
2535            }
2536
2537            next_offset += envelope_size;
2538
2539            // Decode the remaining unknown envelopes.
2540            while next_offset < end_offset {
2541                _next_ordinal_to_read += 1;
2542                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2543                next_offset += envelope_size;
2544            }
2545
2546            Ok(())
2547        }
2548    }
2549
2550    impl FailCommitData {
2551        #[inline(always)]
2552        fn max_ordinal_present(&self) -> u64 {
2553            if let Some(_) = self.progress {
2554                return 2;
2555            }
2556            if let Some(_) = self.info {
2557                return 1;
2558            }
2559            0
2560        }
2561    }
2562
2563    impl fidl::encoding::ValueTypeMarker for FailCommitData {
2564        type Borrowed<'a> = &'a Self;
2565        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2566            value
2567        }
2568    }
2569
2570    unsafe impl fidl::encoding::TypeMarker for FailCommitData {
2571        type Owned = Self;
2572
2573        #[inline(always)]
2574        fn inline_align(_context: fidl::encoding::Context) -> usize {
2575            8
2576        }
2577
2578        #[inline(always)]
2579        fn inline_size(_context: fidl::encoding::Context) -> usize {
2580            16
2581        }
2582    }
2583
2584    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FailCommitData, D>
2585        for &FailCommitData
2586    {
2587        unsafe fn encode(
2588            self,
2589            encoder: &mut fidl::encoding::Encoder<'_, D>,
2590            offset: usize,
2591            mut depth: fidl::encoding::Depth,
2592        ) -> fidl::Result<()> {
2593            encoder.debug_check_bounds::<FailCommitData>(offset);
2594            // Vector header
2595            let max_ordinal: u64 = self.max_ordinal_present();
2596            encoder.write_num(max_ordinal, offset);
2597            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2598            // Calling encoder.out_of_line_offset(0) is not allowed.
2599            if max_ordinal == 0 {
2600                return Ok(());
2601            }
2602            depth.increment()?;
2603            let envelope_size = 8;
2604            let bytes_len = max_ordinal as usize * envelope_size;
2605            #[allow(unused_variables)]
2606            let offset = encoder.out_of_line_offset(bytes_len);
2607            let mut _prev_end_offset: usize = 0;
2608            if 1 > max_ordinal {
2609                return Ok(());
2610            }
2611
2612            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2613            // are envelope_size bytes.
2614            let cur_offset: usize = (1 - 1) * envelope_size;
2615
2616            // Zero reserved fields.
2617            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2618
2619            // Safety:
2620            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2621            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2622            //   envelope_size bytes, there is always sufficient room.
2623            fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
2624                self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
2625                encoder,
2626                offset + cur_offset,
2627                depth,
2628            )?;
2629
2630            _prev_end_offset = cur_offset + envelope_size;
2631            if 2 > max_ordinal {
2632                return Ok(());
2633            }
2634
2635            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2636            // are envelope_size bytes.
2637            let cur_offset: usize = (2 - 1) * envelope_size;
2638
2639            // Zero reserved fields.
2640            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2641
2642            // Safety:
2643            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2644            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2645            //   envelope_size bytes, there is always sufficient room.
2646            fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
2647                self.progress
2648                    .as_ref()
2649                    .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
2650                encoder,
2651                offset + cur_offset,
2652                depth,
2653            )?;
2654
2655            _prev_end_offset = cur_offset + envelope_size;
2656
2657            Ok(())
2658        }
2659    }
2660
2661    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FailCommitData {
2662        #[inline(always)]
2663        fn new_empty() -> Self {
2664            Self::default()
2665        }
2666
2667        unsafe fn decode(
2668            &mut self,
2669            decoder: &mut fidl::encoding::Decoder<'_, D>,
2670            offset: usize,
2671            mut depth: fidl::encoding::Depth,
2672        ) -> fidl::Result<()> {
2673            decoder.debug_check_bounds::<Self>(offset);
2674            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2675                None => return Err(fidl::Error::NotNullable),
2676                Some(len) => len,
2677            };
2678            // Calling decoder.out_of_line_offset(0) is not allowed.
2679            if len == 0 {
2680                return Ok(());
2681            };
2682            depth.increment()?;
2683            let envelope_size = 8;
2684            let bytes_len = len * envelope_size;
2685            let offset = decoder.out_of_line_offset(bytes_len)?;
2686            // Decode the envelope for each type.
2687            let mut _next_ordinal_to_read = 0;
2688            let mut next_offset = offset;
2689            let end_offset = offset + bytes_len;
2690            _next_ordinal_to_read += 1;
2691            if next_offset >= end_offset {
2692                return Ok(());
2693            }
2694
2695            // Decode unknown envelopes for gaps in ordinals.
2696            while _next_ordinal_to_read < 1 {
2697                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2698                _next_ordinal_to_read += 1;
2699                next_offset += envelope_size;
2700            }
2701
2702            let next_out_of_line = decoder.next_out_of_line();
2703            let handles_before = decoder.remaining_handles();
2704            if let Some((inlined, num_bytes, num_handles)) =
2705                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2706            {
2707                let member_inline_size =
2708                    <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2709                if inlined != (member_inline_size <= 4) {
2710                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2711                }
2712                let inner_offset;
2713                let mut inner_depth = depth.clone();
2714                if inlined {
2715                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2716                    inner_offset = next_offset;
2717                } else {
2718                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2719                    inner_depth.increment()?;
2720                }
2721                let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
2722                fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2723                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2724                {
2725                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2726                }
2727                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2728                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2729                }
2730            }
2731
2732            next_offset += envelope_size;
2733            _next_ordinal_to_read += 1;
2734            if next_offset >= end_offset {
2735                return Ok(());
2736            }
2737
2738            // Decode unknown envelopes for gaps in ordinals.
2739            while _next_ordinal_to_read < 2 {
2740                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2741                _next_ordinal_to_read += 1;
2742                next_offset += envelope_size;
2743            }
2744
2745            let next_out_of_line = decoder.next_out_of_line();
2746            let handles_before = decoder.remaining_handles();
2747            if let Some((inlined, num_bytes, num_handles)) =
2748                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2749            {
2750                let member_inline_size =
2751                    <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
2752                        decoder.context,
2753                    );
2754                if inlined != (member_inline_size <= 4) {
2755                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2756                }
2757                let inner_offset;
2758                let mut inner_depth = depth.clone();
2759                if inlined {
2760                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2761                    inner_offset = next_offset;
2762                } else {
2763                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2764                    inner_depth.increment()?;
2765                }
2766                let val_ref =
2767                    self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
2768                fidl::decode!(
2769                    InstallationProgress,
2770                    D,
2771                    val_ref,
2772                    decoder,
2773                    inner_offset,
2774                    inner_depth
2775                )?;
2776                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2777                {
2778                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2779                }
2780                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2781                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2782                }
2783            }
2784
2785            next_offset += envelope_size;
2786
2787            // Decode the remaining unknown envelopes.
2788            while next_offset < end_offset {
2789                _next_ordinal_to_read += 1;
2790                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2791                next_offset += envelope_size;
2792            }
2793
2794            Ok(())
2795        }
2796    }
2797
2798    impl FailFetchData {
2799        #[inline(always)]
2800        fn max_ordinal_present(&self) -> u64 {
2801            if let Some(_) = self.reason {
2802                return 3;
2803            }
2804            if let Some(_) = self.progress {
2805                return 2;
2806            }
2807            if let Some(_) = self.info {
2808                return 1;
2809            }
2810            0
2811        }
2812    }
2813
2814    impl fidl::encoding::ValueTypeMarker for FailFetchData {
2815        type Borrowed<'a> = &'a Self;
2816        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2817            value
2818        }
2819    }
2820
2821    unsafe impl fidl::encoding::TypeMarker for FailFetchData {
2822        type Owned = Self;
2823
2824        #[inline(always)]
2825        fn inline_align(_context: fidl::encoding::Context) -> usize {
2826            8
2827        }
2828
2829        #[inline(always)]
2830        fn inline_size(_context: fidl::encoding::Context) -> usize {
2831            16
2832        }
2833    }
2834
2835    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FailFetchData, D>
2836        for &FailFetchData
2837    {
2838        unsafe fn encode(
2839            self,
2840            encoder: &mut fidl::encoding::Encoder<'_, D>,
2841            offset: usize,
2842            mut depth: fidl::encoding::Depth,
2843        ) -> fidl::Result<()> {
2844            encoder.debug_check_bounds::<FailFetchData>(offset);
2845            // Vector header
2846            let max_ordinal: u64 = self.max_ordinal_present();
2847            encoder.write_num(max_ordinal, offset);
2848            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2849            // Calling encoder.out_of_line_offset(0) is not allowed.
2850            if max_ordinal == 0 {
2851                return Ok(());
2852            }
2853            depth.increment()?;
2854            let envelope_size = 8;
2855            let bytes_len = max_ordinal as usize * envelope_size;
2856            #[allow(unused_variables)]
2857            let offset = encoder.out_of_line_offset(bytes_len);
2858            let mut _prev_end_offset: usize = 0;
2859            if 1 > max_ordinal {
2860                return Ok(());
2861            }
2862
2863            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2864            // are envelope_size bytes.
2865            let cur_offset: usize = (1 - 1) * envelope_size;
2866
2867            // Zero reserved fields.
2868            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2869
2870            // Safety:
2871            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2872            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2873            //   envelope_size bytes, there is always sufficient room.
2874            fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
2875                self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
2876                encoder,
2877                offset + cur_offset,
2878                depth,
2879            )?;
2880
2881            _prev_end_offset = cur_offset + envelope_size;
2882            if 2 > max_ordinal {
2883                return Ok(());
2884            }
2885
2886            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2887            // are envelope_size bytes.
2888            let cur_offset: usize = (2 - 1) * envelope_size;
2889
2890            // Zero reserved fields.
2891            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2892
2893            // Safety:
2894            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2895            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2896            //   envelope_size bytes, there is always sufficient room.
2897            fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
2898                self.progress
2899                    .as_ref()
2900                    .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
2901                encoder,
2902                offset + cur_offset,
2903                depth,
2904            )?;
2905
2906            _prev_end_offset = cur_offset + envelope_size;
2907            if 3 > max_ordinal {
2908                return Ok(());
2909            }
2910
2911            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2912            // are envelope_size bytes.
2913            let cur_offset: usize = (3 - 1) * envelope_size;
2914
2915            // Zero reserved fields.
2916            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2917
2918            // Safety:
2919            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2920            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2921            //   envelope_size bytes, there is always sufficient room.
2922            fidl::encoding::encode_in_envelope_optional::<FetchFailureReason, D>(
2923                self.reason
2924                    .as_ref()
2925                    .map(<FetchFailureReason as fidl::encoding::ValueTypeMarker>::borrow),
2926                encoder,
2927                offset + cur_offset,
2928                depth,
2929            )?;
2930
2931            _prev_end_offset = cur_offset + envelope_size;
2932
2933            Ok(())
2934        }
2935    }
2936
2937    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FailFetchData {
2938        #[inline(always)]
2939        fn new_empty() -> Self {
2940            Self::default()
2941        }
2942
2943        unsafe fn decode(
2944            &mut self,
2945            decoder: &mut fidl::encoding::Decoder<'_, D>,
2946            offset: usize,
2947            mut depth: fidl::encoding::Depth,
2948        ) -> fidl::Result<()> {
2949            decoder.debug_check_bounds::<Self>(offset);
2950            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2951                None => return Err(fidl::Error::NotNullable),
2952                Some(len) => len,
2953            };
2954            // Calling decoder.out_of_line_offset(0) is not allowed.
2955            if len == 0 {
2956                return Ok(());
2957            };
2958            depth.increment()?;
2959            let envelope_size = 8;
2960            let bytes_len = len * envelope_size;
2961            let offset = decoder.out_of_line_offset(bytes_len)?;
2962            // Decode the envelope for each type.
2963            let mut _next_ordinal_to_read = 0;
2964            let mut next_offset = offset;
2965            let end_offset = offset + bytes_len;
2966            _next_ordinal_to_read += 1;
2967            if next_offset >= end_offset {
2968                return Ok(());
2969            }
2970
2971            // Decode unknown envelopes for gaps in ordinals.
2972            while _next_ordinal_to_read < 1 {
2973                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2974                _next_ordinal_to_read += 1;
2975                next_offset += envelope_size;
2976            }
2977
2978            let next_out_of_line = decoder.next_out_of_line();
2979            let handles_before = decoder.remaining_handles();
2980            if let Some((inlined, num_bytes, num_handles)) =
2981                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2982            {
2983                let member_inline_size =
2984                    <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2985                if inlined != (member_inline_size <= 4) {
2986                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2987                }
2988                let inner_offset;
2989                let mut inner_depth = depth.clone();
2990                if inlined {
2991                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2992                    inner_offset = next_offset;
2993                } else {
2994                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2995                    inner_depth.increment()?;
2996                }
2997                let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
2998                fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2999                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3000                {
3001                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3002                }
3003                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3004                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3005                }
3006            }
3007
3008            next_offset += envelope_size;
3009            _next_ordinal_to_read += 1;
3010            if next_offset >= end_offset {
3011                return Ok(());
3012            }
3013
3014            // Decode unknown envelopes for gaps in ordinals.
3015            while _next_ordinal_to_read < 2 {
3016                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3017                _next_ordinal_to_read += 1;
3018                next_offset += envelope_size;
3019            }
3020
3021            let next_out_of_line = decoder.next_out_of_line();
3022            let handles_before = decoder.remaining_handles();
3023            if let Some((inlined, num_bytes, num_handles)) =
3024                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3025            {
3026                let member_inline_size =
3027                    <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
3028                        decoder.context,
3029                    );
3030                if inlined != (member_inline_size <= 4) {
3031                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3032                }
3033                let inner_offset;
3034                let mut inner_depth = depth.clone();
3035                if inlined {
3036                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3037                    inner_offset = next_offset;
3038                } else {
3039                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3040                    inner_depth.increment()?;
3041                }
3042                let val_ref =
3043                    self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
3044                fidl::decode!(
3045                    InstallationProgress,
3046                    D,
3047                    val_ref,
3048                    decoder,
3049                    inner_offset,
3050                    inner_depth
3051                )?;
3052                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3053                {
3054                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3055                }
3056                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3057                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3058                }
3059            }
3060
3061            next_offset += envelope_size;
3062            _next_ordinal_to_read += 1;
3063            if next_offset >= end_offset {
3064                return Ok(());
3065            }
3066
3067            // Decode unknown envelopes for gaps in ordinals.
3068            while _next_ordinal_to_read < 3 {
3069                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3070                _next_ordinal_to_read += 1;
3071                next_offset += envelope_size;
3072            }
3073
3074            let next_out_of_line = decoder.next_out_of_line();
3075            let handles_before = decoder.remaining_handles();
3076            if let Some((inlined, num_bytes, num_handles)) =
3077                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3078            {
3079                let member_inline_size =
3080                    <FetchFailureReason as fidl::encoding::TypeMarker>::inline_size(
3081                        decoder.context,
3082                    );
3083                if inlined != (member_inline_size <= 4) {
3084                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3085                }
3086                let inner_offset;
3087                let mut inner_depth = depth.clone();
3088                if inlined {
3089                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3090                    inner_offset = next_offset;
3091                } else {
3092                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3093                    inner_depth.increment()?;
3094                }
3095                let val_ref =
3096                    self.reason.get_or_insert_with(|| fidl::new_empty!(FetchFailureReason, D));
3097                fidl::decode!(FetchFailureReason, D, val_ref, decoder, inner_offset, inner_depth)?;
3098                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3099                {
3100                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3101                }
3102                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3103                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3104                }
3105            }
3106
3107            next_offset += envelope_size;
3108
3109            // Decode the remaining unknown envelopes.
3110            while next_offset < end_offset {
3111                _next_ordinal_to_read += 1;
3112                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3113                next_offset += envelope_size;
3114            }
3115
3116            Ok(())
3117        }
3118    }
3119
3120    impl FailPrepareData {
3121        #[inline(always)]
3122        fn max_ordinal_present(&self) -> u64 {
3123            if let Some(_) = self.reason {
3124                return 1;
3125            }
3126            0
3127        }
3128    }
3129
3130    impl fidl::encoding::ValueTypeMarker for FailPrepareData {
3131        type Borrowed<'a> = &'a Self;
3132        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3133            value
3134        }
3135    }
3136
3137    unsafe impl fidl::encoding::TypeMarker for FailPrepareData {
3138        type Owned = Self;
3139
3140        #[inline(always)]
3141        fn inline_align(_context: fidl::encoding::Context) -> usize {
3142            8
3143        }
3144
3145        #[inline(always)]
3146        fn inline_size(_context: fidl::encoding::Context) -> usize {
3147            16
3148        }
3149    }
3150
3151    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FailPrepareData, D>
3152        for &FailPrepareData
3153    {
3154        unsafe fn encode(
3155            self,
3156            encoder: &mut fidl::encoding::Encoder<'_, D>,
3157            offset: usize,
3158            mut depth: fidl::encoding::Depth,
3159        ) -> fidl::Result<()> {
3160            encoder.debug_check_bounds::<FailPrepareData>(offset);
3161            // Vector header
3162            let max_ordinal: u64 = self.max_ordinal_present();
3163            encoder.write_num(max_ordinal, offset);
3164            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3165            // Calling encoder.out_of_line_offset(0) is not allowed.
3166            if max_ordinal == 0 {
3167                return Ok(());
3168            }
3169            depth.increment()?;
3170            let envelope_size = 8;
3171            let bytes_len = max_ordinal as usize * envelope_size;
3172            #[allow(unused_variables)]
3173            let offset = encoder.out_of_line_offset(bytes_len);
3174            let mut _prev_end_offset: usize = 0;
3175            if 1 > max_ordinal {
3176                return Ok(());
3177            }
3178
3179            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3180            // are envelope_size bytes.
3181            let cur_offset: usize = (1 - 1) * envelope_size;
3182
3183            // Zero reserved fields.
3184            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3185
3186            // Safety:
3187            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3188            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3189            //   envelope_size bytes, there is always sufficient room.
3190            fidl::encoding::encode_in_envelope_optional::<PrepareFailureReason, D>(
3191                self.reason
3192                    .as_ref()
3193                    .map(<PrepareFailureReason as fidl::encoding::ValueTypeMarker>::borrow),
3194                encoder,
3195                offset + cur_offset,
3196                depth,
3197            )?;
3198
3199            _prev_end_offset = cur_offset + envelope_size;
3200
3201            Ok(())
3202        }
3203    }
3204
3205    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FailPrepareData {
3206        #[inline(always)]
3207        fn new_empty() -> Self {
3208            Self::default()
3209        }
3210
3211        unsafe fn decode(
3212            &mut self,
3213            decoder: &mut fidl::encoding::Decoder<'_, D>,
3214            offset: usize,
3215            mut depth: fidl::encoding::Depth,
3216        ) -> fidl::Result<()> {
3217            decoder.debug_check_bounds::<Self>(offset);
3218            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3219                None => return Err(fidl::Error::NotNullable),
3220                Some(len) => len,
3221            };
3222            // Calling decoder.out_of_line_offset(0) is not allowed.
3223            if len == 0 {
3224                return Ok(());
3225            };
3226            depth.increment()?;
3227            let envelope_size = 8;
3228            let bytes_len = len * envelope_size;
3229            let offset = decoder.out_of_line_offset(bytes_len)?;
3230            // Decode the envelope for each type.
3231            let mut _next_ordinal_to_read = 0;
3232            let mut next_offset = offset;
3233            let end_offset = offset + bytes_len;
3234            _next_ordinal_to_read += 1;
3235            if next_offset >= end_offset {
3236                return Ok(());
3237            }
3238
3239            // Decode unknown envelopes for gaps in ordinals.
3240            while _next_ordinal_to_read < 1 {
3241                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3242                _next_ordinal_to_read += 1;
3243                next_offset += envelope_size;
3244            }
3245
3246            let next_out_of_line = decoder.next_out_of_line();
3247            let handles_before = decoder.remaining_handles();
3248            if let Some((inlined, num_bytes, num_handles)) =
3249                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3250            {
3251                let member_inline_size =
3252                    <PrepareFailureReason as fidl::encoding::TypeMarker>::inline_size(
3253                        decoder.context,
3254                    );
3255                if inlined != (member_inline_size <= 4) {
3256                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3257                }
3258                let inner_offset;
3259                let mut inner_depth = depth.clone();
3260                if inlined {
3261                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3262                    inner_offset = next_offset;
3263                } else {
3264                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3265                    inner_depth.increment()?;
3266                }
3267                let val_ref =
3268                    self.reason.get_or_insert_with(|| fidl::new_empty!(PrepareFailureReason, D));
3269                fidl::decode!(
3270                    PrepareFailureReason,
3271                    D,
3272                    val_ref,
3273                    decoder,
3274                    inner_offset,
3275                    inner_depth
3276                )?;
3277                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3278                {
3279                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3280                }
3281                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3282                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3283                }
3284            }
3285
3286            next_offset += envelope_size;
3287
3288            // Decode the remaining unknown envelopes.
3289            while next_offset < end_offset {
3290                _next_ordinal_to_read += 1;
3291                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3292                next_offset += envelope_size;
3293            }
3294
3295            Ok(())
3296        }
3297    }
3298
3299    impl FailStageData {
3300        #[inline(always)]
3301        fn max_ordinal_present(&self) -> u64 {
3302            if let Some(_) = self.reason {
3303                return 3;
3304            }
3305            if let Some(_) = self.progress {
3306                return 2;
3307            }
3308            if let Some(_) = self.info {
3309                return 1;
3310            }
3311            0
3312        }
3313    }
3314
3315    impl fidl::encoding::ValueTypeMarker for FailStageData {
3316        type Borrowed<'a> = &'a Self;
3317        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3318            value
3319        }
3320    }
3321
3322    unsafe impl fidl::encoding::TypeMarker for FailStageData {
3323        type Owned = Self;
3324
3325        #[inline(always)]
3326        fn inline_align(_context: fidl::encoding::Context) -> usize {
3327            8
3328        }
3329
3330        #[inline(always)]
3331        fn inline_size(_context: fidl::encoding::Context) -> usize {
3332            16
3333        }
3334    }
3335
3336    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FailStageData, D>
3337        for &FailStageData
3338    {
3339        unsafe fn encode(
3340            self,
3341            encoder: &mut fidl::encoding::Encoder<'_, D>,
3342            offset: usize,
3343            mut depth: fidl::encoding::Depth,
3344        ) -> fidl::Result<()> {
3345            encoder.debug_check_bounds::<FailStageData>(offset);
3346            // Vector header
3347            let max_ordinal: u64 = self.max_ordinal_present();
3348            encoder.write_num(max_ordinal, offset);
3349            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3350            // Calling encoder.out_of_line_offset(0) is not allowed.
3351            if max_ordinal == 0 {
3352                return Ok(());
3353            }
3354            depth.increment()?;
3355            let envelope_size = 8;
3356            let bytes_len = max_ordinal as usize * envelope_size;
3357            #[allow(unused_variables)]
3358            let offset = encoder.out_of_line_offset(bytes_len);
3359            let mut _prev_end_offset: usize = 0;
3360            if 1 > max_ordinal {
3361                return Ok(());
3362            }
3363
3364            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3365            // are envelope_size bytes.
3366            let cur_offset: usize = (1 - 1) * envelope_size;
3367
3368            // Zero reserved fields.
3369            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3370
3371            // Safety:
3372            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3373            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3374            //   envelope_size bytes, there is always sufficient room.
3375            fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
3376                self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
3377                encoder,
3378                offset + cur_offset,
3379                depth,
3380            )?;
3381
3382            _prev_end_offset = cur_offset + envelope_size;
3383            if 2 > max_ordinal {
3384                return Ok(());
3385            }
3386
3387            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3388            // are envelope_size bytes.
3389            let cur_offset: usize = (2 - 1) * envelope_size;
3390
3391            // Zero reserved fields.
3392            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3393
3394            // Safety:
3395            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3396            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3397            //   envelope_size bytes, there is always sufficient room.
3398            fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
3399                self.progress
3400                    .as_ref()
3401                    .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
3402                encoder,
3403                offset + cur_offset,
3404                depth,
3405            )?;
3406
3407            _prev_end_offset = cur_offset + envelope_size;
3408            if 3 > max_ordinal {
3409                return Ok(());
3410            }
3411
3412            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3413            // are envelope_size bytes.
3414            let cur_offset: usize = (3 - 1) * envelope_size;
3415
3416            // Zero reserved fields.
3417            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3418
3419            // Safety:
3420            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3421            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3422            //   envelope_size bytes, there is always sufficient room.
3423            fidl::encoding::encode_in_envelope_optional::<StageFailureReason, D>(
3424                self.reason
3425                    .as_ref()
3426                    .map(<StageFailureReason as fidl::encoding::ValueTypeMarker>::borrow),
3427                encoder,
3428                offset + cur_offset,
3429                depth,
3430            )?;
3431
3432            _prev_end_offset = cur_offset + envelope_size;
3433
3434            Ok(())
3435        }
3436    }
3437
3438    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FailStageData {
3439        #[inline(always)]
3440        fn new_empty() -> Self {
3441            Self::default()
3442        }
3443
3444        unsafe fn decode(
3445            &mut self,
3446            decoder: &mut fidl::encoding::Decoder<'_, D>,
3447            offset: usize,
3448            mut depth: fidl::encoding::Depth,
3449        ) -> fidl::Result<()> {
3450            decoder.debug_check_bounds::<Self>(offset);
3451            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3452                None => return Err(fidl::Error::NotNullable),
3453                Some(len) => len,
3454            };
3455            // Calling decoder.out_of_line_offset(0) is not allowed.
3456            if len == 0 {
3457                return Ok(());
3458            };
3459            depth.increment()?;
3460            let envelope_size = 8;
3461            let bytes_len = len * envelope_size;
3462            let offset = decoder.out_of_line_offset(bytes_len)?;
3463            // Decode the envelope for each type.
3464            let mut _next_ordinal_to_read = 0;
3465            let mut next_offset = offset;
3466            let end_offset = offset + bytes_len;
3467            _next_ordinal_to_read += 1;
3468            if next_offset >= end_offset {
3469                return Ok(());
3470            }
3471
3472            // Decode unknown envelopes for gaps in ordinals.
3473            while _next_ordinal_to_read < 1 {
3474                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3475                _next_ordinal_to_read += 1;
3476                next_offset += envelope_size;
3477            }
3478
3479            let next_out_of_line = decoder.next_out_of_line();
3480            let handles_before = decoder.remaining_handles();
3481            if let Some((inlined, num_bytes, num_handles)) =
3482                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3483            {
3484                let member_inline_size =
3485                    <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3486                if inlined != (member_inline_size <= 4) {
3487                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3488                }
3489                let inner_offset;
3490                let mut inner_depth = depth.clone();
3491                if inlined {
3492                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3493                    inner_offset = next_offset;
3494                } else {
3495                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3496                    inner_depth.increment()?;
3497                }
3498                let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
3499                fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
3500                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3501                {
3502                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3503                }
3504                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3505                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3506                }
3507            }
3508
3509            next_offset += envelope_size;
3510            _next_ordinal_to_read += 1;
3511            if next_offset >= end_offset {
3512                return Ok(());
3513            }
3514
3515            // Decode unknown envelopes for gaps in ordinals.
3516            while _next_ordinal_to_read < 2 {
3517                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3518                _next_ordinal_to_read += 1;
3519                next_offset += envelope_size;
3520            }
3521
3522            let next_out_of_line = decoder.next_out_of_line();
3523            let handles_before = decoder.remaining_handles();
3524            if let Some((inlined, num_bytes, num_handles)) =
3525                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3526            {
3527                let member_inline_size =
3528                    <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
3529                        decoder.context,
3530                    );
3531                if inlined != (member_inline_size <= 4) {
3532                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3533                }
3534                let inner_offset;
3535                let mut inner_depth = depth.clone();
3536                if inlined {
3537                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3538                    inner_offset = next_offset;
3539                } else {
3540                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3541                    inner_depth.increment()?;
3542                }
3543                let val_ref =
3544                    self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
3545                fidl::decode!(
3546                    InstallationProgress,
3547                    D,
3548                    val_ref,
3549                    decoder,
3550                    inner_offset,
3551                    inner_depth
3552                )?;
3553                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3554                {
3555                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3556                }
3557                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3558                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3559                }
3560            }
3561
3562            next_offset += envelope_size;
3563            _next_ordinal_to_read += 1;
3564            if next_offset >= end_offset {
3565                return Ok(());
3566            }
3567
3568            // Decode unknown envelopes for gaps in ordinals.
3569            while _next_ordinal_to_read < 3 {
3570                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3571                _next_ordinal_to_read += 1;
3572                next_offset += envelope_size;
3573            }
3574
3575            let next_out_of_line = decoder.next_out_of_line();
3576            let handles_before = decoder.remaining_handles();
3577            if let Some((inlined, num_bytes, num_handles)) =
3578                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3579            {
3580                let member_inline_size =
3581                    <StageFailureReason as fidl::encoding::TypeMarker>::inline_size(
3582                        decoder.context,
3583                    );
3584                if inlined != (member_inline_size <= 4) {
3585                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3586                }
3587                let inner_offset;
3588                let mut inner_depth = depth.clone();
3589                if inlined {
3590                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3591                    inner_offset = next_offset;
3592                } else {
3593                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3594                    inner_depth.increment()?;
3595                }
3596                let val_ref =
3597                    self.reason.get_or_insert_with(|| fidl::new_empty!(StageFailureReason, D));
3598                fidl::decode!(StageFailureReason, D, val_ref, decoder, inner_offset, inner_depth)?;
3599                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3600                {
3601                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3602                }
3603                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3604                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3605                }
3606            }
3607
3608            next_offset += envelope_size;
3609
3610            // Decode the remaining unknown envelopes.
3611            while next_offset < end_offset {
3612                _next_ordinal_to_read += 1;
3613                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3614                next_offset += envelope_size;
3615            }
3616
3617            Ok(())
3618        }
3619    }
3620
3621    impl FetchData {
3622        #[inline(always)]
3623        fn max_ordinal_present(&self) -> u64 {
3624            if let Some(_) = self.progress {
3625                return 2;
3626            }
3627            if let Some(_) = self.info {
3628                return 1;
3629            }
3630            0
3631        }
3632    }
3633
3634    impl fidl::encoding::ValueTypeMarker for FetchData {
3635        type Borrowed<'a> = &'a Self;
3636        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3637            value
3638        }
3639    }
3640
3641    unsafe impl fidl::encoding::TypeMarker for FetchData {
3642        type Owned = Self;
3643
3644        #[inline(always)]
3645        fn inline_align(_context: fidl::encoding::Context) -> usize {
3646            8
3647        }
3648
3649        #[inline(always)]
3650        fn inline_size(_context: fidl::encoding::Context) -> usize {
3651            16
3652        }
3653    }
3654
3655    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FetchData, D>
3656        for &FetchData
3657    {
3658        unsafe fn encode(
3659            self,
3660            encoder: &mut fidl::encoding::Encoder<'_, D>,
3661            offset: usize,
3662            mut depth: fidl::encoding::Depth,
3663        ) -> fidl::Result<()> {
3664            encoder.debug_check_bounds::<FetchData>(offset);
3665            // Vector header
3666            let max_ordinal: u64 = self.max_ordinal_present();
3667            encoder.write_num(max_ordinal, offset);
3668            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3669            // Calling encoder.out_of_line_offset(0) is not allowed.
3670            if max_ordinal == 0 {
3671                return Ok(());
3672            }
3673            depth.increment()?;
3674            let envelope_size = 8;
3675            let bytes_len = max_ordinal as usize * envelope_size;
3676            #[allow(unused_variables)]
3677            let offset = encoder.out_of_line_offset(bytes_len);
3678            let mut _prev_end_offset: usize = 0;
3679            if 1 > max_ordinal {
3680                return Ok(());
3681            }
3682
3683            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3684            // are envelope_size bytes.
3685            let cur_offset: usize = (1 - 1) * envelope_size;
3686
3687            // Zero reserved fields.
3688            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3689
3690            // Safety:
3691            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3692            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3693            //   envelope_size bytes, there is always sufficient room.
3694            fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
3695                self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
3696                encoder,
3697                offset + cur_offset,
3698                depth,
3699            )?;
3700
3701            _prev_end_offset = cur_offset + envelope_size;
3702            if 2 > max_ordinal {
3703                return Ok(());
3704            }
3705
3706            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3707            // are envelope_size bytes.
3708            let cur_offset: usize = (2 - 1) * envelope_size;
3709
3710            // Zero reserved fields.
3711            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3712
3713            // Safety:
3714            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3715            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3716            //   envelope_size bytes, there is always sufficient room.
3717            fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
3718                self.progress
3719                    .as_ref()
3720                    .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
3721                encoder,
3722                offset + cur_offset,
3723                depth,
3724            )?;
3725
3726            _prev_end_offset = cur_offset + envelope_size;
3727
3728            Ok(())
3729        }
3730    }
3731
3732    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FetchData {
3733        #[inline(always)]
3734        fn new_empty() -> Self {
3735            Self::default()
3736        }
3737
3738        unsafe fn decode(
3739            &mut self,
3740            decoder: &mut fidl::encoding::Decoder<'_, D>,
3741            offset: usize,
3742            mut depth: fidl::encoding::Depth,
3743        ) -> fidl::Result<()> {
3744            decoder.debug_check_bounds::<Self>(offset);
3745            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3746                None => return Err(fidl::Error::NotNullable),
3747                Some(len) => len,
3748            };
3749            // Calling decoder.out_of_line_offset(0) is not allowed.
3750            if len == 0 {
3751                return Ok(());
3752            };
3753            depth.increment()?;
3754            let envelope_size = 8;
3755            let bytes_len = len * envelope_size;
3756            let offset = decoder.out_of_line_offset(bytes_len)?;
3757            // Decode the envelope for each type.
3758            let mut _next_ordinal_to_read = 0;
3759            let mut next_offset = offset;
3760            let end_offset = offset + bytes_len;
3761            _next_ordinal_to_read += 1;
3762            if next_offset >= end_offset {
3763                return Ok(());
3764            }
3765
3766            // Decode unknown envelopes for gaps in ordinals.
3767            while _next_ordinal_to_read < 1 {
3768                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3769                _next_ordinal_to_read += 1;
3770                next_offset += envelope_size;
3771            }
3772
3773            let next_out_of_line = decoder.next_out_of_line();
3774            let handles_before = decoder.remaining_handles();
3775            if let Some((inlined, num_bytes, num_handles)) =
3776                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3777            {
3778                let member_inline_size =
3779                    <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3780                if inlined != (member_inline_size <= 4) {
3781                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3782                }
3783                let inner_offset;
3784                let mut inner_depth = depth.clone();
3785                if inlined {
3786                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3787                    inner_offset = next_offset;
3788                } else {
3789                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3790                    inner_depth.increment()?;
3791                }
3792                let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
3793                fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
3794                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3795                {
3796                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3797                }
3798                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3799                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3800                }
3801            }
3802
3803            next_offset += envelope_size;
3804            _next_ordinal_to_read += 1;
3805            if next_offset >= end_offset {
3806                return Ok(());
3807            }
3808
3809            // Decode unknown envelopes for gaps in ordinals.
3810            while _next_ordinal_to_read < 2 {
3811                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3812                _next_ordinal_to_read += 1;
3813                next_offset += envelope_size;
3814            }
3815
3816            let next_out_of_line = decoder.next_out_of_line();
3817            let handles_before = decoder.remaining_handles();
3818            if let Some((inlined, num_bytes, num_handles)) =
3819                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3820            {
3821                let member_inline_size =
3822                    <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
3823                        decoder.context,
3824                    );
3825                if inlined != (member_inline_size <= 4) {
3826                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3827                }
3828                let inner_offset;
3829                let mut inner_depth = depth.clone();
3830                if inlined {
3831                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3832                    inner_offset = next_offset;
3833                } else {
3834                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3835                    inner_depth.increment()?;
3836                }
3837                let val_ref =
3838                    self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
3839                fidl::decode!(
3840                    InstallationProgress,
3841                    D,
3842                    val_ref,
3843                    decoder,
3844                    inner_offset,
3845                    inner_depth
3846                )?;
3847                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3848                {
3849                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3850                }
3851                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3852                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3853                }
3854            }
3855
3856            next_offset += envelope_size;
3857
3858            // Decode the remaining unknown envelopes.
3859            while next_offset < end_offset {
3860                _next_ordinal_to_read += 1;
3861                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3862                next_offset += envelope_size;
3863            }
3864
3865            Ok(())
3866        }
3867    }
3868
3869    impl InstallationProgress {
3870        #[inline(always)]
3871        fn max_ordinal_present(&self) -> u64 {
3872            if let Some(_) = self.bytes_downloaded {
3873                return 2;
3874            }
3875            if let Some(_) = self.fraction_completed {
3876                return 1;
3877            }
3878            0
3879        }
3880    }
3881
3882    impl fidl::encoding::ValueTypeMarker for InstallationProgress {
3883        type Borrowed<'a> = &'a Self;
3884        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3885            value
3886        }
3887    }
3888
3889    unsafe impl fidl::encoding::TypeMarker for InstallationProgress {
3890        type Owned = Self;
3891
3892        #[inline(always)]
3893        fn inline_align(_context: fidl::encoding::Context) -> usize {
3894            8
3895        }
3896
3897        #[inline(always)]
3898        fn inline_size(_context: fidl::encoding::Context) -> usize {
3899            16
3900        }
3901    }
3902
3903    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InstallationProgress, D>
3904        for &InstallationProgress
3905    {
3906        unsafe fn encode(
3907            self,
3908            encoder: &mut fidl::encoding::Encoder<'_, D>,
3909            offset: usize,
3910            mut depth: fidl::encoding::Depth,
3911        ) -> fidl::Result<()> {
3912            encoder.debug_check_bounds::<InstallationProgress>(offset);
3913            // Vector header
3914            let max_ordinal: u64 = self.max_ordinal_present();
3915            encoder.write_num(max_ordinal, offset);
3916            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3917            // Calling encoder.out_of_line_offset(0) is not allowed.
3918            if max_ordinal == 0 {
3919                return Ok(());
3920            }
3921            depth.increment()?;
3922            let envelope_size = 8;
3923            let bytes_len = max_ordinal as usize * envelope_size;
3924            #[allow(unused_variables)]
3925            let offset = encoder.out_of_line_offset(bytes_len);
3926            let mut _prev_end_offset: usize = 0;
3927            if 1 > max_ordinal {
3928                return Ok(());
3929            }
3930
3931            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3932            // are envelope_size bytes.
3933            let cur_offset: usize = (1 - 1) * envelope_size;
3934
3935            // Zero reserved fields.
3936            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3937
3938            // Safety:
3939            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3940            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3941            //   envelope_size bytes, there is always sufficient room.
3942            fidl::encoding::encode_in_envelope_optional::<f32, D>(
3943                self.fraction_completed
3944                    .as_ref()
3945                    .map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
3946                encoder,
3947                offset + cur_offset,
3948                depth,
3949            )?;
3950
3951            _prev_end_offset = cur_offset + envelope_size;
3952            if 2 > max_ordinal {
3953                return Ok(());
3954            }
3955
3956            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3957            // are envelope_size bytes.
3958            let cur_offset: usize = (2 - 1) * envelope_size;
3959
3960            // Zero reserved fields.
3961            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3962
3963            // Safety:
3964            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3965            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3966            //   envelope_size bytes, there is always sufficient room.
3967            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3968                self.bytes_downloaded
3969                    .as_ref()
3970                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3971                encoder,
3972                offset + cur_offset,
3973                depth,
3974            )?;
3975
3976            _prev_end_offset = cur_offset + envelope_size;
3977
3978            Ok(())
3979        }
3980    }
3981
3982    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InstallationProgress {
3983        #[inline(always)]
3984        fn new_empty() -> Self {
3985            Self::default()
3986        }
3987
3988        unsafe fn decode(
3989            &mut self,
3990            decoder: &mut fidl::encoding::Decoder<'_, D>,
3991            offset: usize,
3992            mut depth: fidl::encoding::Depth,
3993        ) -> fidl::Result<()> {
3994            decoder.debug_check_bounds::<Self>(offset);
3995            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3996                None => return Err(fidl::Error::NotNullable),
3997                Some(len) => len,
3998            };
3999            // Calling decoder.out_of_line_offset(0) is not allowed.
4000            if len == 0 {
4001                return Ok(());
4002            };
4003            depth.increment()?;
4004            let envelope_size = 8;
4005            let bytes_len = len * envelope_size;
4006            let offset = decoder.out_of_line_offset(bytes_len)?;
4007            // Decode the envelope for each type.
4008            let mut _next_ordinal_to_read = 0;
4009            let mut next_offset = offset;
4010            let end_offset = offset + bytes_len;
4011            _next_ordinal_to_read += 1;
4012            if next_offset >= end_offset {
4013                return Ok(());
4014            }
4015
4016            // Decode unknown envelopes for gaps in ordinals.
4017            while _next_ordinal_to_read < 1 {
4018                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4019                _next_ordinal_to_read += 1;
4020                next_offset += envelope_size;
4021            }
4022
4023            let next_out_of_line = decoder.next_out_of_line();
4024            let handles_before = decoder.remaining_handles();
4025            if let Some((inlined, num_bytes, num_handles)) =
4026                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4027            {
4028                let member_inline_size =
4029                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4030                if inlined != (member_inline_size <= 4) {
4031                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4032                }
4033                let inner_offset;
4034                let mut inner_depth = depth.clone();
4035                if inlined {
4036                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4037                    inner_offset = next_offset;
4038                } else {
4039                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4040                    inner_depth.increment()?;
4041                }
4042                let val_ref =
4043                    self.fraction_completed.get_or_insert_with(|| fidl::new_empty!(f32, D));
4044                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
4045                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4046                {
4047                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4048                }
4049                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4050                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4051                }
4052            }
4053
4054            next_offset += envelope_size;
4055            _next_ordinal_to_read += 1;
4056            if next_offset >= end_offset {
4057                return Ok(());
4058            }
4059
4060            // Decode unknown envelopes for gaps in ordinals.
4061            while _next_ordinal_to_read < 2 {
4062                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4063                _next_ordinal_to_read += 1;
4064                next_offset += envelope_size;
4065            }
4066
4067            let next_out_of_line = decoder.next_out_of_line();
4068            let handles_before = decoder.remaining_handles();
4069            if let Some((inlined, num_bytes, num_handles)) =
4070                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4071            {
4072                let member_inline_size =
4073                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4074                if inlined != (member_inline_size <= 4) {
4075                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4076                }
4077                let inner_offset;
4078                let mut inner_depth = depth.clone();
4079                if inlined {
4080                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4081                    inner_offset = next_offset;
4082                } else {
4083                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4084                    inner_depth.increment()?;
4085                }
4086                let val_ref = self.bytes_downloaded.get_or_insert_with(|| fidl::new_empty!(u64, D));
4087                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4088                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4089                {
4090                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4091                }
4092                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4093                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4094                }
4095            }
4096
4097            next_offset += envelope_size;
4098
4099            // Decode the remaining unknown envelopes.
4100            while next_offset < end_offset {
4101                _next_ordinal_to_read += 1;
4102                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4103                next_offset += envelope_size;
4104            }
4105
4106            Ok(())
4107        }
4108    }
4109
4110    impl Options {
4111        #[inline(always)]
4112        fn max_ordinal_present(&self) -> u64 {
4113            if let Some(_) = self.should_write_recovery {
4114                return 3;
4115            }
4116            if let Some(_) = self.allow_attach_to_existing_attempt {
4117                return 2;
4118            }
4119            if let Some(_) = self.initiator {
4120                return 1;
4121            }
4122            0
4123        }
4124    }
4125
4126    impl fidl::encoding::ValueTypeMarker for Options {
4127        type Borrowed<'a> = &'a Self;
4128        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4129            value
4130        }
4131    }
4132
4133    unsafe impl fidl::encoding::TypeMarker for Options {
4134        type Owned = Self;
4135
4136        #[inline(always)]
4137        fn inline_align(_context: fidl::encoding::Context) -> usize {
4138            8
4139        }
4140
4141        #[inline(always)]
4142        fn inline_size(_context: fidl::encoding::Context) -> usize {
4143            16
4144        }
4145    }
4146
4147    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Options, D> for &Options {
4148        unsafe fn encode(
4149            self,
4150            encoder: &mut fidl::encoding::Encoder<'_, D>,
4151            offset: usize,
4152            mut depth: fidl::encoding::Depth,
4153        ) -> fidl::Result<()> {
4154            encoder.debug_check_bounds::<Options>(offset);
4155            // Vector header
4156            let max_ordinal: u64 = self.max_ordinal_present();
4157            encoder.write_num(max_ordinal, offset);
4158            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4159            // Calling encoder.out_of_line_offset(0) is not allowed.
4160            if max_ordinal == 0 {
4161                return Ok(());
4162            }
4163            depth.increment()?;
4164            let envelope_size = 8;
4165            let bytes_len = max_ordinal as usize * envelope_size;
4166            #[allow(unused_variables)]
4167            let offset = encoder.out_of_line_offset(bytes_len);
4168            let mut _prev_end_offset: usize = 0;
4169            if 1 > max_ordinal {
4170                return Ok(());
4171            }
4172
4173            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4174            // are envelope_size bytes.
4175            let cur_offset: usize = (1 - 1) * envelope_size;
4176
4177            // Zero reserved fields.
4178            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4179
4180            // Safety:
4181            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4182            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4183            //   envelope_size bytes, there is always sufficient room.
4184            fidl::encoding::encode_in_envelope_optional::<Initiator, D>(
4185                self.initiator.as_ref().map(<Initiator as fidl::encoding::ValueTypeMarker>::borrow),
4186                encoder,
4187                offset + cur_offset,
4188                depth,
4189            )?;
4190
4191            _prev_end_offset = cur_offset + envelope_size;
4192            if 2 > max_ordinal {
4193                return Ok(());
4194            }
4195
4196            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4197            // are envelope_size bytes.
4198            let cur_offset: usize = (2 - 1) * envelope_size;
4199
4200            // Zero reserved fields.
4201            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4202
4203            // Safety:
4204            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4205            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4206            //   envelope_size bytes, there is always sufficient room.
4207            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4208                self.allow_attach_to_existing_attempt
4209                    .as_ref()
4210                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4211                encoder,
4212                offset + cur_offset,
4213                depth,
4214            )?;
4215
4216            _prev_end_offset = cur_offset + envelope_size;
4217            if 3 > max_ordinal {
4218                return Ok(());
4219            }
4220
4221            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4222            // are envelope_size bytes.
4223            let cur_offset: usize = (3 - 1) * envelope_size;
4224
4225            // Zero reserved fields.
4226            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4227
4228            // Safety:
4229            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4230            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4231            //   envelope_size bytes, there is always sufficient room.
4232            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4233                self.should_write_recovery
4234                    .as_ref()
4235                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4236                encoder,
4237                offset + cur_offset,
4238                depth,
4239            )?;
4240
4241            _prev_end_offset = cur_offset + envelope_size;
4242
4243            Ok(())
4244        }
4245    }
4246
4247    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Options {
4248        #[inline(always)]
4249        fn new_empty() -> Self {
4250            Self::default()
4251        }
4252
4253        unsafe fn decode(
4254            &mut self,
4255            decoder: &mut fidl::encoding::Decoder<'_, D>,
4256            offset: usize,
4257            mut depth: fidl::encoding::Depth,
4258        ) -> fidl::Result<()> {
4259            decoder.debug_check_bounds::<Self>(offset);
4260            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4261                None => return Err(fidl::Error::NotNullable),
4262                Some(len) => len,
4263            };
4264            // Calling decoder.out_of_line_offset(0) is not allowed.
4265            if len == 0 {
4266                return Ok(());
4267            };
4268            depth.increment()?;
4269            let envelope_size = 8;
4270            let bytes_len = len * envelope_size;
4271            let offset = decoder.out_of_line_offset(bytes_len)?;
4272            // Decode the envelope for each type.
4273            let mut _next_ordinal_to_read = 0;
4274            let mut next_offset = offset;
4275            let end_offset = offset + bytes_len;
4276            _next_ordinal_to_read += 1;
4277            if next_offset >= end_offset {
4278                return Ok(());
4279            }
4280
4281            // Decode unknown envelopes for gaps in ordinals.
4282            while _next_ordinal_to_read < 1 {
4283                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4284                _next_ordinal_to_read += 1;
4285                next_offset += envelope_size;
4286            }
4287
4288            let next_out_of_line = decoder.next_out_of_line();
4289            let handles_before = decoder.remaining_handles();
4290            if let Some((inlined, num_bytes, num_handles)) =
4291                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4292            {
4293                let member_inline_size =
4294                    <Initiator as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4295                if inlined != (member_inline_size <= 4) {
4296                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4297                }
4298                let inner_offset;
4299                let mut inner_depth = depth.clone();
4300                if inlined {
4301                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4302                    inner_offset = next_offset;
4303                } else {
4304                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4305                    inner_depth.increment()?;
4306                }
4307                let val_ref = self.initiator.get_or_insert_with(|| fidl::new_empty!(Initiator, D));
4308                fidl::decode!(Initiator, D, val_ref, decoder, inner_offset, inner_depth)?;
4309                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4310                {
4311                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4312                }
4313                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4314                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4315                }
4316            }
4317
4318            next_offset += envelope_size;
4319            _next_ordinal_to_read += 1;
4320            if next_offset >= end_offset {
4321                return Ok(());
4322            }
4323
4324            // Decode unknown envelopes for gaps in ordinals.
4325            while _next_ordinal_to_read < 2 {
4326                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4327                _next_ordinal_to_read += 1;
4328                next_offset += envelope_size;
4329            }
4330
4331            let next_out_of_line = decoder.next_out_of_line();
4332            let handles_before = decoder.remaining_handles();
4333            if let Some((inlined, num_bytes, num_handles)) =
4334                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4335            {
4336                let member_inline_size =
4337                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4338                if inlined != (member_inline_size <= 4) {
4339                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4340                }
4341                let inner_offset;
4342                let mut inner_depth = depth.clone();
4343                if inlined {
4344                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4345                    inner_offset = next_offset;
4346                } else {
4347                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4348                    inner_depth.increment()?;
4349                }
4350                let val_ref = self
4351                    .allow_attach_to_existing_attempt
4352                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
4353                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4354                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4355                {
4356                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4357                }
4358                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4359                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4360                }
4361            }
4362
4363            next_offset += envelope_size;
4364            _next_ordinal_to_read += 1;
4365            if next_offset >= end_offset {
4366                return Ok(());
4367            }
4368
4369            // Decode unknown envelopes for gaps in ordinals.
4370            while _next_ordinal_to_read < 3 {
4371                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4372                _next_ordinal_to_read += 1;
4373                next_offset += envelope_size;
4374            }
4375
4376            let next_out_of_line = decoder.next_out_of_line();
4377            let handles_before = decoder.remaining_handles();
4378            if let Some((inlined, num_bytes, num_handles)) =
4379                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4380            {
4381                let member_inline_size =
4382                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4383                if inlined != (member_inline_size <= 4) {
4384                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4385                }
4386                let inner_offset;
4387                let mut inner_depth = depth.clone();
4388                if inlined {
4389                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4390                    inner_offset = next_offset;
4391                } else {
4392                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4393                    inner_depth.increment()?;
4394                }
4395                let val_ref =
4396                    self.should_write_recovery.get_or_insert_with(|| fidl::new_empty!(bool, D));
4397                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4398                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4399                {
4400                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4401                }
4402                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4403                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4404                }
4405            }
4406
4407            next_offset += envelope_size;
4408
4409            // Decode the remaining unknown envelopes.
4410            while next_offset < end_offset {
4411                _next_ordinal_to_read += 1;
4412                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4413                next_offset += envelope_size;
4414            }
4415
4416            Ok(())
4417        }
4418    }
4419
4420    impl PrepareData {
4421        #[inline(always)]
4422        fn max_ordinal_present(&self) -> u64 {
4423            0
4424        }
4425    }
4426
4427    impl fidl::encoding::ValueTypeMarker for PrepareData {
4428        type Borrowed<'a> = &'a Self;
4429        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4430            value
4431        }
4432    }
4433
4434    unsafe impl fidl::encoding::TypeMarker for PrepareData {
4435        type Owned = Self;
4436
4437        #[inline(always)]
4438        fn inline_align(_context: fidl::encoding::Context) -> usize {
4439            8
4440        }
4441
4442        #[inline(always)]
4443        fn inline_size(_context: fidl::encoding::Context) -> usize {
4444            16
4445        }
4446    }
4447
4448    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PrepareData, D>
4449        for &PrepareData
4450    {
4451        unsafe fn encode(
4452            self,
4453            encoder: &mut fidl::encoding::Encoder<'_, D>,
4454            offset: usize,
4455            mut depth: fidl::encoding::Depth,
4456        ) -> fidl::Result<()> {
4457            encoder.debug_check_bounds::<PrepareData>(offset);
4458            // Vector header
4459            let max_ordinal: u64 = self.max_ordinal_present();
4460            encoder.write_num(max_ordinal, offset);
4461            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4462            // Calling encoder.out_of_line_offset(0) is not allowed.
4463            if max_ordinal == 0 {
4464                return Ok(());
4465            }
4466            depth.increment()?;
4467            let envelope_size = 8;
4468            let bytes_len = max_ordinal as usize * envelope_size;
4469            #[allow(unused_variables)]
4470            let offset = encoder.out_of_line_offset(bytes_len);
4471            let mut _prev_end_offset: usize = 0;
4472
4473            Ok(())
4474        }
4475    }
4476
4477    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PrepareData {
4478        #[inline(always)]
4479        fn new_empty() -> Self {
4480            Self::default()
4481        }
4482
4483        unsafe fn decode(
4484            &mut self,
4485            decoder: &mut fidl::encoding::Decoder<'_, D>,
4486            offset: usize,
4487            mut depth: fidl::encoding::Depth,
4488        ) -> fidl::Result<()> {
4489            decoder.debug_check_bounds::<Self>(offset);
4490            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4491                None => return Err(fidl::Error::NotNullable),
4492                Some(len) => len,
4493            };
4494            // Calling decoder.out_of_line_offset(0) is not allowed.
4495            if len == 0 {
4496                return Ok(());
4497            };
4498            depth.increment()?;
4499            let envelope_size = 8;
4500            let bytes_len = len * envelope_size;
4501            let offset = decoder.out_of_line_offset(bytes_len)?;
4502            // Decode the envelope for each type.
4503            let mut _next_ordinal_to_read = 0;
4504            let mut next_offset = offset;
4505            let end_offset = offset + bytes_len;
4506
4507            // Decode the remaining unknown envelopes.
4508            while next_offset < end_offset {
4509                _next_ordinal_to_read += 1;
4510                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4511                next_offset += envelope_size;
4512            }
4513
4514            Ok(())
4515        }
4516    }
4517
4518    impl RebootData {
4519        #[inline(always)]
4520        fn max_ordinal_present(&self) -> u64 {
4521            if let Some(_) = self.progress {
4522                return 2;
4523            }
4524            if let Some(_) = self.info {
4525                return 1;
4526            }
4527            0
4528        }
4529    }
4530
4531    impl fidl::encoding::ValueTypeMarker for RebootData {
4532        type Borrowed<'a> = &'a Self;
4533        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4534            value
4535        }
4536    }
4537
4538    unsafe impl fidl::encoding::TypeMarker for RebootData {
4539        type Owned = Self;
4540
4541        #[inline(always)]
4542        fn inline_align(_context: fidl::encoding::Context) -> usize {
4543            8
4544        }
4545
4546        #[inline(always)]
4547        fn inline_size(_context: fidl::encoding::Context) -> usize {
4548            16
4549        }
4550    }
4551
4552    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RebootData, D>
4553        for &RebootData
4554    {
4555        unsafe fn encode(
4556            self,
4557            encoder: &mut fidl::encoding::Encoder<'_, D>,
4558            offset: usize,
4559            mut depth: fidl::encoding::Depth,
4560        ) -> fidl::Result<()> {
4561            encoder.debug_check_bounds::<RebootData>(offset);
4562            // Vector header
4563            let max_ordinal: u64 = self.max_ordinal_present();
4564            encoder.write_num(max_ordinal, offset);
4565            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4566            // Calling encoder.out_of_line_offset(0) is not allowed.
4567            if max_ordinal == 0 {
4568                return Ok(());
4569            }
4570            depth.increment()?;
4571            let envelope_size = 8;
4572            let bytes_len = max_ordinal as usize * envelope_size;
4573            #[allow(unused_variables)]
4574            let offset = encoder.out_of_line_offset(bytes_len);
4575            let mut _prev_end_offset: usize = 0;
4576            if 1 > max_ordinal {
4577                return Ok(());
4578            }
4579
4580            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4581            // are envelope_size bytes.
4582            let cur_offset: usize = (1 - 1) * envelope_size;
4583
4584            // Zero reserved fields.
4585            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4586
4587            // Safety:
4588            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4589            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4590            //   envelope_size bytes, there is always sufficient room.
4591            fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
4592                self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
4593                encoder,
4594                offset + cur_offset,
4595                depth,
4596            )?;
4597
4598            _prev_end_offset = cur_offset + envelope_size;
4599            if 2 > max_ordinal {
4600                return Ok(());
4601            }
4602
4603            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4604            // are envelope_size bytes.
4605            let cur_offset: usize = (2 - 1) * envelope_size;
4606
4607            // Zero reserved fields.
4608            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4609
4610            // Safety:
4611            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4612            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4613            //   envelope_size bytes, there is always sufficient room.
4614            fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
4615                self.progress
4616                    .as_ref()
4617                    .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
4618                encoder,
4619                offset + cur_offset,
4620                depth,
4621            )?;
4622
4623            _prev_end_offset = cur_offset + envelope_size;
4624
4625            Ok(())
4626        }
4627    }
4628
4629    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RebootData {
4630        #[inline(always)]
4631        fn new_empty() -> Self {
4632            Self::default()
4633        }
4634
4635        unsafe fn decode(
4636            &mut self,
4637            decoder: &mut fidl::encoding::Decoder<'_, D>,
4638            offset: usize,
4639            mut depth: fidl::encoding::Depth,
4640        ) -> fidl::Result<()> {
4641            decoder.debug_check_bounds::<Self>(offset);
4642            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4643                None => return Err(fidl::Error::NotNullable),
4644                Some(len) => len,
4645            };
4646            // Calling decoder.out_of_line_offset(0) is not allowed.
4647            if len == 0 {
4648                return Ok(());
4649            };
4650            depth.increment()?;
4651            let envelope_size = 8;
4652            let bytes_len = len * envelope_size;
4653            let offset = decoder.out_of_line_offset(bytes_len)?;
4654            // Decode the envelope for each type.
4655            let mut _next_ordinal_to_read = 0;
4656            let mut next_offset = offset;
4657            let end_offset = offset + bytes_len;
4658            _next_ordinal_to_read += 1;
4659            if next_offset >= end_offset {
4660                return Ok(());
4661            }
4662
4663            // Decode unknown envelopes for gaps in ordinals.
4664            while _next_ordinal_to_read < 1 {
4665                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4666                _next_ordinal_to_read += 1;
4667                next_offset += envelope_size;
4668            }
4669
4670            let next_out_of_line = decoder.next_out_of_line();
4671            let handles_before = decoder.remaining_handles();
4672            if let Some((inlined, num_bytes, num_handles)) =
4673                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4674            {
4675                let member_inline_size =
4676                    <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4677                if inlined != (member_inline_size <= 4) {
4678                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4679                }
4680                let inner_offset;
4681                let mut inner_depth = depth.clone();
4682                if inlined {
4683                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4684                    inner_offset = next_offset;
4685                } else {
4686                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4687                    inner_depth.increment()?;
4688                }
4689                let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
4690                fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
4691                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4692                {
4693                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4694                }
4695                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4696                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4697                }
4698            }
4699
4700            next_offset += envelope_size;
4701            _next_ordinal_to_read += 1;
4702            if next_offset >= end_offset {
4703                return Ok(());
4704            }
4705
4706            // Decode unknown envelopes for gaps in ordinals.
4707            while _next_ordinal_to_read < 2 {
4708                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4709                _next_ordinal_to_read += 1;
4710                next_offset += envelope_size;
4711            }
4712
4713            let next_out_of_line = decoder.next_out_of_line();
4714            let handles_before = decoder.remaining_handles();
4715            if let Some((inlined, num_bytes, num_handles)) =
4716                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4717            {
4718                let member_inline_size =
4719                    <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
4720                        decoder.context,
4721                    );
4722                if inlined != (member_inline_size <= 4) {
4723                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4724                }
4725                let inner_offset;
4726                let mut inner_depth = depth.clone();
4727                if inlined {
4728                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4729                    inner_offset = next_offset;
4730                } else {
4731                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4732                    inner_depth.increment()?;
4733                }
4734                let val_ref =
4735                    self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
4736                fidl::decode!(
4737                    InstallationProgress,
4738                    D,
4739                    val_ref,
4740                    decoder,
4741                    inner_offset,
4742                    inner_depth
4743                )?;
4744                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4745                {
4746                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4747                }
4748                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4749                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4750                }
4751            }
4752
4753            next_offset += envelope_size;
4754
4755            // Decode the remaining unknown envelopes.
4756            while next_offset < end_offset {
4757                _next_ordinal_to_read += 1;
4758                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4759                next_offset += envelope_size;
4760            }
4761
4762            Ok(())
4763        }
4764    }
4765
4766    impl StageData {
4767        #[inline(always)]
4768        fn max_ordinal_present(&self) -> u64 {
4769            if let Some(_) = self.progress {
4770                return 2;
4771            }
4772            if let Some(_) = self.info {
4773                return 1;
4774            }
4775            0
4776        }
4777    }
4778
4779    impl fidl::encoding::ValueTypeMarker for StageData {
4780        type Borrowed<'a> = &'a Self;
4781        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4782            value
4783        }
4784    }
4785
4786    unsafe impl fidl::encoding::TypeMarker for StageData {
4787        type Owned = Self;
4788
4789        #[inline(always)]
4790        fn inline_align(_context: fidl::encoding::Context) -> usize {
4791            8
4792        }
4793
4794        #[inline(always)]
4795        fn inline_size(_context: fidl::encoding::Context) -> usize {
4796            16
4797        }
4798    }
4799
4800    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StageData, D>
4801        for &StageData
4802    {
4803        unsafe fn encode(
4804            self,
4805            encoder: &mut fidl::encoding::Encoder<'_, D>,
4806            offset: usize,
4807            mut depth: fidl::encoding::Depth,
4808        ) -> fidl::Result<()> {
4809            encoder.debug_check_bounds::<StageData>(offset);
4810            // Vector header
4811            let max_ordinal: u64 = self.max_ordinal_present();
4812            encoder.write_num(max_ordinal, offset);
4813            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4814            // Calling encoder.out_of_line_offset(0) is not allowed.
4815            if max_ordinal == 0 {
4816                return Ok(());
4817            }
4818            depth.increment()?;
4819            let envelope_size = 8;
4820            let bytes_len = max_ordinal as usize * envelope_size;
4821            #[allow(unused_variables)]
4822            let offset = encoder.out_of_line_offset(bytes_len);
4823            let mut _prev_end_offset: usize = 0;
4824            if 1 > max_ordinal {
4825                return Ok(());
4826            }
4827
4828            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4829            // are envelope_size bytes.
4830            let cur_offset: usize = (1 - 1) * envelope_size;
4831
4832            // Zero reserved fields.
4833            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4834
4835            // Safety:
4836            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4837            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4838            //   envelope_size bytes, there is always sufficient room.
4839            fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
4840                self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
4841                encoder,
4842                offset + cur_offset,
4843                depth,
4844            )?;
4845
4846            _prev_end_offset = cur_offset + envelope_size;
4847            if 2 > max_ordinal {
4848                return Ok(());
4849            }
4850
4851            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4852            // are envelope_size bytes.
4853            let cur_offset: usize = (2 - 1) * envelope_size;
4854
4855            // Zero reserved fields.
4856            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4857
4858            // Safety:
4859            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4860            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4861            //   envelope_size bytes, there is always sufficient room.
4862            fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
4863                self.progress
4864                    .as_ref()
4865                    .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
4866                encoder,
4867                offset + cur_offset,
4868                depth,
4869            )?;
4870
4871            _prev_end_offset = cur_offset + envelope_size;
4872
4873            Ok(())
4874        }
4875    }
4876
4877    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StageData {
4878        #[inline(always)]
4879        fn new_empty() -> Self {
4880            Self::default()
4881        }
4882
4883        unsafe fn decode(
4884            &mut self,
4885            decoder: &mut fidl::encoding::Decoder<'_, D>,
4886            offset: usize,
4887            mut depth: fidl::encoding::Depth,
4888        ) -> fidl::Result<()> {
4889            decoder.debug_check_bounds::<Self>(offset);
4890            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4891                None => return Err(fidl::Error::NotNullable),
4892                Some(len) => len,
4893            };
4894            // Calling decoder.out_of_line_offset(0) is not allowed.
4895            if len == 0 {
4896                return Ok(());
4897            };
4898            depth.increment()?;
4899            let envelope_size = 8;
4900            let bytes_len = len * envelope_size;
4901            let offset = decoder.out_of_line_offset(bytes_len)?;
4902            // Decode the envelope for each type.
4903            let mut _next_ordinal_to_read = 0;
4904            let mut next_offset = offset;
4905            let end_offset = offset + bytes_len;
4906            _next_ordinal_to_read += 1;
4907            if next_offset >= end_offset {
4908                return Ok(());
4909            }
4910
4911            // Decode unknown envelopes for gaps in ordinals.
4912            while _next_ordinal_to_read < 1 {
4913                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4914                _next_ordinal_to_read += 1;
4915                next_offset += envelope_size;
4916            }
4917
4918            let next_out_of_line = decoder.next_out_of_line();
4919            let handles_before = decoder.remaining_handles();
4920            if let Some((inlined, num_bytes, num_handles)) =
4921                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4922            {
4923                let member_inline_size =
4924                    <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4925                if inlined != (member_inline_size <= 4) {
4926                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4927                }
4928                let inner_offset;
4929                let mut inner_depth = depth.clone();
4930                if inlined {
4931                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4932                    inner_offset = next_offset;
4933                } else {
4934                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4935                    inner_depth.increment()?;
4936                }
4937                let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
4938                fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
4939                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4940                {
4941                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4942                }
4943                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4944                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4945                }
4946            }
4947
4948            next_offset += envelope_size;
4949            _next_ordinal_to_read += 1;
4950            if next_offset >= end_offset {
4951                return Ok(());
4952            }
4953
4954            // Decode unknown envelopes for gaps in ordinals.
4955            while _next_ordinal_to_read < 2 {
4956                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4957                _next_ordinal_to_read += 1;
4958                next_offset += envelope_size;
4959            }
4960
4961            let next_out_of_line = decoder.next_out_of_line();
4962            let handles_before = decoder.remaining_handles();
4963            if let Some((inlined, num_bytes, num_handles)) =
4964                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4965            {
4966                let member_inline_size =
4967                    <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
4968                        decoder.context,
4969                    );
4970                if inlined != (member_inline_size <= 4) {
4971                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4972                }
4973                let inner_offset;
4974                let mut inner_depth = depth.clone();
4975                if inlined {
4976                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4977                    inner_offset = next_offset;
4978                } else {
4979                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4980                    inner_depth.increment()?;
4981                }
4982                let val_ref =
4983                    self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
4984                fidl::decode!(
4985                    InstallationProgress,
4986                    D,
4987                    val_ref,
4988                    decoder,
4989                    inner_offset,
4990                    inner_depth
4991                )?;
4992                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4993                {
4994                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4995                }
4996                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4997                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4998                }
4999            }
5000
5001            next_offset += envelope_size;
5002
5003            // Decode the remaining unknown envelopes.
5004            while next_offset < end_offset {
5005                _next_ordinal_to_read += 1;
5006                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5007                next_offset += envelope_size;
5008            }
5009
5010            Ok(())
5011        }
5012    }
5013
5014    impl UpdateInfo {
5015        #[inline(always)]
5016        fn max_ordinal_present(&self) -> u64 {
5017            if let Some(_) = self.download_size {
5018                return 1;
5019            }
5020            0
5021        }
5022    }
5023
5024    impl fidl::encoding::ValueTypeMarker for UpdateInfo {
5025        type Borrowed<'a> = &'a Self;
5026        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5027            value
5028        }
5029    }
5030
5031    unsafe impl fidl::encoding::TypeMarker for UpdateInfo {
5032        type Owned = Self;
5033
5034        #[inline(always)]
5035        fn inline_align(_context: fidl::encoding::Context) -> usize {
5036            8
5037        }
5038
5039        #[inline(always)]
5040        fn inline_size(_context: fidl::encoding::Context) -> usize {
5041            16
5042        }
5043    }
5044
5045    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UpdateInfo, D>
5046        for &UpdateInfo
5047    {
5048        unsafe fn encode(
5049            self,
5050            encoder: &mut fidl::encoding::Encoder<'_, D>,
5051            offset: usize,
5052            mut depth: fidl::encoding::Depth,
5053        ) -> fidl::Result<()> {
5054            encoder.debug_check_bounds::<UpdateInfo>(offset);
5055            // Vector header
5056            let max_ordinal: u64 = self.max_ordinal_present();
5057            encoder.write_num(max_ordinal, offset);
5058            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5059            // Calling encoder.out_of_line_offset(0) is not allowed.
5060            if max_ordinal == 0 {
5061                return Ok(());
5062            }
5063            depth.increment()?;
5064            let envelope_size = 8;
5065            let bytes_len = max_ordinal as usize * envelope_size;
5066            #[allow(unused_variables)]
5067            let offset = encoder.out_of_line_offset(bytes_len);
5068            let mut _prev_end_offset: usize = 0;
5069            if 1 > max_ordinal {
5070                return Ok(());
5071            }
5072
5073            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5074            // are envelope_size bytes.
5075            let cur_offset: usize = (1 - 1) * envelope_size;
5076
5077            // Zero reserved fields.
5078            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5079
5080            // Safety:
5081            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5082            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5083            //   envelope_size bytes, there is always sufficient room.
5084            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5085                self.download_size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5086                encoder,
5087                offset + cur_offset,
5088                depth,
5089            )?;
5090
5091            _prev_end_offset = cur_offset + envelope_size;
5092
5093            Ok(())
5094        }
5095    }
5096
5097    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpdateInfo {
5098        #[inline(always)]
5099        fn new_empty() -> Self {
5100            Self::default()
5101        }
5102
5103        unsafe fn decode(
5104            &mut self,
5105            decoder: &mut fidl::encoding::Decoder<'_, D>,
5106            offset: usize,
5107            mut depth: fidl::encoding::Depth,
5108        ) -> fidl::Result<()> {
5109            decoder.debug_check_bounds::<Self>(offset);
5110            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5111                None => return Err(fidl::Error::NotNullable),
5112                Some(len) => len,
5113            };
5114            // Calling decoder.out_of_line_offset(0) is not allowed.
5115            if len == 0 {
5116                return Ok(());
5117            };
5118            depth.increment()?;
5119            let envelope_size = 8;
5120            let bytes_len = len * envelope_size;
5121            let offset = decoder.out_of_line_offset(bytes_len)?;
5122            // Decode the envelope for each type.
5123            let mut _next_ordinal_to_read = 0;
5124            let mut next_offset = offset;
5125            let end_offset = offset + bytes_len;
5126            _next_ordinal_to_read += 1;
5127            if next_offset >= end_offset {
5128                return Ok(());
5129            }
5130
5131            // Decode unknown envelopes for gaps in ordinals.
5132            while _next_ordinal_to_read < 1 {
5133                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5134                _next_ordinal_to_read += 1;
5135                next_offset += envelope_size;
5136            }
5137
5138            let next_out_of_line = decoder.next_out_of_line();
5139            let handles_before = decoder.remaining_handles();
5140            if let Some((inlined, num_bytes, num_handles)) =
5141                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5142            {
5143                let member_inline_size =
5144                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5145                if inlined != (member_inline_size <= 4) {
5146                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5147                }
5148                let inner_offset;
5149                let mut inner_depth = depth.clone();
5150                if inlined {
5151                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5152                    inner_offset = next_offset;
5153                } else {
5154                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5155                    inner_depth.increment()?;
5156                }
5157                let val_ref = self.download_size.get_or_insert_with(|| fidl::new_empty!(u64, D));
5158                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5159                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5160                {
5161                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5162                }
5163                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5164                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5165                }
5166            }
5167
5168            next_offset += envelope_size;
5169
5170            // Decode the remaining unknown envelopes.
5171            while next_offset < end_offset {
5172                _next_ordinal_to_read += 1;
5173                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5174                next_offset += envelope_size;
5175            }
5176
5177            Ok(())
5178        }
5179    }
5180
5181    impl WaitToRebootData {
5182        #[inline(always)]
5183        fn max_ordinal_present(&self) -> u64 {
5184            if let Some(_) = self.progress {
5185                return 2;
5186            }
5187            if let Some(_) = self.info {
5188                return 1;
5189            }
5190            0
5191        }
5192    }
5193
5194    impl fidl::encoding::ValueTypeMarker for WaitToRebootData {
5195        type Borrowed<'a> = &'a Self;
5196        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5197            value
5198        }
5199    }
5200
5201    unsafe impl fidl::encoding::TypeMarker for WaitToRebootData {
5202        type Owned = Self;
5203
5204        #[inline(always)]
5205        fn inline_align(_context: fidl::encoding::Context) -> usize {
5206            8
5207        }
5208
5209        #[inline(always)]
5210        fn inline_size(_context: fidl::encoding::Context) -> usize {
5211            16
5212        }
5213    }
5214
5215    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<WaitToRebootData, D>
5216        for &WaitToRebootData
5217    {
5218        unsafe fn encode(
5219            self,
5220            encoder: &mut fidl::encoding::Encoder<'_, D>,
5221            offset: usize,
5222            mut depth: fidl::encoding::Depth,
5223        ) -> fidl::Result<()> {
5224            encoder.debug_check_bounds::<WaitToRebootData>(offset);
5225            // Vector header
5226            let max_ordinal: u64 = self.max_ordinal_present();
5227            encoder.write_num(max_ordinal, offset);
5228            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5229            // Calling encoder.out_of_line_offset(0) is not allowed.
5230            if max_ordinal == 0 {
5231                return Ok(());
5232            }
5233            depth.increment()?;
5234            let envelope_size = 8;
5235            let bytes_len = max_ordinal as usize * envelope_size;
5236            #[allow(unused_variables)]
5237            let offset = encoder.out_of_line_offset(bytes_len);
5238            let mut _prev_end_offset: usize = 0;
5239            if 1 > max_ordinal {
5240                return Ok(());
5241            }
5242
5243            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5244            // are envelope_size bytes.
5245            let cur_offset: usize = (1 - 1) * envelope_size;
5246
5247            // Zero reserved fields.
5248            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5249
5250            // Safety:
5251            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5252            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5253            //   envelope_size bytes, there is always sufficient room.
5254            fidl::encoding::encode_in_envelope_optional::<UpdateInfo, D>(
5255                self.info.as_ref().map(<UpdateInfo as fidl::encoding::ValueTypeMarker>::borrow),
5256                encoder,
5257                offset + cur_offset,
5258                depth,
5259            )?;
5260
5261            _prev_end_offset = cur_offset + envelope_size;
5262            if 2 > max_ordinal {
5263                return Ok(());
5264            }
5265
5266            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5267            // are envelope_size bytes.
5268            let cur_offset: usize = (2 - 1) * envelope_size;
5269
5270            // Zero reserved fields.
5271            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5272
5273            // Safety:
5274            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5275            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5276            //   envelope_size bytes, there is always sufficient room.
5277            fidl::encoding::encode_in_envelope_optional::<InstallationProgress, D>(
5278                self.progress
5279                    .as_ref()
5280                    .map(<InstallationProgress as fidl::encoding::ValueTypeMarker>::borrow),
5281                encoder,
5282                offset + cur_offset,
5283                depth,
5284            )?;
5285
5286            _prev_end_offset = cur_offset + envelope_size;
5287
5288            Ok(())
5289        }
5290    }
5291
5292    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WaitToRebootData {
5293        #[inline(always)]
5294        fn new_empty() -> Self {
5295            Self::default()
5296        }
5297
5298        unsafe fn decode(
5299            &mut self,
5300            decoder: &mut fidl::encoding::Decoder<'_, D>,
5301            offset: usize,
5302            mut depth: fidl::encoding::Depth,
5303        ) -> fidl::Result<()> {
5304            decoder.debug_check_bounds::<Self>(offset);
5305            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5306                None => return Err(fidl::Error::NotNullable),
5307                Some(len) => len,
5308            };
5309            // Calling decoder.out_of_line_offset(0) is not allowed.
5310            if len == 0 {
5311                return Ok(());
5312            };
5313            depth.increment()?;
5314            let envelope_size = 8;
5315            let bytes_len = len * envelope_size;
5316            let offset = decoder.out_of_line_offset(bytes_len)?;
5317            // Decode the envelope for each type.
5318            let mut _next_ordinal_to_read = 0;
5319            let mut next_offset = offset;
5320            let end_offset = offset + bytes_len;
5321            _next_ordinal_to_read += 1;
5322            if next_offset >= end_offset {
5323                return Ok(());
5324            }
5325
5326            // Decode unknown envelopes for gaps in ordinals.
5327            while _next_ordinal_to_read < 1 {
5328                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5329                _next_ordinal_to_read += 1;
5330                next_offset += envelope_size;
5331            }
5332
5333            let next_out_of_line = decoder.next_out_of_line();
5334            let handles_before = decoder.remaining_handles();
5335            if let Some((inlined, num_bytes, num_handles)) =
5336                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5337            {
5338                let member_inline_size =
5339                    <UpdateInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5340                if inlined != (member_inline_size <= 4) {
5341                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5342                }
5343                let inner_offset;
5344                let mut inner_depth = depth.clone();
5345                if inlined {
5346                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5347                    inner_offset = next_offset;
5348                } else {
5349                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5350                    inner_depth.increment()?;
5351                }
5352                let val_ref = self.info.get_or_insert_with(|| fidl::new_empty!(UpdateInfo, D));
5353                fidl::decode!(UpdateInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
5354                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5355                {
5356                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5357                }
5358                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5359                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5360                }
5361            }
5362
5363            next_offset += envelope_size;
5364            _next_ordinal_to_read += 1;
5365            if next_offset >= end_offset {
5366                return Ok(());
5367            }
5368
5369            // Decode unknown envelopes for gaps in ordinals.
5370            while _next_ordinal_to_read < 2 {
5371                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5372                _next_ordinal_to_read += 1;
5373                next_offset += envelope_size;
5374            }
5375
5376            let next_out_of_line = decoder.next_out_of_line();
5377            let handles_before = decoder.remaining_handles();
5378            if let Some((inlined, num_bytes, num_handles)) =
5379                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5380            {
5381                let member_inline_size =
5382                    <InstallationProgress as fidl::encoding::TypeMarker>::inline_size(
5383                        decoder.context,
5384                    );
5385                if inlined != (member_inline_size <= 4) {
5386                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5387                }
5388                let inner_offset;
5389                let mut inner_depth = depth.clone();
5390                if inlined {
5391                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5392                    inner_offset = next_offset;
5393                } else {
5394                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5395                    inner_depth.increment()?;
5396                }
5397                let val_ref =
5398                    self.progress.get_or_insert_with(|| fidl::new_empty!(InstallationProgress, D));
5399                fidl::decode!(
5400                    InstallationProgress,
5401                    D,
5402                    val_ref,
5403                    decoder,
5404                    inner_offset,
5405                    inner_depth
5406                )?;
5407                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5408                {
5409                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5410                }
5411                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5412                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5413                }
5414            }
5415
5416            next_offset += envelope_size;
5417
5418            // Decode the remaining unknown envelopes.
5419            while next_offset < end_offset {
5420                _next_ordinal_to_read += 1;
5421                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5422                next_offset += envelope_size;
5423            }
5424
5425            Ok(())
5426        }
5427    }
5428
5429    impl fidl::encoding::ValueTypeMarker for State {
5430        type Borrowed<'a> = &'a Self;
5431        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5432            value
5433        }
5434    }
5435
5436    unsafe impl fidl::encoding::TypeMarker for State {
5437        type Owned = Self;
5438
5439        #[inline(always)]
5440        fn inline_align(_context: fidl::encoding::Context) -> usize {
5441            8
5442        }
5443
5444        #[inline(always)]
5445        fn inline_size(_context: fidl::encoding::Context) -> usize {
5446            16
5447        }
5448    }
5449
5450    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<State, D> for &State {
5451        #[inline]
5452        unsafe fn encode(
5453            self,
5454            encoder: &mut fidl::encoding::Encoder<'_, D>,
5455            offset: usize,
5456            _depth: fidl::encoding::Depth,
5457        ) -> fidl::Result<()> {
5458            encoder.debug_check_bounds::<State>(offset);
5459            encoder.write_num::<u64>(self.ordinal(), offset);
5460            match self {
5461                State::Prepare(ref val) => fidl::encoding::encode_in_envelope::<PrepareData, D>(
5462                    <PrepareData as fidl::encoding::ValueTypeMarker>::borrow(val),
5463                    encoder,
5464                    offset + 8,
5465                    _depth,
5466                ),
5467                State::Stage(ref val) => fidl::encoding::encode_in_envelope::<StageData, D>(
5468                    <StageData as fidl::encoding::ValueTypeMarker>::borrow(val),
5469                    encoder,
5470                    offset + 8,
5471                    _depth,
5472                ),
5473                State::Fetch(ref val) => fidl::encoding::encode_in_envelope::<FetchData, D>(
5474                    <FetchData as fidl::encoding::ValueTypeMarker>::borrow(val),
5475                    encoder,
5476                    offset + 8,
5477                    _depth,
5478                ),
5479                State::Commit(ref val) => fidl::encoding::encode_in_envelope::<CommitData, D>(
5480                    <CommitData as fidl::encoding::ValueTypeMarker>::borrow(val),
5481                    encoder,
5482                    offset + 8,
5483                    _depth,
5484                ),
5485                State::WaitToReboot(ref val) => {
5486                    fidl::encoding::encode_in_envelope::<WaitToRebootData, D>(
5487                        <WaitToRebootData as fidl::encoding::ValueTypeMarker>::borrow(val),
5488                        encoder,
5489                        offset + 8,
5490                        _depth,
5491                    )
5492                }
5493                State::Reboot(ref val) => fidl::encoding::encode_in_envelope::<RebootData, D>(
5494                    <RebootData as fidl::encoding::ValueTypeMarker>::borrow(val),
5495                    encoder,
5496                    offset + 8,
5497                    _depth,
5498                ),
5499                State::DeferReboot(ref val) => {
5500                    fidl::encoding::encode_in_envelope::<DeferRebootData, D>(
5501                        <DeferRebootData as fidl::encoding::ValueTypeMarker>::borrow(val),
5502                        encoder,
5503                        offset + 8,
5504                        _depth,
5505                    )
5506                }
5507                State::Complete(ref val) => fidl::encoding::encode_in_envelope::<CompleteData, D>(
5508                    <CompleteData as fidl::encoding::ValueTypeMarker>::borrow(val),
5509                    encoder,
5510                    offset + 8,
5511                    _depth,
5512                ),
5513                State::FailPrepare(ref val) => {
5514                    fidl::encoding::encode_in_envelope::<FailPrepareData, D>(
5515                        <FailPrepareData as fidl::encoding::ValueTypeMarker>::borrow(val),
5516                        encoder,
5517                        offset + 8,
5518                        _depth,
5519                    )
5520                }
5521                State::FailStage(ref val) => {
5522                    fidl::encoding::encode_in_envelope::<FailStageData, D>(
5523                        <FailStageData as fidl::encoding::ValueTypeMarker>::borrow(val),
5524                        encoder,
5525                        offset + 8,
5526                        _depth,
5527                    )
5528                }
5529                State::FailFetch(ref val) => {
5530                    fidl::encoding::encode_in_envelope::<FailFetchData, D>(
5531                        <FailFetchData as fidl::encoding::ValueTypeMarker>::borrow(val),
5532                        encoder,
5533                        offset + 8,
5534                        _depth,
5535                    )
5536                }
5537                State::FailCommit(ref val) => {
5538                    fidl::encoding::encode_in_envelope::<FailCommitData, D>(
5539                        <FailCommitData as fidl::encoding::ValueTypeMarker>::borrow(val),
5540                        encoder,
5541                        offset + 8,
5542                        _depth,
5543                    )
5544                }
5545                State::Canceled(ref val) => fidl::encoding::encode_in_envelope::<CanceledData, D>(
5546                    <CanceledData as fidl::encoding::ValueTypeMarker>::borrow(val),
5547                    encoder,
5548                    offset + 8,
5549                    _depth,
5550                ),
5551            }
5552        }
5553    }
5554
5555    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for State {
5556        #[inline(always)]
5557        fn new_empty() -> Self {
5558            Self::Prepare(fidl::new_empty!(PrepareData, D))
5559        }
5560
5561        #[inline]
5562        unsafe fn decode(
5563            &mut self,
5564            decoder: &mut fidl::encoding::Decoder<'_, D>,
5565            offset: usize,
5566            mut depth: fidl::encoding::Depth,
5567        ) -> fidl::Result<()> {
5568            decoder.debug_check_bounds::<Self>(offset);
5569            #[allow(unused_variables)]
5570            let next_out_of_line = decoder.next_out_of_line();
5571            let handles_before = decoder.remaining_handles();
5572            let (ordinal, inlined, num_bytes, num_handles) =
5573                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
5574
5575            let member_inline_size = match ordinal {
5576                1 => <PrepareData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5577                2 => <StageData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5578                3 => <FetchData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5579                4 => <CommitData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5580                5 => <WaitToRebootData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5581                6 => <RebootData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5582                7 => <DeferRebootData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5583                8 => <CompleteData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5584                9 => <FailPrepareData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5585                10 => <FailStageData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5586                11 => <FailFetchData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5587                12 => <FailCommitData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5588                13 => <CanceledData as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5589                _ => return Err(fidl::Error::UnknownUnionTag),
5590            };
5591
5592            if inlined != (member_inline_size <= 4) {
5593                return Err(fidl::Error::InvalidInlineBitInEnvelope);
5594            }
5595            let _inner_offset;
5596            if inlined {
5597                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
5598                _inner_offset = offset + 8;
5599            } else {
5600                depth.increment()?;
5601                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5602            }
5603            match ordinal {
5604                1 => {
5605                    #[allow(irrefutable_let_patterns)]
5606                    if let State::Prepare(_) = self {
5607                        // Do nothing, read the value into the object
5608                    } else {
5609                        // Initialize `self` to the right variant
5610                        *self = State::Prepare(fidl::new_empty!(PrepareData, D));
5611                    }
5612                    #[allow(irrefutable_let_patterns)]
5613                    if let State::Prepare(ref mut val) = self {
5614                        fidl::decode!(PrepareData, D, val, decoder, _inner_offset, depth)?;
5615                    } else {
5616                        unreachable!()
5617                    }
5618                }
5619                2 => {
5620                    #[allow(irrefutable_let_patterns)]
5621                    if let State::Stage(_) = self {
5622                        // Do nothing, read the value into the object
5623                    } else {
5624                        // Initialize `self` to the right variant
5625                        *self = State::Stage(fidl::new_empty!(StageData, D));
5626                    }
5627                    #[allow(irrefutable_let_patterns)]
5628                    if let State::Stage(ref mut val) = self {
5629                        fidl::decode!(StageData, D, val, decoder, _inner_offset, depth)?;
5630                    } else {
5631                        unreachable!()
5632                    }
5633                }
5634                3 => {
5635                    #[allow(irrefutable_let_patterns)]
5636                    if let State::Fetch(_) = self {
5637                        // Do nothing, read the value into the object
5638                    } else {
5639                        // Initialize `self` to the right variant
5640                        *self = State::Fetch(fidl::new_empty!(FetchData, D));
5641                    }
5642                    #[allow(irrefutable_let_patterns)]
5643                    if let State::Fetch(ref mut val) = self {
5644                        fidl::decode!(FetchData, D, val, decoder, _inner_offset, depth)?;
5645                    } else {
5646                        unreachable!()
5647                    }
5648                }
5649                4 => {
5650                    #[allow(irrefutable_let_patterns)]
5651                    if let State::Commit(_) = self {
5652                        // Do nothing, read the value into the object
5653                    } else {
5654                        // Initialize `self` to the right variant
5655                        *self = State::Commit(fidl::new_empty!(CommitData, D));
5656                    }
5657                    #[allow(irrefutable_let_patterns)]
5658                    if let State::Commit(ref mut val) = self {
5659                        fidl::decode!(CommitData, D, val, decoder, _inner_offset, depth)?;
5660                    } else {
5661                        unreachable!()
5662                    }
5663                }
5664                5 => {
5665                    #[allow(irrefutable_let_patterns)]
5666                    if let State::WaitToReboot(_) = self {
5667                        // Do nothing, read the value into the object
5668                    } else {
5669                        // Initialize `self` to the right variant
5670                        *self = State::WaitToReboot(fidl::new_empty!(WaitToRebootData, D));
5671                    }
5672                    #[allow(irrefutable_let_patterns)]
5673                    if let State::WaitToReboot(ref mut val) = self {
5674                        fidl::decode!(WaitToRebootData, D, val, decoder, _inner_offset, depth)?;
5675                    } else {
5676                        unreachable!()
5677                    }
5678                }
5679                6 => {
5680                    #[allow(irrefutable_let_patterns)]
5681                    if let State::Reboot(_) = self {
5682                        // Do nothing, read the value into the object
5683                    } else {
5684                        // Initialize `self` to the right variant
5685                        *self = State::Reboot(fidl::new_empty!(RebootData, D));
5686                    }
5687                    #[allow(irrefutable_let_patterns)]
5688                    if let State::Reboot(ref mut val) = self {
5689                        fidl::decode!(RebootData, D, val, decoder, _inner_offset, depth)?;
5690                    } else {
5691                        unreachable!()
5692                    }
5693                }
5694                7 => {
5695                    #[allow(irrefutable_let_patterns)]
5696                    if let State::DeferReboot(_) = self {
5697                        // Do nothing, read the value into the object
5698                    } else {
5699                        // Initialize `self` to the right variant
5700                        *self = State::DeferReboot(fidl::new_empty!(DeferRebootData, D));
5701                    }
5702                    #[allow(irrefutable_let_patterns)]
5703                    if let State::DeferReboot(ref mut val) = self {
5704                        fidl::decode!(DeferRebootData, D, val, decoder, _inner_offset, depth)?;
5705                    } else {
5706                        unreachable!()
5707                    }
5708                }
5709                8 => {
5710                    #[allow(irrefutable_let_patterns)]
5711                    if let State::Complete(_) = self {
5712                        // Do nothing, read the value into the object
5713                    } else {
5714                        // Initialize `self` to the right variant
5715                        *self = State::Complete(fidl::new_empty!(CompleteData, D));
5716                    }
5717                    #[allow(irrefutable_let_patterns)]
5718                    if let State::Complete(ref mut val) = self {
5719                        fidl::decode!(CompleteData, D, val, decoder, _inner_offset, depth)?;
5720                    } else {
5721                        unreachable!()
5722                    }
5723                }
5724                9 => {
5725                    #[allow(irrefutable_let_patterns)]
5726                    if let State::FailPrepare(_) = self {
5727                        // Do nothing, read the value into the object
5728                    } else {
5729                        // Initialize `self` to the right variant
5730                        *self = State::FailPrepare(fidl::new_empty!(FailPrepareData, D));
5731                    }
5732                    #[allow(irrefutable_let_patterns)]
5733                    if let State::FailPrepare(ref mut val) = self {
5734                        fidl::decode!(FailPrepareData, D, val, decoder, _inner_offset, depth)?;
5735                    } else {
5736                        unreachable!()
5737                    }
5738                }
5739                10 => {
5740                    #[allow(irrefutable_let_patterns)]
5741                    if let State::FailStage(_) = self {
5742                        // Do nothing, read the value into the object
5743                    } else {
5744                        // Initialize `self` to the right variant
5745                        *self = State::FailStage(fidl::new_empty!(FailStageData, D));
5746                    }
5747                    #[allow(irrefutable_let_patterns)]
5748                    if let State::FailStage(ref mut val) = self {
5749                        fidl::decode!(FailStageData, D, val, decoder, _inner_offset, depth)?;
5750                    } else {
5751                        unreachable!()
5752                    }
5753                }
5754                11 => {
5755                    #[allow(irrefutable_let_patterns)]
5756                    if let State::FailFetch(_) = self {
5757                        // Do nothing, read the value into the object
5758                    } else {
5759                        // Initialize `self` to the right variant
5760                        *self = State::FailFetch(fidl::new_empty!(FailFetchData, D));
5761                    }
5762                    #[allow(irrefutable_let_patterns)]
5763                    if let State::FailFetch(ref mut val) = self {
5764                        fidl::decode!(FailFetchData, D, val, decoder, _inner_offset, depth)?;
5765                    } else {
5766                        unreachable!()
5767                    }
5768                }
5769                12 => {
5770                    #[allow(irrefutable_let_patterns)]
5771                    if let State::FailCommit(_) = self {
5772                        // Do nothing, read the value into the object
5773                    } else {
5774                        // Initialize `self` to the right variant
5775                        *self = State::FailCommit(fidl::new_empty!(FailCommitData, D));
5776                    }
5777                    #[allow(irrefutable_let_patterns)]
5778                    if let State::FailCommit(ref mut val) = self {
5779                        fidl::decode!(FailCommitData, D, val, decoder, _inner_offset, depth)?;
5780                    } else {
5781                        unreachable!()
5782                    }
5783                }
5784                13 => {
5785                    #[allow(irrefutable_let_patterns)]
5786                    if let State::Canceled(_) = self {
5787                        // Do nothing, read the value into the object
5788                    } else {
5789                        // Initialize `self` to the right variant
5790                        *self = State::Canceled(fidl::new_empty!(CanceledData, D));
5791                    }
5792                    #[allow(irrefutable_let_patterns)]
5793                    if let State::Canceled(ref mut val) = self {
5794                        fidl::decode!(CanceledData, D, val, decoder, _inner_offset, depth)?;
5795                    } else {
5796                        unreachable!()
5797                    }
5798                }
5799                ordinal => panic!("unexpected ordinal {:?}", ordinal),
5800            }
5801            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5802                return Err(fidl::Error::InvalidNumBytesInEnvelope);
5803            }
5804            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5805                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5806            }
5807            Ok(())
5808        }
5809    }
5810}