fidl_fuchsia_sys2__common/
fidl_fuchsia_sys2__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// The maximum length of an instance ID.
12/// An instance ID is a 256-bit identifier, which when encoded
13/// in hex notation is 64 characters long.
14pub const MAX_INSTANCE_ID_LENGTH: u32 = 64;
15
16/// The maximum length of the human-readable start reason.
17/// This accounts for StartReason::AccessCapability which can have a length of
18/// MAX_MONIKER_LENGTH + MAX_NAME_LENGTH + 26 (4222 characters).
19pub const MAX_START_REASON: u32 = 5000;
20
21/// The maximum length of a storage instance ID.
22/// A storage instance ID is a 256-bit UUID, which when encoded
23/// in hex notation is 64 characters long.
24pub const MAX_STORAGE_ID_LENGTH: u32 = 64;
25
26/// Errors that can be returned by the ConfigOverride protocol.
27#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
28pub enum ConfigOverrideError {
29    /// Could not find an instance matching the given moniker.
30    InstanceNotFound,
31    /// The given moniker could not be parsed.
32    BadMoniker,
33    /// The given moniker matches an instance, but the instance is not resolved.
34    InstanceNotResolved,
35    /// There is no structured configuration associated with this instance.
36    NoConfig,
37    /// Could not find a structured configuration field with the given key.
38    KeyNotFound,
39    #[doc(hidden)]
40    __SourceBreaking { unknown_ordinal: u32 },
41}
42
43/// Pattern that matches an unknown `ConfigOverrideError` member.
44#[macro_export]
45macro_rules! ConfigOverrideErrorUnknown {
46    () => {
47        _
48    };
49}
50
51impl ConfigOverrideError {
52    #[inline]
53    pub fn from_primitive(prim: u32) -> Option<Self> {
54        match prim {
55            1 => Some(Self::InstanceNotFound),
56            2 => Some(Self::BadMoniker),
57            3 => Some(Self::InstanceNotResolved),
58            4 => Some(Self::NoConfig),
59            5 => Some(Self::KeyNotFound),
60            _ => None,
61        }
62    }
63
64    #[inline]
65    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
66        match prim {
67            1 => Self::InstanceNotFound,
68            2 => Self::BadMoniker,
69            3 => Self::InstanceNotResolved,
70            4 => Self::NoConfig,
71            5 => Self::KeyNotFound,
72            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
73        }
74    }
75
76    #[inline]
77    pub fn unknown() -> Self {
78        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
79    }
80
81    #[inline]
82    pub const fn into_primitive(self) -> u32 {
83        match self {
84            Self::InstanceNotFound => 1,
85            Self::BadMoniker => 2,
86            Self::InstanceNotResolved => 3,
87            Self::NoConfig => 4,
88            Self::KeyNotFound => 5,
89            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
90        }
91    }
92
93    #[inline]
94    pub fn is_unknown(&self) -> bool {
95        match self {
96            Self::__SourceBreaking { unknown_ordinal: _ } => true,
97            _ => false,
98        }
99    }
100}
101
102/// Errors that can be returned by the ConnectToStorageAdmin call.
103#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
104pub enum ConnectToStorageAdminError {
105    /// Could not find an instance matching the given moniker.
106    InstanceNotFound,
107    /// The given moniker could not be parsed.
108    BadMoniker,
109    /// The instance does not define a storage capability with the given name.
110    StorageNotFound,
111    /// This operation requires the instance to be resolved.
112    InstanceNotResolved,
113    /// The given storage capability could not be parsed.
114    BadCapability,
115    #[doc(hidden)]
116    __SourceBreaking { unknown_ordinal: u32 },
117}
118
119/// Pattern that matches an unknown `ConnectToStorageAdminError` member.
120#[macro_export]
121macro_rules! ConnectToStorageAdminErrorUnknown {
122    () => {
123        _
124    };
125}
126
127impl ConnectToStorageAdminError {
128    #[inline]
129    pub fn from_primitive(prim: u32) -> Option<Self> {
130        match prim {
131            1 => Some(Self::InstanceNotFound),
132            2 => Some(Self::BadMoniker),
133            3 => Some(Self::StorageNotFound),
134            4 => Some(Self::InstanceNotResolved),
135            5 => Some(Self::BadCapability),
136            _ => None,
137        }
138    }
139
140    #[inline]
141    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
142        match prim {
143            1 => Self::InstanceNotFound,
144            2 => Self::BadMoniker,
145            3 => Self::StorageNotFound,
146            4 => Self::InstanceNotResolved,
147            5 => Self::BadCapability,
148            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
149        }
150    }
151
152    #[inline]
153    pub fn unknown() -> Self {
154        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
155    }
156
157    #[inline]
158    pub const fn into_primitive(self) -> u32 {
159        match self {
160            Self::InstanceNotFound => 1,
161            Self::BadMoniker => 2,
162            Self::StorageNotFound => 3,
163            Self::InstanceNotResolved => 4,
164            Self::BadCapability => 5,
165            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
166        }
167    }
168
169    #[inline]
170    pub fn is_unknown(&self) -> bool {
171        match self {
172            Self::__SourceBreaking { unknown_ordinal: _ } => true,
173            _ => false,
174        }
175    }
176}
177
178/// Errors that can be returned by the ConstructNamespace call.
179#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
180pub enum ConstructNamespaceError {
181    /// Could not find an instance matching the given moniker.
182    InstanceNotFound,
183    /// The given moniker could not be parsed.
184    BadMoniker,
185    /// Namespace construction requires the instance to be resolved.
186    InstanceNotResolved,
187    #[doc(hidden)]
188    __SourceBreaking { unknown_ordinal: u32 },
189}
190
191/// Pattern that matches an unknown `ConstructNamespaceError` member.
192#[macro_export]
193macro_rules! ConstructNamespaceErrorUnknown {
194    () => {
195        _
196    };
197}
198
199impl ConstructNamespaceError {
200    #[inline]
201    pub fn from_primitive(prim: u32) -> Option<Self> {
202        match prim {
203            1 => Some(Self::InstanceNotFound),
204            2 => Some(Self::BadMoniker),
205            3 => Some(Self::InstanceNotResolved),
206            _ => None,
207        }
208    }
209
210    #[inline]
211    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
212        match prim {
213            1 => Self::InstanceNotFound,
214            2 => Self::BadMoniker,
215            3 => Self::InstanceNotResolved,
216            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
217        }
218    }
219
220    #[inline]
221    pub fn unknown() -> Self {
222        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
223    }
224
225    #[inline]
226    pub const fn into_primitive(self) -> u32 {
227        match self {
228            Self::InstanceNotFound => 1,
229            Self::BadMoniker => 2,
230            Self::InstanceNotResolved => 3,
231            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
232        }
233    }
234
235    #[inline]
236    pub fn is_unknown(&self) -> bool {
237        match self {
238            Self::__SourceBreaking { unknown_ordinal: _ } => true,
239            _ => false,
240        }
241    }
242}
243
244#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
245pub enum CreateError {
246    Internal,
247    InstanceNotFound,
248    InstanceAlreadyExists,
249    BadMoniker,
250    BadChildDecl,
251    CollectionNotFound,
252    BadDynamicOffer,
253    DynamicOffersForbidden,
254    EagerStartupForbidden,
255    NumberedHandlesForbidden,
256    #[doc(hidden)]
257    __SourceBreaking {
258        unknown_ordinal: u32,
259    },
260}
261
262/// Pattern that matches an unknown `CreateError` member.
263#[macro_export]
264macro_rules! CreateErrorUnknown {
265    () => {
266        _
267    };
268}
269
270impl CreateError {
271    #[inline]
272    pub fn from_primitive(prim: u32) -> Option<Self> {
273        match prim {
274            1 => Some(Self::Internal),
275            2 => Some(Self::InstanceNotFound),
276            3 => Some(Self::InstanceAlreadyExists),
277            4 => Some(Self::BadMoniker),
278            5 => Some(Self::BadChildDecl),
279            6 => Some(Self::CollectionNotFound),
280            7 => Some(Self::BadDynamicOffer),
281            8 => Some(Self::DynamicOffersForbidden),
282            9 => Some(Self::EagerStartupForbidden),
283            10 => Some(Self::NumberedHandlesForbidden),
284            _ => None,
285        }
286    }
287
288    #[inline]
289    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
290        match prim {
291            1 => Self::Internal,
292            2 => Self::InstanceNotFound,
293            3 => Self::InstanceAlreadyExists,
294            4 => Self::BadMoniker,
295            5 => Self::BadChildDecl,
296            6 => Self::CollectionNotFound,
297            7 => Self::BadDynamicOffer,
298            8 => Self::DynamicOffersForbidden,
299            9 => Self::EagerStartupForbidden,
300            10 => Self::NumberedHandlesForbidden,
301            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
302        }
303    }
304
305    #[inline]
306    pub fn unknown() -> Self {
307        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
308    }
309
310    #[inline]
311    pub const fn into_primitive(self) -> u32 {
312        match self {
313            Self::Internal => 1,
314            Self::InstanceNotFound => 2,
315            Self::InstanceAlreadyExists => 3,
316            Self::BadMoniker => 4,
317            Self::BadChildDecl => 5,
318            Self::CollectionNotFound => 6,
319            Self::BadDynamicOffer => 7,
320            Self::DynamicOffersForbidden => 8,
321            Self::EagerStartupForbidden => 9,
322            Self::NumberedHandlesForbidden => 10,
323            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
324        }
325    }
326
327    #[inline]
328    pub fn is_unknown(&self) -> bool {
329        match self {
330            Self::__SourceBreaking { unknown_ordinal: _ } => true,
331            _ => false,
332        }
333    }
334}
335
336#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
337pub enum DeclType {
338    /// The capability comes from a `use` declaration in the component's manifest.
339    /// It will be available in the namespace of the component instance.
340    Use,
341    /// The capability comes from an `expose` declaration in the component's manifest.
342    Expose,
343    /// A capability that could be either a `use` or `expose` declaration. Used
344    /// in inputs only, for fuzzy matching.
345    Any,
346    #[doc(hidden)]
347    __SourceBreaking { unknown_ordinal: u32 },
348}
349
350/// Pattern that matches an unknown `DeclType` member.
351#[macro_export]
352macro_rules! DeclTypeUnknown {
353    () => {
354        _
355    };
356}
357
358impl DeclType {
359    #[inline]
360    pub fn from_primitive(prim: u32) -> Option<Self> {
361        match prim {
362            1 => Some(Self::Use),
363            2 => Some(Self::Expose),
364            3 => Some(Self::Any),
365            _ => None,
366        }
367    }
368
369    #[inline]
370    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
371        match prim {
372            1 => Self::Use,
373            2 => Self::Expose,
374            3 => Self::Any,
375            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
376        }
377    }
378
379    #[inline]
380    pub fn unknown() -> Self {
381        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
382    }
383
384    #[inline]
385    pub const fn into_primitive(self) -> u32 {
386        match self {
387            Self::Use => 1,
388            Self::Expose => 2,
389            Self::Any => 3,
390            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
391        }
392    }
393
394    #[inline]
395    pub fn is_unknown(&self) -> bool {
396        match self {
397            Self::__SourceBreaking { unknown_ordinal: _ } => true,
398            _ => false,
399        }
400    }
401}
402
403#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
404#[repr(u32)]
405pub enum DeletionError {
406    /// There was an error sending a request to the storage provider.
407    Connection = 1,
408    /// The storage provider returned an error in response to a protocol
409    /// request.
410    Protocol = 2,
411    /// There was no storage available for deletion.
412    NoneAvailable = 3,
413    /// This call is not supported.
414    Unsupported = 4,
415}
416
417impl DeletionError {
418    #[inline]
419    pub fn from_primitive(prim: u32) -> Option<Self> {
420        match prim {
421            1 => Some(Self::Connection),
422            2 => Some(Self::Protocol),
423            3 => Some(Self::NoneAvailable),
424            4 => Some(Self::Unsupported),
425            _ => None,
426        }
427    }
428
429    #[inline]
430    pub const fn into_primitive(self) -> u32 {
431        self as u32
432    }
433}
434
435#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
436pub enum DestroyError {
437    Internal,
438    InstanceNotFound,
439    BadMoniker,
440    BadChildRef,
441    InstanceNotResolved,
442    #[doc(hidden)]
443    __SourceBreaking {
444        unknown_ordinal: u32,
445    },
446}
447
448/// Pattern that matches an unknown `DestroyError` member.
449#[macro_export]
450macro_rules! DestroyErrorUnknown {
451    () => {
452        _
453    };
454}
455
456impl DestroyError {
457    #[inline]
458    pub fn from_primitive(prim: u32) -> Option<Self> {
459        match prim {
460            1 => Some(Self::Internal),
461            2 => Some(Self::InstanceNotFound),
462            3 => Some(Self::BadMoniker),
463            4 => Some(Self::BadChildRef),
464            5 => Some(Self::InstanceNotResolved),
465            _ => None,
466        }
467    }
468
469    #[inline]
470    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
471        match prim {
472            1 => Self::Internal,
473            2 => Self::InstanceNotFound,
474            3 => Self::BadMoniker,
475            4 => Self::BadChildRef,
476            5 => Self::InstanceNotResolved,
477            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
478        }
479    }
480
481    #[inline]
482    pub fn unknown() -> Self {
483        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
484    }
485
486    #[inline]
487    pub const fn into_primitive(self) -> u32 {
488        match self {
489            Self::Internal => 1,
490            Self::InstanceNotFound => 2,
491            Self::BadMoniker => 3,
492            Self::BadChildRef => 4,
493            Self::InstanceNotResolved => 5,
494            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
495        }
496    }
497
498    #[inline]
499    pub fn is_unknown(&self) -> bool {
500        match self {
501            Self::__SourceBreaking { unknown_ordinal: _ } => true,
502            _ => false,
503        }
504    }
505}
506
507/// Errors that can be returned by the GetAllInstances call.
508#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
509pub enum GetAllInstancesError {
510    /// Could not find the scope root instance.
511    InstanceNotFound,
512    #[doc(hidden)]
513    __SourceBreaking { unknown_ordinal: u32 },
514}
515
516/// Pattern that matches an unknown `GetAllInstancesError` member.
517#[macro_export]
518macro_rules! GetAllInstancesErrorUnknown {
519    () => {
520        _
521    };
522}
523
524impl GetAllInstancesError {
525    #[inline]
526    pub fn from_primitive(prim: u32) -> Option<Self> {
527        match prim {
528            1 => Some(Self::InstanceNotFound),
529            _ => None,
530        }
531    }
532
533    #[inline]
534    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
535        match prim {
536            1 => Self::InstanceNotFound,
537            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
538        }
539    }
540
541    #[inline]
542    pub fn unknown() -> Self {
543        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
544    }
545
546    #[inline]
547    pub const fn into_primitive(self) -> u32 {
548        match self {
549            Self::InstanceNotFound => 1,
550            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
551        }
552    }
553
554    #[inline]
555    pub fn is_unknown(&self) -> bool {
556        match self {
557            Self::__SourceBreaking { unknown_ordinal: _ } => true,
558            _ => false,
559        }
560    }
561}
562
563/// Errors that can be returned by the GetManifest call.
564#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
565pub enum GetDeclarationError {
566    /// Could not find an instance matching the given moniker.
567    InstanceNotFound,
568    /// The given moniker could not be parsed.
569    BadMoniker,
570    /// The component manifest is only available when the instance is resolved.
571    InstanceNotResolved,
572    /// The component manifest could not be encoded into its persistable format.
573    EncodeFailed,
574    /// The specified collection was not found in the specified component.
575    BadChildLocation,
576    /// The specified URL could not be parsed.
577    BadUrl,
578    #[doc(hidden)]
579    __SourceBreaking { unknown_ordinal: u32 },
580}
581
582/// Pattern that matches an unknown `GetDeclarationError` member.
583#[macro_export]
584macro_rules! GetDeclarationErrorUnknown {
585    () => {
586        _
587    };
588}
589
590impl GetDeclarationError {
591    #[inline]
592    pub fn from_primitive(prim: u32) -> Option<Self> {
593        match prim {
594            1 => Some(Self::InstanceNotFound),
595            2 => Some(Self::BadMoniker),
596            3 => Some(Self::InstanceNotResolved),
597            4 => Some(Self::EncodeFailed),
598            5 => Some(Self::BadChildLocation),
599            6 => Some(Self::BadUrl),
600            _ => None,
601        }
602    }
603
604    #[inline]
605    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
606        match prim {
607            1 => Self::InstanceNotFound,
608            2 => Self::BadMoniker,
609            3 => Self::InstanceNotResolved,
610            4 => Self::EncodeFailed,
611            5 => Self::BadChildLocation,
612            6 => Self::BadUrl,
613            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
614        }
615    }
616
617    #[inline]
618    pub fn unknown() -> Self {
619        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
620    }
621
622    #[inline]
623    pub const fn into_primitive(self) -> u32 {
624        match self {
625            Self::InstanceNotFound => 1,
626            Self::BadMoniker => 2,
627            Self::InstanceNotResolved => 3,
628            Self::EncodeFailed => 4,
629            Self::BadChildLocation => 5,
630            Self::BadUrl => 6,
631            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
632        }
633    }
634
635    #[inline]
636    pub fn is_unknown(&self) -> bool {
637        match self {
638            Self::__SourceBreaking { unknown_ordinal: _ } => true,
639            _ => false,
640        }
641    }
642}
643
644/// Errors that can be returned by the GetInstance call.
645#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
646pub enum GetInstanceError {
647    /// Could not find an instance matching the given moniker.
648    InstanceNotFound,
649    /// The given moniker could not be parsed.
650    BadMoniker,
651    #[doc(hidden)]
652    __SourceBreaking { unknown_ordinal: u32 },
653}
654
655/// Pattern that matches an unknown `GetInstanceError` member.
656#[macro_export]
657macro_rules! GetInstanceErrorUnknown {
658    () => {
659        _
660    };
661}
662
663impl GetInstanceError {
664    #[inline]
665    pub fn from_primitive(prim: u32) -> Option<Self> {
666        match prim {
667            1 => Some(Self::InstanceNotFound),
668            2 => Some(Self::BadMoniker),
669            _ => None,
670        }
671    }
672
673    #[inline]
674    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
675        match prim {
676            1 => Self::InstanceNotFound,
677            2 => Self::BadMoniker,
678            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
679        }
680    }
681
682    #[inline]
683    pub fn unknown() -> Self {
684        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
685    }
686
687    #[inline]
688    pub const fn into_primitive(self) -> u32 {
689        match self {
690            Self::InstanceNotFound => 1,
691            Self::BadMoniker => 2,
692            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
693        }
694    }
695
696    #[inline]
697    pub fn is_unknown(&self) -> bool {
698        match self {
699            Self::__SourceBreaking { unknown_ordinal: _ } => true,
700            _ => false,
701        }
702    }
703}
704
705/// Errors that can be returned by the GetStructuredConfig call.
706#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
707pub enum GetStructuredConfigError {
708    /// Could not find an instance matching the given moniker.
709    InstanceNotFound,
710    /// The given moniker could not be parsed.
711    BadMoniker,
712    /// The component manifest is only available when the instance is resolved.
713    InstanceNotResolved,
714    /// There is no structured configuration associated with this instance.
715    NoConfig,
716    #[doc(hidden)]
717    __SourceBreaking { unknown_ordinal: u32 },
718}
719
720/// Pattern that matches an unknown `GetStructuredConfigError` member.
721#[macro_export]
722macro_rules! GetStructuredConfigErrorUnknown {
723    () => {
724        _
725    };
726}
727
728impl GetStructuredConfigError {
729    #[inline]
730    pub fn from_primitive(prim: u32) -> Option<Self> {
731        match prim {
732            1 => Some(Self::InstanceNotFound),
733            2 => Some(Self::BadMoniker),
734            3 => Some(Self::InstanceNotResolved),
735            4 => Some(Self::NoConfig),
736            _ => None,
737        }
738    }
739
740    #[inline]
741    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
742        match prim {
743            1 => Self::InstanceNotFound,
744            2 => Self::BadMoniker,
745            3 => Self::InstanceNotResolved,
746            4 => Self::NoConfig,
747            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
748        }
749    }
750
751    #[inline]
752    pub fn unknown() -> Self {
753        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
754    }
755
756    #[inline]
757    pub const fn into_primitive(self) -> u32 {
758        match self {
759            Self::InstanceNotFound => 1,
760            Self::BadMoniker => 2,
761            Self::InstanceNotResolved => 3,
762            Self::NoConfig => 4,
763            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
764        }
765    }
766
767    #[inline]
768    pub fn is_unknown(&self) -> bool {
769        match self {
770            Self::__SourceBreaking { unknown_ordinal: _ } => true,
771            _ => false,
772        }
773    }
774}
775
776/// The directories of an instance that can be opened by component manager.
777#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
778pub enum OpenDirType {
779    /// Served by the component's program. Rights unknown.
780    OutgoingDir,
781    /// Served by the component's runner. Rights unknown.
782    RuntimeDir,
783    /// Served by the component's resolver. Rights unknown.
784    PackageDir,
785    /// Served by component manager. Directory has RW rights.
786    ExposedDir,
787    /// Served by component manager. Directory has RW rights.
788    NamespaceDir,
789    #[doc(hidden)]
790    __SourceBreaking { unknown_ordinal: u32 },
791}
792
793/// Pattern that matches an unknown `OpenDirType` member.
794#[macro_export]
795macro_rules! OpenDirTypeUnknown {
796    () => {
797        _
798    };
799}
800
801impl OpenDirType {
802    #[inline]
803    pub fn from_primitive(prim: u32) -> Option<Self> {
804        match prim {
805            1 => Some(Self::OutgoingDir),
806            2 => Some(Self::RuntimeDir),
807            3 => Some(Self::PackageDir),
808            4 => Some(Self::ExposedDir),
809            5 => Some(Self::NamespaceDir),
810            _ => None,
811        }
812    }
813
814    #[inline]
815    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
816        match prim {
817            1 => Self::OutgoingDir,
818            2 => Self::RuntimeDir,
819            3 => Self::PackageDir,
820            4 => Self::ExposedDir,
821            5 => Self::NamespaceDir,
822            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
823        }
824    }
825
826    #[inline]
827    pub fn unknown() -> Self {
828        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
829    }
830
831    #[inline]
832    pub const fn into_primitive(self) -> u32 {
833        match self {
834            Self::OutgoingDir => 1,
835            Self::RuntimeDir => 2,
836            Self::PackageDir => 3,
837            Self::ExposedDir => 4,
838            Self::NamespaceDir => 5,
839            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
840        }
841    }
842
843    #[inline]
844    pub fn is_unknown(&self) -> bool {
845        match self {
846            Self::__SourceBreaking { unknown_ordinal: _ } => true,
847            _ => false,
848        }
849    }
850}
851
852/// Errors that can be returned by the OpenDirectory call.
853#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
854pub enum OpenError {
855    /// Could not find an instance matching the given moniker.
856    InstanceNotFound,
857    /// The given moniker could not be parsed.
858    BadMoniker,
859    /// The requested directory is available when the instance is resolved.
860    InstanceNotResolved,
861    /// The requested directory is available when the instance is running.
862    ///
863    /// Deprecation: the platform will stop emitting this error from version 19.
864    /// The component will always be started if not already.
865    InstanceNotRunning,
866    /// Component manager's open request on the directory returned a FIDL error.
867    FidlError,
868    /// The instance does not have a directory of this type.
869    NoSuchDir,
870    /// The given directory type could not be parsed.
871    BadDirType,
872    /// The given path could not be parsed by component manager.
873    BadPath,
874    /// Serving the requested directory requires starting the instance, but the
875    /// instance failed to start.
876    InstanceFailedToStart,
877    /// Instance matching moniker was destroyed.
878    InstanceDestroyed,
879    #[doc(hidden)]
880    __SourceBreaking { unknown_ordinal: u32 },
881}
882
883/// Pattern that matches an unknown `OpenError` member.
884#[macro_export]
885macro_rules! OpenErrorUnknown {
886    () => {
887        _
888    };
889}
890
891impl OpenError {
892    #[inline]
893    pub fn from_primitive(prim: u32) -> Option<Self> {
894        match prim {
895            1 => Some(Self::InstanceNotFound),
896            2 => Some(Self::BadMoniker),
897            3 => Some(Self::InstanceNotResolved),
898            4 => Some(Self::InstanceNotRunning),
899            5 => Some(Self::FidlError),
900            6 => Some(Self::NoSuchDir),
901            7 => Some(Self::BadDirType),
902            8 => Some(Self::BadPath),
903            9 => Some(Self::InstanceFailedToStart),
904            10 => Some(Self::InstanceDestroyed),
905            _ => None,
906        }
907    }
908
909    #[inline]
910    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
911        match prim {
912            1 => Self::InstanceNotFound,
913            2 => Self::BadMoniker,
914            3 => Self::InstanceNotResolved,
915            4 => Self::InstanceNotRunning,
916            5 => Self::FidlError,
917            6 => Self::NoSuchDir,
918            7 => Self::BadDirType,
919            8 => Self::BadPath,
920            9 => Self::InstanceFailedToStart,
921            10 => Self::InstanceDestroyed,
922            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
923        }
924    }
925
926    #[inline]
927    pub fn unknown() -> Self {
928        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
929    }
930
931    #[inline]
932    pub const fn into_primitive(self) -> u32 {
933        match self {
934            Self::InstanceNotFound => 1,
935            Self::BadMoniker => 2,
936            Self::InstanceNotResolved => 3,
937            Self::InstanceNotRunning => 4,
938            Self::FidlError => 5,
939            Self::NoSuchDir => 6,
940            Self::BadDirType => 7,
941            Self::BadPath => 8,
942            Self::InstanceFailedToStart => 9,
943            Self::InstanceDestroyed => 10,
944            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
945        }
946    }
947
948    #[inline]
949    pub fn is_unknown(&self) -> bool {
950        match self {
951            Self::__SourceBreaking { unknown_ordinal: _ } => true,
952            _ => false,
953        }
954    }
955}
956
957/// Errors that can be returned by the RealmQuery API.
958#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
959pub enum RealmQueryError {
960    /// Could not find an instance matching the given moniker.
961    InstanceNotFound,
962    /// The given moniker could not be parsed.
963    BadMoniker,
964    #[doc(hidden)]
965    __SourceBreaking { unknown_ordinal: u32 },
966}
967
968/// Pattern that matches an unknown `RealmQueryError` member.
969#[macro_export]
970macro_rules! RealmQueryErrorUnknown {
971    () => {
972        _
973    };
974}
975
976impl RealmQueryError {
977    #[inline]
978    pub fn from_primitive(prim: u32) -> Option<Self> {
979        match prim {
980            1 => Some(Self::InstanceNotFound),
981            2 => Some(Self::BadMoniker),
982            _ => None,
983        }
984    }
985
986    #[inline]
987    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
988        match prim {
989            1 => Self::InstanceNotFound,
990            2 => Self::BadMoniker,
991            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
992        }
993    }
994
995    #[inline]
996    pub fn unknown() -> Self {
997        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
998    }
999
1000    #[inline]
1001    pub const fn into_primitive(self) -> u32 {
1002        match self {
1003            Self::InstanceNotFound => 1,
1004            Self::BadMoniker => 2,
1005            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1006        }
1007    }
1008
1009    #[inline]
1010    pub fn is_unknown(&self) -> bool {
1011        match self {
1012            Self::__SourceBreaking { unknown_ordinal: _ } => true,
1013            _ => false,
1014        }
1015    }
1016}
1017
1018#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1019pub enum ResolveError {
1020    Internal,
1021    InstanceNotFound,
1022    BadMoniker,
1023    PackageNotFound,
1024    ManifestNotFound,
1025    PolicyError,
1026    #[doc(hidden)]
1027    __SourceBreaking {
1028        unknown_ordinal: u32,
1029    },
1030}
1031
1032/// Pattern that matches an unknown `ResolveError` member.
1033#[macro_export]
1034macro_rules! ResolveErrorUnknown {
1035    () => {
1036        _
1037    };
1038}
1039
1040impl ResolveError {
1041    #[inline]
1042    pub fn from_primitive(prim: u32) -> Option<Self> {
1043        match prim {
1044            1 => Some(Self::Internal),
1045            2 => Some(Self::InstanceNotFound),
1046            3 => Some(Self::BadMoniker),
1047            4 => Some(Self::PackageNotFound),
1048            5 => Some(Self::ManifestNotFound),
1049            6 => Some(Self::PolicyError),
1050            _ => None,
1051        }
1052    }
1053
1054    #[inline]
1055    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1056        match prim {
1057            1 => Self::Internal,
1058            2 => Self::InstanceNotFound,
1059            3 => Self::BadMoniker,
1060            4 => Self::PackageNotFound,
1061            5 => Self::ManifestNotFound,
1062            6 => Self::PolicyError,
1063            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1064        }
1065    }
1066
1067    #[inline]
1068    pub fn unknown() -> Self {
1069        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1070    }
1071
1072    #[inline]
1073    pub const fn into_primitive(self) -> u32 {
1074        match self {
1075            Self::Internal => 1,
1076            Self::InstanceNotFound => 2,
1077            Self::BadMoniker => 3,
1078            Self::PackageNotFound => 4,
1079            Self::ManifestNotFound => 5,
1080            Self::PolicyError => 6,
1081            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1082        }
1083    }
1084
1085    #[inline]
1086    pub fn is_unknown(&self) -> bool {
1087        match self {
1088            Self::__SourceBreaking { unknown_ordinal: _ } => true,
1089            _ => false,
1090        }
1091    }
1092}
1093
1094#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1095pub enum RouteOutcome {
1096    /// Routing succeeded and returned a capability.
1097    Success,
1098    /// Routing terminated in a `void` source. This is a form of success but it's exposed as
1099    /// its own state so tooling can report it.
1100    Void,
1101    /// Routing failed. This will be the state iff `RouteReport.error` is set.
1102    Failed,
1103    #[doc(hidden)]
1104    __SourceBreaking { unknown_ordinal: u32 },
1105}
1106
1107/// Pattern that matches an unknown `RouteOutcome` member.
1108#[macro_export]
1109macro_rules! RouteOutcomeUnknown {
1110    () => {
1111        _
1112    };
1113}
1114
1115impl RouteOutcome {
1116    #[inline]
1117    pub fn from_primitive(prim: u32) -> Option<Self> {
1118        match prim {
1119            1 => Some(Self::Success),
1120            2 => Some(Self::Void),
1121            3 => Some(Self::Failed),
1122            _ => None,
1123        }
1124    }
1125
1126    #[inline]
1127    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1128        match prim {
1129            1 => Self::Success,
1130            2 => Self::Void,
1131            3 => Self::Failed,
1132            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1133        }
1134    }
1135
1136    #[inline]
1137    pub fn unknown() -> Self {
1138        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1139    }
1140
1141    #[inline]
1142    pub const fn into_primitive(self) -> u32 {
1143        match self {
1144            Self::Success => 1,
1145            Self::Void => 2,
1146            Self::Failed => 3,
1147            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1148        }
1149    }
1150
1151    #[inline]
1152    pub fn is_unknown(&self) -> bool {
1153        match self {
1154            Self::__SourceBreaking { unknown_ordinal: _ } => true,
1155            _ => false,
1156        }
1157    }
1158}
1159
1160/// Errors for RouteValidator
1161#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1162pub enum RouteValidatorError {
1163    /// An unexpected error occurred.
1164    Internal,
1165    /// At least one argument had an invalid format.
1166    InvalidArguments,
1167    /// The component instance was not found.
1168    InstanceNotFound,
1169    /// The component instance was not resolved.
1170    InstanceNotResolved,
1171    #[doc(hidden)]
1172    __SourceBreaking { unknown_ordinal: u32 },
1173}
1174
1175/// Pattern that matches an unknown `RouteValidatorError` member.
1176#[macro_export]
1177macro_rules! RouteValidatorErrorUnknown {
1178    () => {
1179        _
1180    };
1181}
1182
1183impl RouteValidatorError {
1184    #[inline]
1185    pub fn from_primitive(prim: u32) -> Option<Self> {
1186        match prim {
1187            1 => Some(Self::Internal),
1188            2 => Some(Self::InvalidArguments),
1189            3 => Some(Self::InstanceNotFound),
1190            4 => Some(Self::InstanceNotResolved),
1191            _ => None,
1192        }
1193    }
1194
1195    #[inline]
1196    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1197        match prim {
1198            1 => Self::Internal,
1199            2 => Self::InvalidArguments,
1200            3 => Self::InstanceNotFound,
1201            4 => Self::InstanceNotResolved,
1202            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1203        }
1204    }
1205
1206    #[inline]
1207    pub fn unknown() -> Self {
1208        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1209    }
1210
1211    #[inline]
1212    pub const fn into_primitive(self) -> u32 {
1213        match self {
1214            Self::Internal => 1,
1215            Self::InvalidArguments => 2,
1216            Self::InstanceNotFound => 3,
1217            Self::InstanceNotResolved => 4,
1218            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1219        }
1220    }
1221
1222    #[inline]
1223    pub fn is_unknown(&self) -> bool {
1224        match self {
1225            Self::__SourceBreaking { unknown_ordinal: _ } => true,
1226            _ => false,
1227        }
1228    }
1229}
1230
1231#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1232pub enum StartError {
1233    Internal,
1234    InstanceNotFound,
1235    BadMoniker,
1236    PackageNotFound,
1237    ManifestNotFound,
1238    PolicyError,
1239    InvalidArguments,
1240    #[doc(hidden)]
1241    __SourceBreaking {
1242        unknown_ordinal: u32,
1243    },
1244}
1245
1246/// Pattern that matches an unknown `StartError` member.
1247#[macro_export]
1248macro_rules! StartErrorUnknown {
1249    () => {
1250        _
1251    };
1252}
1253
1254impl StartError {
1255    #[inline]
1256    pub fn from_primitive(prim: u32) -> Option<Self> {
1257        match prim {
1258            1 => Some(Self::Internal),
1259            2 => Some(Self::InstanceNotFound),
1260            3 => Some(Self::BadMoniker),
1261            4 => Some(Self::PackageNotFound),
1262            5 => Some(Self::ManifestNotFound),
1263            6 => Some(Self::PolicyError),
1264            7 => Some(Self::InvalidArguments),
1265            _ => None,
1266        }
1267    }
1268
1269    #[inline]
1270    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1271        match prim {
1272            1 => Self::Internal,
1273            2 => Self::InstanceNotFound,
1274            3 => Self::BadMoniker,
1275            4 => Self::PackageNotFound,
1276            5 => Self::ManifestNotFound,
1277            6 => Self::PolicyError,
1278            7 => Self::InvalidArguments,
1279            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1280        }
1281    }
1282
1283    #[inline]
1284    pub fn unknown() -> Self {
1285        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1286    }
1287
1288    #[inline]
1289    pub const fn into_primitive(self) -> u32 {
1290        match self {
1291            Self::Internal => 1,
1292            Self::InstanceNotFound => 2,
1293            Self::BadMoniker => 3,
1294            Self::PackageNotFound => 4,
1295            Self::ManifestNotFound => 5,
1296            Self::PolicyError => 6,
1297            Self::InvalidArguments => 7,
1298            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1299        }
1300    }
1301
1302    #[inline]
1303    pub fn is_unknown(&self) -> bool {
1304        match self {
1305            Self::__SourceBreaking { unknown_ordinal: _ } => true,
1306            _ => false,
1307        }
1308    }
1309}
1310
1311#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1312#[repr(u32)]
1313pub enum StatusError {
1314    /// The storage provider returned an error to a request or the connection
1315    /// to the provider unexpectedly closed.
1316    Provider = 1,
1317    /// Information returned by the storage provider appears to be invalid.
1318    ResponseInvalid = 2,
1319    /// A call to the storage provider succeeded, but it returned unexpectedly
1320    /// empty data.
1321    StatusUnknown = 3,
1322    /// This call is not supported.
1323    Unsupported = 4,
1324}
1325
1326impl StatusError {
1327    #[inline]
1328    pub fn from_primitive(prim: u32) -> Option<Self> {
1329        match prim {
1330            1 => Some(Self::Provider),
1331            2 => Some(Self::ResponseInvalid),
1332            3 => Some(Self::StatusUnknown),
1333            4 => Some(Self::Unsupported),
1334            _ => None,
1335        }
1336    }
1337
1338    #[inline]
1339    pub const fn into_primitive(self) -> u32 {
1340        self as u32
1341    }
1342}
1343
1344#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1345pub enum StopError {
1346    Internal,
1347    InstanceNotFound,
1348    BadMoniker,
1349    #[doc(hidden)]
1350    __SourceBreaking {
1351        unknown_ordinal: u32,
1352    },
1353}
1354
1355/// Pattern that matches an unknown `StopError` member.
1356#[macro_export]
1357macro_rules! StopErrorUnknown {
1358    () => {
1359        _
1360    };
1361}
1362
1363impl StopError {
1364    #[inline]
1365    pub fn from_primitive(prim: u32) -> Option<Self> {
1366        match prim {
1367            1 => Some(Self::Internal),
1368            2 => Some(Self::InstanceNotFound),
1369            3 => Some(Self::BadMoniker),
1370            _ => None,
1371        }
1372    }
1373
1374    #[inline]
1375    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1376        match prim {
1377            1 => Self::Internal,
1378            2 => Self::InstanceNotFound,
1379            3 => Self::BadMoniker,
1380            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1381        }
1382    }
1383
1384    #[inline]
1385    pub fn unknown() -> Self {
1386        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1387    }
1388
1389    #[inline]
1390    pub const fn into_primitive(self) -> u32 {
1391        match self {
1392            Self::Internal => 1,
1393            Self::InstanceNotFound => 2,
1394            Self::BadMoniker => 3,
1395            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1396        }
1397    }
1398
1399    #[inline]
1400    pub fn is_unknown(&self) -> bool {
1401        match self {
1402            Self::__SourceBreaking { unknown_ordinal: _ } => true,
1403            _ => false,
1404        }
1405    }
1406}
1407
1408#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1409pub enum UnresolveError {
1410    Internal,
1411    InstanceNotFound,
1412    BadMoniker,
1413    #[doc(hidden)]
1414    __SourceBreaking {
1415        unknown_ordinal: u32,
1416    },
1417}
1418
1419/// Pattern that matches an unknown `UnresolveError` member.
1420#[macro_export]
1421macro_rules! UnresolveErrorUnknown {
1422    () => {
1423        _
1424    };
1425}
1426
1427impl UnresolveError {
1428    #[inline]
1429    pub fn from_primitive(prim: u32) -> Option<Self> {
1430        match prim {
1431            1 => Some(Self::Internal),
1432            2 => Some(Self::InstanceNotFound),
1433            3 => Some(Self::BadMoniker),
1434            _ => None,
1435        }
1436    }
1437
1438    #[inline]
1439    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1440        match prim {
1441            1 => Self::Internal,
1442            2 => Self::InstanceNotFound,
1443            3 => Self::BadMoniker,
1444            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1445        }
1446    }
1447
1448    #[inline]
1449    pub fn unknown() -> Self {
1450        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1451    }
1452
1453    #[inline]
1454    pub const fn into_primitive(self) -> u32 {
1455        match self {
1456            Self::Internal => 1,
1457            Self::InstanceNotFound => 2,
1458            Self::BadMoniker => 3,
1459            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1460        }
1461    }
1462
1463    #[inline]
1464    pub fn is_unknown(&self) -> bool {
1465        match self {
1466            Self::__SourceBreaking { unknown_ordinal: _ } => true,
1467            _ => false,
1468        }
1469    }
1470}
1471
1472#[derive(Clone, Debug, PartialEq)]
1473pub struct ConfigOverrideSetStructuredConfigRequest {
1474    /// The moniker of the component that should use the structured config
1475    /// override.  This moniker is relative to the realm that uses this
1476    /// protocol.
1477    pub moniker: String,
1478    pub fields: Vec<fidl_fuchsia_component_decl__common::ConfigOverride>,
1479}
1480
1481impl fidl::Persistable for ConfigOverrideSetStructuredConfigRequest {}
1482
1483#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1484pub struct ConfigOverrideUnsetStructuredConfigRequest {
1485    /// The moniker of the component that should use the structured config
1486    /// override.  This moniker is relative to the realm that uses this
1487    /// protocol.
1488    pub moniker: String,
1489}
1490
1491impl fidl::Persistable for ConfigOverrideUnsetStructuredConfigRequest {}
1492
1493#[derive(Clone, Debug, PartialEq)]
1494pub struct CrashIntrospectFindComponentByThreadKoidResponse {
1495    pub info: ComponentCrashInfo,
1496}
1497
1498impl fidl::Persistable for CrashIntrospectFindComponentByThreadKoidResponse {}
1499
1500#[derive(Clone, Debug, PartialEq)]
1501pub struct InstanceIteratorNextResponse {
1502    pub infos: Vec<Instance>,
1503}
1504
1505impl fidl::Persistable for InstanceIteratorNextResponse {}
1506
1507#[derive(Clone, Debug, PartialEq)]
1508pub struct LifecycleControllerDestroyInstanceRequest {
1509    pub parent_moniker: String,
1510    pub child: fidl_fuchsia_component_decl__common::ChildRef,
1511}
1512
1513impl fidl::Persistable for LifecycleControllerDestroyInstanceRequest {}
1514
1515#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1516pub struct LifecycleControllerResolveInstanceRequest {
1517    pub moniker: String,
1518}
1519
1520impl fidl::Persistable for LifecycleControllerResolveInstanceRequest {}
1521
1522#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1523pub struct LifecycleControllerStopInstanceRequest {
1524    pub moniker: String,
1525}
1526
1527impl fidl::Persistable for LifecycleControllerStopInstanceRequest {}
1528
1529#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1530pub struct LifecycleControllerUnresolveInstanceRequest {
1531    pub moniker: String,
1532}
1533
1534impl fidl::Persistable for LifecycleControllerUnresolveInstanceRequest {}
1535
1536#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1537pub struct ManifestBytesIteratorNextResponse {
1538    pub infos: Vec<u8>,
1539}
1540
1541impl fidl::Persistable for ManifestBytesIteratorNextResponse {}
1542
1543#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1544pub struct RealmQueryConstructNamespaceRequest {
1545    pub moniker: String,
1546}
1547
1548impl fidl::Persistable for RealmQueryConstructNamespaceRequest {}
1549
1550#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1551pub struct RealmQueryGetInstanceRequest {
1552    pub moniker: String,
1553}
1554
1555impl fidl::Persistable for RealmQueryGetInstanceRequest {}
1556
1557#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1558pub struct RealmQueryGetManifestRequest {
1559    pub moniker: String,
1560}
1561
1562impl fidl::Persistable for RealmQueryGetManifestRequest {}
1563
1564#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1565pub struct RealmQueryGetResolvedDeclarationRequest {
1566    pub moniker: String,
1567}
1568
1569impl fidl::Persistable for RealmQueryGetResolvedDeclarationRequest {}
1570
1571#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1572pub struct RealmQueryGetStructuredConfigRequest {
1573    pub moniker: String,
1574}
1575
1576impl fidl::Persistable for RealmQueryGetStructuredConfigRequest {}
1577
1578#[derive(Clone, Debug, PartialEq)]
1579pub struct RealmQueryResolveDeclarationRequest {
1580    pub parent: String,
1581    pub child_location: ChildLocation,
1582    pub url: String,
1583}
1584
1585impl fidl::Persistable for RealmQueryResolveDeclarationRequest {}
1586
1587#[derive(Clone, Debug, PartialEq)]
1588pub struct RealmQueryGetInstanceResponse {
1589    pub instance: Instance,
1590}
1591
1592impl fidl::Persistable for RealmQueryGetInstanceResponse {}
1593
1594#[derive(Clone, Debug, PartialEq)]
1595pub struct RealmQueryGetStructuredConfigResponse {
1596    pub config: fidl_fuchsia_component_decl__common::ResolvedConfig,
1597}
1598
1599impl fidl::Persistable for RealmQueryGetStructuredConfigResponse {}
1600
1601/// A capability in a target component to route to the source.
1602#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1603pub struct RouteTarget {
1604    /// The capability name to match (this is not the path). Supports fuzzy
1605    /// matching by substring.
1606    pub name: String,
1607    /// Whether the capability is a `use`d by the component or `expose`d
1608    /// from it.
1609    pub decl_type: DeclType,
1610}
1611
1612impl fidl::Persistable for RouteTarget {}
1613
1614#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1615pub struct RouteValidatorRouteRequest {
1616    /// The target component with the capability to route.
1617    pub moniker: String,
1618    /// The target capabilites to route (i.e., uses or exposes)
1619    pub targets: Vec<RouteTarget>,
1620}
1621
1622impl fidl::Persistable for RouteValidatorRouteRequest {}
1623
1624#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1625pub struct RouteValidatorValidateRequest {
1626    pub moniker: String,
1627}
1628
1629impl fidl::Persistable for RouteValidatorValidateRequest {}
1630
1631#[derive(Clone, Debug, PartialEq)]
1632pub struct RouteValidatorRouteResponse {
1633    pub reports: Vec<RouteReport>,
1634}
1635
1636impl fidl::Persistable for RouteValidatorRouteResponse {}
1637
1638#[derive(Clone, Debug, PartialEq)]
1639pub struct RouteValidatorValidateResponse {
1640    pub reports: Vec<RouteReport>,
1641}
1642
1643impl fidl::Persistable for RouteValidatorValidateResponse {}
1644
1645#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1646pub struct StorageAdminDeleteComponentStorageRequest {
1647    pub relative_moniker: String,
1648}
1649
1650impl fidl::Persistable for StorageAdminDeleteComponentStorageRequest {}
1651
1652#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1653pub struct StorageIteratorNextResponse {
1654    pub relative_monikers: Vec<String>,
1655}
1656
1657impl fidl::Persistable for StorageIteratorNextResponse {}
1658
1659/// Information stored when a thread crashes.
1660#[derive(Clone, Debug, Default, PartialEq)]
1661pub struct ComponentCrashInfo {
1662    pub url: Option<String>,
1663    pub moniker: Option<String>,
1664    #[doc(hidden)]
1665    pub __source_breaking: fidl::marker::SourceBreaking,
1666}
1667
1668impl fidl::Persistable for ComponentCrashInfo {}
1669
1670/// Information about the execution state of a component instance.
1671#[derive(Clone, Debug, Default, PartialEq)]
1672pub struct ExecutionInfo {
1673    /// The human-readable explanation for why this instance was started.
1674    pub start_reason: Option<String>,
1675    #[doc(hidden)]
1676    pub __source_breaking: fidl::marker::SourceBreaking,
1677}
1678
1679impl fidl::Persistable for ExecutionInfo {}
1680
1681/// Describes a component instance under a realm.
1682///
1683/// Note: This structure is expected to fit in a single Zircon channel message.
1684///       Do not add fields that have the potential to violate that constraint.
1685///       Prefer to create dedicated methods and iterators instead.
1686#[derive(Clone, Debug, Default, PartialEq)]
1687pub struct Instance {
1688    /// The path to this instance relative to the scope root.
1689    pub moniker: Option<String>,
1690    /// The URL of the component manifest for this instance.
1691    pub url: Option<String>,
1692    /// The stable identifier for this instance, if one exists.
1693    pub instance_id: Option<String>,
1694    /// Information about the resolved state of a component instance.
1695    /// If the component is not resolved, this field is not set.
1696    pub resolved_info: Option<ResolvedInfo>,
1697    /// The component's environment name as defined by its parent.
1698    pub environment: Option<String>,
1699    #[doc(hidden)]
1700    pub __source_breaking: fidl::marker::SourceBreaking,
1701}
1702
1703impl fidl::Persistable for Instance {}
1704
1705/// Information about the resolved state of a component instance.
1706#[derive(Clone, Debug, Default, PartialEq)]
1707pub struct ResolvedInfo {
1708    /// The resolved URL of this instance.
1709    pub resolved_url: Option<String>,
1710    /// Information about the execution state of a component instance.
1711    /// If the component is not running, this field is not set.
1712    pub execution_info: Option<ExecutionInfo>,
1713    #[doc(hidden)]
1714    pub __source_breaking: fidl::marker::SourceBreaking,
1715}
1716
1717impl fidl::Persistable for ResolvedInfo {}
1718
1719/// Routing error for a particular capability.
1720#[derive(Clone, Debug, Default, PartialEq)]
1721pub struct RouteError {
1722    /// A human-readable explanation of the routing error.
1723    pub summary: Option<String>,
1724    #[doc(hidden)]
1725    pub __source_breaking: fidl::marker::SourceBreaking,
1726}
1727
1728impl fidl::Persistable for RouteError {}
1729
1730/// Routing result for a particular capability.
1731#[derive(Clone, Debug, Default, PartialEq)]
1732pub struct RouteReport {
1733    /// The capability whose routing was attempted.
1734    pub capability: Option<String>,
1735    /// Type of capability declaration
1736    pub decl_type: Option<DeclType>,
1737    /// Describes the error that occurred from routing this capability.
1738    /// This field is not present if routing succeeded.
1739    pub error: Option<RouteError>,
1740    /// The moniker of the source component.
1741    pub source_moniker: Option<String>,
1742    /// Metadata about the instances in a service. Populated only for aggregated services.
1743    pub service_instances: Option<Vec<ServiceInstance>>,
1744    /// The requested level of availability of the capability.
1745    pub availability: Option<fidl_fuchsia_component_decl__common::Availability>,
1746    /// The overall outcome of routing.
1747    pub outcome: Option<RouteOutcome>,
1748    #[doc(hidden)]
1749    pub __source_breaking: fidl::marker::SourceBreaking,
1750}
1751
1752impl fidl::Persistable for RouteReport {}
1753
1754/// Metadata about a service instance.
1755#[derive(Clone, Debug, Default, PartialEq)]
1756pub struct ServiceInstance {
1757    /// The name of the service instance in this service directory.
1758    pub instance_name: Option<String>,
1759    /// The name of the component that serves the service instance,
1760    /// including the collection name if the component is a child.
1761    pub child_name: Option<String>,
1762    /// The name of the service instance as exposed by the child.
1763    pub child_instance_name: Option<String>,
1764    #[doc(hidden)]
1765    pub __source_breaking: fidl::marker::SourceBreaking,
1766}
1767
1768impl fidl::Persistable for ServiceInstance {}
1769
1770/// Metadata about status of the storage
1771#[derive(Clone, Debug, Default, PartialEq)]
1772pub struct StorageStatus {
1773    pub total_size: Option<u64>,
1774    pub used_size: Option<u64>,
1775    #[doc(hidden)]
1776    pub __source_breaking: fidl::marker::SourceBreaking,
1777}
1778
1779impl fidl::Persistable for StorageStatus {}
1780
1781/// Locations from which a child could be resolved under a given parent.
1782#[derive(Clone, Debug)]
1783pub enum ChildLocation {
1784    Collection(String),
1785    #[doc(hidden)]
1786    __SourceBreaking {
1787        unknown_ordinal: u64,
1788    },
1789}
1790
1791/// Pattern that matches an unknown `ChildLocation` member.
1792#[macro_export]
1793macro_rules! ChildLocationUnknown {
1794    () => {
1795        _
1796    };
1797}
1798
1799// Custom PartialEq so that unknown variants are not equal to themselves.
1800impl PartialEq for ChildLocation {
1801    fn eq(&self, other: &Self) -> bool {
1802        match (self, other) {
1803            (Self::Collection(x), Self::Collection(y)) => *x == *y,
1804            _ => false,
1805        }
1806    }
1807}
1808
1809impl ChildLocation {
1810    #[inline]
1811    pub fn ordinal(&self) -> u64 {
1812        match *self {
1813            Self::Collection(_) => 1,
1814            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1815        }
1816    }
1817
1818    #[inline]
1819    pub fn unknown_variant_for_testing() -> Self {
1820        Self::__SourceBreaking { unknown_ordinal: 0 }
1821    }
1822
1823    #[inline]
1824    pub fn is_unknown(&self) -> bool {
1825        match self {
1826            Self::__SourceBreaking { .. } => true,
1827            _ => false,
1828        }
1829    }
1830}
1831
1832impl fidl::Persistable for ChildLocation {}
1833
1834mod internal {
1835    use super::*;
1836    unsafe impl fidl::encoding::TypeMarker for ConfigOverrideError {
1837        type Owned = Self;
1838
1839        #[inline(always)]
1840        fn inline_align(_context: fidl::encoding::Context) -> usize {
1841            std::mem::align_of::<u32>()
1842        }
1843
1844        #[inline(always)]
1845        fn inline_size(_context: fidl::encoding::Context) -> usize {
1846            std::mem::size_of::<u32>()
1847        }
1848
1849        #[inline(always)]
1850        fn encode_is_copy() -> bool {
1851            false
1852        }
1853
1854        #[inline(always)]
1855        fn decode_is_copy() -> bool {
1856            false
1857        }
1858    }
1859
1860    impl fidl::encoding::ValueTypeMarker for ConfigOverrideError {
1861        type Borrowed<'a> = Self;
1862        #[inline(always)]
1863        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1864            *value
1865        }
1866    }
1867
1868    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1869        for ConfigOverrideError
1870    {
1871        #[inline]
1872        unsafe fn encode(
1873            self,
1874            encoder: &mut fidl::encoding::Encoder<'_, D>,
1875            offset: usize,
1876            _depth: fidl::encoding::Depth,
1877        ) -> fidl::Result<()> {
1878            encoder.debug_check_bounds::<Self>(offset);
1879            encoder.write_num(self.into_primitive(), offset);
1880            Ok(())
1881        }
1882    }
1883
1884    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigOverrideError {
1885        #[inline(always)]
1886        fn new_empty() -> Self {
1887            Self::unknown()
1888        }
1889
1890        #[inline]
1891        unsafe fn decode(
1892            &mut self,
1893            decoder: &mut fidl::encoding::Decoder<'_, D>,
1894            offset: usize,
1895            _depth: fidl::encoding::Depth,
1896        ) -> fidl::Result<()> {
1897            decoder.debug_check_bounds::<Self>(offset);
1898            let prim = decoder.read_num::<u32>(offset);
1899
1900            *self = Self::from_primitive_allow_unknown(prim);
1901            Ok(())
1902        }
1903    }
1904    unsafe impl fidl::encoding::TypeMarker for ConnectToStorageAdminError {
1905        type Owned = Self;
1906
1907        #[inline(always)]
1908        fn inline_align(_context: fidl::encoding::Context) -> usize {
1909            std::mem::align_of::<u32>()
1910        }
1911
1912        #[inline(always)]
1913        fn inline_size(_context: fidl::encoding::Context) -> usize {
1914            std::mem::size_of::<u32>()
1915        }
1916
1917        #[inline(always)]
1918        fn encode_is_copy() -> bool {
1919            false
1920        }
1921
1922        #[inline(always)]
1923        fn decode_is_copy() -> bool {
1924            false
1925        }
1926    }
1927
1928    impl fidl::encoding::ValueTypeMarker for ConnectToStorageAdminError {
1929        type Borrowed<'a> = Self;
1930        #[inline(always)]
1931        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1932            *value
1933        }
1934    }
1935
1936    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1937        for ConnectToStorageAdminError
1938    {
1939        #[inline]
1940        unsafe fn encode(
1941            self,
1942            encoder: &mut fidl::encoding::Encoder<'_, D>,
1943            offset: usize,
1944            _depth: fidl::encoding::Depth,
1945        ) -> fidl::Result<()> {
1946            encoder.debug_check_bounds::<Self>(offset);
1947            encoder.write_num(self.into_primitive(), offset);
1948            Ok(())
1949        }
1950    }
1951
1952    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1953        for ConnectToStorageAdminError
1954    {
1955        #[inline(always)]
1956        fn new_empty() -> Self {
1957            Self::unknown()
1958        }
1959
1960        #[inline]
1961        unsafe fn decode(
1962            &mut self,
1963            decoder: &mut fidl::encoding::Decoder<'_, D>,
1964            offset: usize,
1965            _depth: fidl::encoding::Depth,
1966        ) -> fidl::Result<()> {
1967            decoder.debug_check_bounds::<Self>(offset);
1968            let prim = decoder.read_num::<u32>(offset);
1969
1970            *self = Self::from_primitive_allow_unknown(prim);
1971            Ok(())
1972        }
1973    }
1974    unsafe impl fidl::encoding::TypeMarker for ConstructNamespaceError {
1975        type Owned = Self;
1976
1977        #[inline(always)]
1978        fn inline_align(_context: fidl::encoding::Context) -> usize {
1979            std::mem::align_of::<u32>()
1980        }
1981
1982        #[inline(always)]
1983        fn inline_size(_context: fidl::encoding::Context) -> usize {
1984            std::mem::size_of::<u32>()
1985        }
1986
1987        #[inline(always)]
1988        fn encode_is_copy() -> bool {
1989            false
1990        }
1991
1992        #[inline(always)]
1993        fn decode_is_copy() -> bool {
1994            false
1995        }
1996    }
1997
1998    impl fidl::encoding::ValueTypeMarker for ConstructNamespaceError {
1999        type Borrowed<'a> = Self;
2000        #[inline(always)]
2001        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2002            *value
2003        }
2004    }
2005
2006    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2007        for ConstructNamespaceError
2008    {
2009        #[inline]
2010        unsafe fn encode(
2011            self,
2012            encoder: &mut fidl::encoding::Encoder<'_, D>,
2013            offset: usize,
2014            _depth: fidl::encoding::Depth,
2015        ) -> fidl::Result<()> {
2016            encoder.debug_check_bounds::<Self>(offset);
2017            encoder.write_num(self.into_primitive(), offset);
2018            Ok(())
2019        }
2020    }
2021
2022    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2023        for ConstructNamespaceError
2024    {
2025        #[inline(always)]
2026        fn new_empty() -> Self {
2027            Self::unknown()
2028        }
2029
2030        #[inline]
2031        unsafe fn decode(
2032            &mut self,
2033            decoder: &mut fidl::encoding::Decoder<'_, D>,
2034            offset: usize,
2035            _depth: fidl::encoding::Depth,
2036        ) -> fidl::Result<()> {
2037            decoder.debug_check_bounds::<Self>(offset);
2038            let prim = decoder.read_num::<u32>(offset);
2039
2040            *self = Self::from_primitive_allow_unknown(prim);
2041            Ok(())
2042        }
2043    }
2044    unsafe impl fidl::encoding::TypeMarker for CreateError {
2045        type Owned = Self;
2046
2047        #[inline(always)]
2048        fn inline_align(_context: fidl::encoding::Context) -> usize {
2049            std::mem::align_of::<u32>()
2050        }
2051
2052        #[inline(always)]
2053        fn inline_size(_context: fidl::encoding::Context) -> usize {
2054            std::mem::size_of::<u32>()
2055        }
2056
2057        #[inline(always)]
2058        fn encode_is_copy() -> bool {
2059            false
2060        }
2061
2062        #[inline(always)]
2063        fn decode_is_copy() -> bool {
2064            false
2065        }
2066    }
2067
2068    impl fidl::encoding::ValueTypeMarker for CreateError {
2069        type Borrowed<'a> = Self;
2070        #[inline(always)]
2071        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2072            *value
2073        }
2074    }
2075
2076    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CreateError {
2077        #[inline]
2078        unsafe fn encode(
2079            self,
2080            encoder: &mut fidl::encoding::Encoder<'_, D>,
2081            offset: usize,
2082            _depth: fidl::encoding::Depth,
2083        ) -> fidl::Result<()> {
2084            encoder.debug_check_bounds::<Self>(offset);
2085            encoder.write_num(self.into_primitive(), offset);
2086            Ok(())
2087        }
2088    }
2089
2090    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CreateError {
2091        #[inline(always)]
2092        fn new_empty() -> Self {
2093            Self::unknown()
2094        }
2095
2096        #[inline]
2097        unsafe fn decode(
2098            &mut self,
2099            decoder: &mut fidl::encoding::Decoder<'_, D>,
2100            offset: usize,
2101            _depth: fidl::encoding::Depth,
2102        ) -> fidl::Result<()> {
2103            decoder.debug_check_bounds::<Self>(offset);
2104            let prim = decoder.read_num::<u32>(offset);
2105
2106            *self = Self::from_primitive_allow_unknown(prim);
2107            Ok(())
2108        }
2109    }
2110    unsafe impl fidl::encoding::TypeMarker for DeclType {
2111        type Owned = Self;
2112
2113        #[inline(always)]
2114        fn inline_align(_context: fidl::encoding::Context) -> usize {
2115            std::mem::align_of::<u32>()
2116        }
2117
2118        #[inline(always)]
2119        fn inline_size(_context: fidl::encoding::Context) -> usize {
2120            std::mem::size_of::<u32>()
2121        }
2122
2123        #[inline(always)]
2124        fn encode_is_copy() -> bool {
2125            false
2126        }
2127
2128        #[inline(always)]
2129        fn decode_is_copy() -> bool {
2130            false
2131        }
2132    }
2133
2134    impl fidl::encoding::ValueTypeMarker for DeclType {
2135        type Borrowed<'a> = Self;
2136        #[inline(always)]
2137        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2138            *value
2139        }
2140    }
2141
2142    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DeclType {
2143        #[inline]
2144        unsafe fn encode(
2145            self,
2146            encoder: &mut fidl::encoding::Encoder<'_, D>,
2147            offset: usize,
2148            _depth: fidl::encoding::Depth,
2149        ) -> fidl::Result<()> {
2150            encoder.debug_check_bounds::<Self>(offset);
2151            encoder.write_num(self.into_primitive(), offset);
2152            Ok(())
2153        }
2154    }
2155
2156    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeclType {
2157        #[inline(always)]
2158        fn new_empty() -> Self {
2159            Self::unknown()
2160        }
2161
2162        #[inline]
2163        unsafe fn decode(
2164            &mut self,
2165            decoder: &mut fidl::encoding::Decoder<'_, D>,
2166            offset: usize,
2167            _depth: fidl::encoding::Depth,
2168        ) -> fidl::Result<()> {
2169            decoder.debug_check_bounds::<Self>(offset);
2170            let prim = decoder.read_num::<u32>(offset);
2171
2172            *self = Self::from_primitive_allow_unknown(prim);
2173            Ok(())
2174        }
2175    }
2176    unsafe impl fidl::encoding::TypeMarker for DeletionError {
2177        type Owned = Self;
2178
2179        #[inline(always)]
2180        fn inline_align(_context: fidl::encoding::Context) -> usize {
2181            std::mem::align_of::<u32>()
2182        }
2183
2184        #[inline(always)]
2185        fn inline_size(_context: fidl::encoding::Context) -> usize {
2186            std::mem::size_of::<u32>()
2187        }
2188
2189        #[inline(always)]
2190        fn encode_is_copy() -> bool {
2191            true
2192        }
2193
2194        #[inline(always)]
2195        fn decode_is_copy() -> bool {
2196            false
2197        }
2198    }
2199
2200    impl fidl::encoding::ValueTypeMarker for DeletionError {
2201        type Borrowed<'a> = Self;
2202        #[inline(always)]
2203        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2204            *value
2205        }
2206    }
2207
2208    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DeletionError {
2209        #[inline]
2210        unsafe fn encode(
2211            self,
2212            encoder: &mut fidl::encoding::Encoder<'_, D>,
2213            offset: usize,
2214            _depth: fidl::encoding::Depth,
2215        ) -> fidl::Result<()> {
2216            encoder.debug_check_bounds::<Self>(offset);
2217            encoder.write_num(self.into_primitive(), offset);
2218            Ok(())
2219        }
2220    }
2221
2222    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeletionError {
2223        #[inline(always)]
2224        fn new_empty() -> Self {
2225            Self::Connection
2226        }
2227
2228        #[inline]
2229        unsafe fn decode(
2230            &mut self,
2231            decoder: &mut fidl::encoding::Decoder<'_, D>,
2232            offset: usize,
2233            _depth: fidl::encoding::Depth,
2234        ) -> fidl::Result<()> {
2235            decoder.debug_check_bounds::<Self>(offset);
2236            let prim = decoder.read_num::<u32>(offset);
2237
2238            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2239            Ok(())
2240        }
2241    }
2242    unsafe impl fidl::encoding::TypeMarker for DestroyError {
2243        type Owned = Self;
2244
2245        #[inline(always)]
2246        fn inline_align(_context: fidl::encoding::Context) -> usize {
2247            std::mem::align_of::<u32>()
2248        }
2249
2250        #[inline(always)]
2251        fn inline_size(_context: fidl::encoding::Context) -> usize {
2252            std::mem::size_of::<u32>()
2253        }
2254
2255        #[inline(always)]
2256        fn encode_is_copy() -> bool {
2257            false
2258        }
2259
2260        #[inline(always)]
2261        fn decode_is_copy() -> bool {
2262            false
2263        }
2264    }
2265
2266    impl fidl::encoding::ValueTypeMarker for DestroyError {
2267        type Borrowed<'a> = Self;
2268        #[inline(always)]
2269        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2270            *value
2271        }
2272    }
2273
2274    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DestroyError {
2275        #[inline]
2276        unsafe fn encode(
2277            self,
2278            encoder: &mut fidl::encoding::Encoder<'_, D>,
2279            offset: usize,
2280            _depth: fidl::encoding::Depth,
2281        ) -> fidl::Result<()> {
2282            encoder.debug_check_bounds::<Self>(offset);
2283            encoder.write_num(self.into_primitive(), offset);
2284            Ok(())
2285        }
2286    }
2287
2288    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DestroyError {
2289        #[inline(always)]
2290        fn new_empty() -> Self {
2291            Self::unknown()
2292        }
2293
2294        #[inline]
2295        unsafe fn decode(
2296            &mut self,
2297            decoder: &mut fidl::encoding::Decoder<'_, D>,
2298            offset: usize,
2299            _depth: fidl::encoding::Depth,
2300        ) -> fidl::Result<()> {
2301            decoder.debug_check_bounds::<Self>(offset);
2302            let prim = decoder.read_num::<u32>(offset);
2303
2304            *self = Self::from_primitive_allow_unknown(prim);
2305            Ok(())
2306        }
2307    }
2308    unsafe impl fidl::encoding::TypeMarker for GetAllInstancesError {
2309        type Owned = Self;
2310
2311        #[inline(always)]
2312        fn inline_align(_context: fidl::encoding::Context) -> usize {
2313            std::mem::align_of::<u32>()
2314        }
2315
2316        #[inline(always)]
2317        fn inline_size(_context: fidl::encoding::Context) -> usize {
2318            std::mem::size_of::<u32>()
2319        }
2320
2321        #[inline(always)]
2322        fn encode_is_copy() -> bool {
2323            false
2324        }
2325
2326        #[inline(always)]
2327        fn decode_is_copy() -> bool {
2328            false
2329        }
2330    }
2331
2332    impl fidl::encoding::ValueTypeMarker for GetAllInstancesError {
2333        type Borrowed<'a> = Self;
2334        #[inline(always)]
2335        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2336            *value
2337        }
2338    }
2339
2340    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2341        for GetAllInstancesError
2342    {
2343        #[inline]
2344        unsafe fn encode(
2345            self,
2346            encoder: &mut fidl::encoding::Encoder<'_, D>,
2347            offset: usize,
2348            _depth: fidl::encoding::Depth,
2349        ) -> fidl::Result<()> {
2350            encoder.debug_check_bounds::<Self>(offset);
2351            encoder.write_num(self.into_primitive(), offset);
2352            Ok(())
2353        }
2354    }
2355
2356    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetAllInstancesError {
2357        #[inline(always)]
2358        fn new_empty() -> Self {
2359            Self::unknown()
2360        }
2361
2362        #[inline]
2363        unsafe fn decode(
2364            &mut self,
2365            decoder: &mut fidl::encoding::Decoder<'_, D>,
2366            offset: usize,
2367            _depth: fidl::encoding::Depth,
2368        ) -> fidl::Result<()> {
2369            decoder.debug_check_bounds::<Self>(offset);
2370            let prim = decoder.read_num::<u32>(offset);
2371
2372            *self = Self::from_primitive_allow_unknown(prim);
2373            Ok(())
2374        }
2375    }
2376    unsafe impl fidl::encoding::TypeMarker for GetDeclarationError {
2377        type Owned = Self;
2378
2379        #[inline(always)]
2380        fn inline_align(_context: fidl::encoding::Context) -> usize {
2381            std::mem::align_of::<u32>()
2382        }
2383
2384        #[inline(always)]
2385        fn inline_size(_context: fidl::encoding::Context) -> usize {
2386            std::mem::size_of::<u32>()
2387        }
2388
2389        #[inline(always)]
2390        fn encode_is_copy() -> bool {
2391            false
2392        }
2393
2394        #[inline(always)]
2395        fn decode_is_copy() -> bool {
2396            false
2397        }
2398    }
2399
2400    impl fidl::encoding::ValueTypeMarker for GetDeclarationError {
2401        type Borrowed<'a> = Self;
2402        #[inline(always)]
2403        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2404            *value
2405        }
2406    }
2407
2408    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2409        for GetDeclarationError
2410    {
2411        #[inline]
2412        unsafe fn encode(
2413            self,
2414            encoder: &mut fidl::encoding::Encoder<'_, D>,
2415            offset: usize,
2416            _depth: fidl::encoding::Depth,
2417        ) -> fidl::Result<()> {
2418            encoder.debug_check_bounds::<Self>(offset);
2419            encoder.write_num(self.into_primitive(), offset);
2420            Ok(())
2421        }
2422    }
2423
2424    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetDeclarationError {
2425        #[inline(always)]
2426        fn new_empty() -> Self {
2427            Self::unknown()
2428        }
2429
2430        #[inline]
2431        unsafe fn decode(
2432            &mut self,
2433            decoder: &mut fidl::encoding::Decoder<'_, D>,
2434            offset: usize,
2435            _depth: fidl::encoding::Depth,
2436        ) -> fidl::Result<()> {
2437            decoder.debug_check_bounds::<Self>(offset);
2438            let prim = decoder.read_num::<u32>(offset);
2439
2440            *self = Self::from_primitive_allow_unknown(prim);
2441            Ok(())
2442        }
2443    }
2444    unsafe impl fidl::encoding::TypeMarker for GetInstanceError {
2445        type Owned = Self;
2446
2447        #[inline(always)]
2448        fn inline_align(_context: fidl::encoding::Context) -> usize {
2449            std::mem::align_of::<u32>()
2450        }
2451
2452        #[inline(always)]
2453        fn inline_size(_context: fidl::encoding::Context) -> usize {
2454            std::mem::size_of::<u32>()
2455        }
2456
2457        #[inline(always)]
2458        fn encode_is_copy() -> bool {
2459            false
2460        }
2461
2462        #[inline(always)]
2463        fn decode_is_copy() -> bool {
2464            false
2465        }
2466    }
2467
2468    impl fidl::encoding::ValueTypeMarker for GetInstanceError {
2469        type Borrowed<'a> = Self;
2470        #[inline(always)]
2471        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2472            *value
2473        }
2474    }
2475
2476    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2477        for GetInstanceError
2478    {
2479        #[inline]
2480        unsafe fn encode(
2481            self,
2482            encoder: &mut fidl::encoding::Encoder<'_, D>,
2483            offset: usize,
2484            _depth: fidl::encoding::Depth,
2485        ) -> fidl::Result<()> {
2486            encoder.debug_check_bounds::<Self>(offset);
2487            encoder.write_num(self.into_primitive(), offset);
2488            Ok(())
2489        }
2490    }
2491
2492    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetInstanceError {
2493        #[inline(always)]
2494        fn new_empty() -> Self {
2495            Self::unknown()
2496        }
2497
2498        #[inline]
2499        unsafe fn decode(
2500            &mut self,
2501            decoder: &mut fidl::encoding::Decoder<'_, D>,
2502            offset: usize,
2503            _depth: fidl::encoding::Depth,
2504        ) -> fidl::Result<()> {
2505            decoder.debug_check_bounds::<Self>(offset);
2506            let prim = decoder.read_num::<u32>(offset);
2507
2508            *self = Self::from_primitive_allow_unknown(prim);
2509            Ok(())
2510        }
2511    }
2512    unsafe impl fidl::encoding::TypeMarker for GetStructuredConfigError {
2513        type Owned = Self;
2514
2515        #[inline(always)]
2516        fn inline_align(_context: fidl::encoding::Context) -> usize {
2517            std::mem::align_of::<u32>()
2518        }
2519
2520        #[inline(always)]
2521        fn inline_size(_context: fidl::encoding::Context) -> usize {
2522            std::mem::size_of::<u32>()
2523        }
2524
2525        #[inline(always)]
2526        fn encode_is_copy() -> bool {
2527            false
2528        }
2529
2530        #[inline(always)]
2531        fn decode_is_copy() -> bool {
2532            false
2533        }
2534    }
2535
2536    impl fidl::encoding::ValueTypeMarker for GetStructuredConfigError {
2537        type Borrowed<'a> = Self;
2538        #[inline(always)]
2539        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2540            *value
2541        }
2542    }
2543
2544    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2545        for GetStructuredConfigError
2546    {
2547        #[inline]
2548        unsafe fn encode(
2549            self,
2550            encoder: &mut fidl::encoding::Encoder<'_, D>,
2551            offset: usize,
2552            _depth: fidl::encoding::Depth,
2553        ) -> fidl::Result<()> {
2554            encoder.debug_check_bounds::<Self>(offset);
2555            encoder.write_num(self.into_primitive(), offset);
2556            Ok(())
2557        }
2558    }
2559
2560    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2561        for GetStructuredConfigError
2562    {
2563        #[inline(always)]
2564        fn new_empty() -> Self {
2565            Self::unknown()
2566        }
2567
2568        #[inline]
2569        unsafe fn decode(
2570            &mut self,
2571            decoder: &mut fidl::encoding::Decoder<'_, D>,
2572            offset: usize,
2573            _depth: fidl::encoding::Depth,
2574        ) -> fidl::Result<()> {
2575            decoder.debug_check_bounds::<Self>(offset);
2576            let prim = decoder.read_num::<u32>(offset);
2577
2578            *self = Self::from_primitive_allow_unknown(prim);
2579            Ok(())
2580        }
2581    }
2582    unsafe impl fidl::encoding::TypeMarker for OpenDirType {
2583        type Owned = Self;
2584
2585        #[inline(always)]
2586        fn inline_align(_context: fidl::encoding::Context) -> usize {
2587            std::mem::align_of::<u32>()
2588        }
2589
2590        #[inline(always)]
2591        fn inline_size(_context: fidl::encoding::Context) -> usize {
2592            std::mem::size_of::<u32>()
2593        }
2594
2595        #[inline(always)]
2596        fn encode_is_copy() -> bool {
2597            false
2598        }
2599
2600        #[inline(always)]
2601        fn decode_is_copy() -> bool {
2602            false
2603        }
2604    }
2605
2606    impl fidl::encoding::ValueTypeMarker for OpenDirType {
2607        type Borrowed<'a> = Self;
2608        #[inline(always)]
2609        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2610            *value
2611        }
2612    }
2613
2614    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OpenDirType {
2615        #[inline]
2616        unsafe fn encode(
2617            self,
2618            encoder: &mut fidl::encoding::Encoder<'_, D>,
2619            offset: usize,
2620            _depth: fidl::encoding::Depth,
2621        ) -> fidl::Result<()> {
2622            encoder.debug_check_bounds::<Self>(offset);
2623            encoder.write_num(self.into_primitive(), offset);
2624            Ok(())
2625        }
2626    }
2627
2628    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OpenDirType {
2629        #[inline(always)]
2630        fn new_empty() -> Self {
2631            Self::unknown()
2632        }
2633
2634        #[inline]
2635        unsafe fn decode(
2636            &mut self,
2637            decoder: &mut fidl::encoding::Decoder<'_, D>,
2638            offset: usize,
2639            _depth: fidl::encoding::Depth,
2640        ) -> fidl::Result<()> {
2641            decoder.debug_check_bounds::<Self>(offset);
2642            let prim = decoder.read_num::<u32>(offset);
2643
2644            *self = Self::from_primitive_allow_unknown(prim);
2645            Ok(())
2646        }
2647    }
2648    unsafe impl fidl::encoding::TypeMarker for OpenError {
2649        type Owned = Self;
2650
2651        #[inline(always)]
2652        fn inline_align(_context: fidl::encoding::Context) -> usize {
2653            std::mem::align_of::<u32>()
2654        }
2655
2656        #[inline(always)]
2657        fn inline_size(_context: fidl::encoding::Context) -> usize {
2658            std::mem::size_of::<u32>()
2659        }
2660
2661        #[inline(always)]
2662        fn encode_is_copy() -> bool {
2663            false
2664        }
2665
2666        #[inline(always)]
2667        fn decode_is_copy() -> bool {
2668            false
2669        }
2670    }
2671
2672    impl fidl::encoding::ValueTypeMarker for OpenError {
2673        type Borrowed<'a> = Self;
2674        #[inline(always)]
2675        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2676            *value
2677        }
2678    }
2679
2680    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OpenError {
2681        #[inline]
2682        unsafe fn encode(
2683            self,
2684            encoder: &mut fidl::encoding::Encoder<'_, D>,
2685            offset: usize,
2686            _depth: fidl::encoding::Depth,
2687        ) -> fidl::Result<()> {
2688            encoder.debug_check_bounds::<Self>(offset);
2689            encoder.write_num(self.into_primitive(), offset);
2690            Ok(())
2691        }
2692    }
2693
2694    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OpenError {
2695        #[inline(always)]
2696        fn new_empty() -> Self {
2697            Self::unknown()
2698        }
2699
2700        #[inline]
2701        unsafe fn decode(
2702            &mut self,
2703            decoder: &mut fidl::encoding::Decoder<'_, D>,
2704            offset: usize,
2705            _depth: fidl::encoding::Depth,
2706        ) -> fidl::Result<()> {
2707            decoder.debug_check_bounds::<Self>(offset);
2708            let prim = decoder.read_num::<u32>(offset);
2709
2710            *self = Self::from_primitive_allow_unknown(prim);
2711            Ok(())
2712        }
2713    }
2714    unsafe impl fidl::encoding::TypeMarker for RealmQueryError {
2715        type Owned = Self;
2716
2717        #[inline(always)]
2718        fn inline_align(_context: fidl::encoding::Context) -> usize {
2719            std::mem::align_of::<u32>()
2720        }
2721
2722        #[inline(always)]
2723        fn inline_size(_context: fidl::encoding::Context) -> usize {
2724            std::mem::size_of::<u32>()
2725        }
2726
2727        #[inline(always)]
2728        fn encode_is_copy() -> bool {
2729            false
2730        }
2731
2732        #[inline(always)]
2733        fn decode_is_copy() -> bool {
2734            false
2735        }
2736    }
2737
2738    impl fidl::encoding::ValueTypeMarker for RealmQueryError {
2739        type Borrowed<'a> = Self;
2740        #[inline(always)]
2741        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2742            *value
2743        }
2744    }
2745
2746    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2747        for RealmQueryError
2748    {
2749        #[inline]
2750        unsafe fn encode(
2751            self,
2752            encoder: &mut fidl::encoding::Encoder<'_, D>,
2753            offset: usize,
2754            _depth: fidl::encoding::Depth,
2755        ) -> fidl::Result<()> {
2756            encoder.debug_check_bounds::<Self>(offset);
2757            encoder.write_num(self.into_primitive(), offset);
2758            Ok(())
2759        }
2760    }
2761
2762    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RealmQueryError {
2763        #[inline(always)]
2764        fn new_empty() -> Self {
2765            Self::unknown()
2766        }
2767
2768        #[inline]
2769        unsafe fn decode(
2770            &mut self,
2771            decoder: &mut fidl::encoding::Decoder<'_, D>,
2772            offset: usize,
2773            _depth: fidl::encoding::Depth,
2774        ) -> fidl::Result<()> {
2775            decoder.debug_check_bounds::<Self>(offset);
2776            let prim = decoder.read_num::<u32>(offset);
2777
2778            *self = Self::from_primitive_allow_unknown(prim);
2779            Ok(())
2780        }
2781    }
2782    unsafe impl fidl::encoding::TypeMarker for ResolveError {
2783        type Owned = Self;
2784
2785        #[inline(always)]
2786        fn inline_align(_context: fidl::encoding::Context) -> usize {
2787            std::mem::align_of::<u32>()
2788        }
2789
2790        #[inline(always)]
2791        fn inline_size(_context: fidl::encoding::Context) -> usize {
2792            std::mem::size_of::<u32>()
2793        }
2794
2795        #[inline(always)]
2796        fn encode_is_copy() -> bool {
2797            false
2798        }
2799
2800        #[inline(always)]
2801        fn decode_is_copy() -> bool {
2802            false
2803        }
2804    }
2805
2806    impl fidl::encoding::ValueTypeMarker for ResolveError {
2807        type Borrowed<'a> = Self;
2808        #[inline(always)]
2809        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2810            *value
2811        }
2812    }
2813
2814    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ResolveError {
2815        #[inline]
2816        unsafe fn encode(
2817            self,
2818            encoder: &mut fidl::encoding::Encoder<'_, D>,
2819            offset: usize,
2820            _depth: fidl::encoding::Depth,
2821        ) -> fidl::Result<()> {
2822            encoder.debug_check_bounds::<Self>(offset);
2823            encoder.write_num(self.into_primitive(), offset);
2824            Ok(())
2825        }
2826    }
2827
2828    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolveError {
2829        #[inline(always)]
2830        fn new_empty() -> Self {
2831            Self::unknown()
2832        }
2833
2834        #[inline]
2835        unsafe fn decode(
2836            &mut self,
2837            decoder: &mut fidl::encoding::Decoder<'_, D>,
2838            offset: usize,
2839            _depth: fidl::encoding::Depth,
2840        ) -> fidl::Result<()> {
2841            decoder.debug_check_bounds::<Self>(offset);
2842            let prim = decoder.read_num::<u32>(offset);
2843
2844            *self = Self::from_primitive_allow_unknown(prim);
2845            Ok(())
2846        }
2847    }
2848    unsafe impl fidl::encoding::TypeMarker for RouteOutcome {
2849        type Owned = Self;
2850
2851        #[inline(always)]
2852        fn inline_align(_context: fidl::encoding::Context) -> usize {
2853            std::mem::align_of::<u32>()
2854        }
2855
2856        #[inline(always)]
2857        fn inline_size(_context: fidl::encoding::Context) -> usize {
2858            std::mem::size_of::<u32>()
2859        }
2860
2861        #[inline(always)]
2862        fn encode_is_copy() -> bool {
2863            false
2864        }
2865
2866        #[inline(always)]
2867        fn decode_is_copy() -> bool {
2868            false
2869        }
2870    }
2871
2872    impl fidl::encoding::ValueTypeMarker for RouteOutcome {
2873        type Borrowed<'a> = Self;
2874        #[inline(always)]
2875        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2876            *value
2877        }
2878    }
2879
2880    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for RouteOutcome {
2881        #[inline]
2882        unsafe fn encode(
2883            self,
2884            encoder: &mut fidl::encoding::Encoder<'_, D>,
2885            offset: usize,
2886            _depth: fidl::encoding::Depth,
2887        ) -> fidl::Result<()> {
2888            encoder.debug_check_bounds::<Self>(offset);
2889            encoder.write_num(self.into_primitive(), offset);
2890            Ok(())
2891        }
2892    }
2893
2894    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RouteOutcome {
2895        #[inline(always)]
2896        fn new_empty() -> Self {
2897            Self::unknown()
2898        }
2899
2900        #[inline]
2901        unsafe fn decode(
2902            &mut self,
2903            decoder: &mut fidl::encoding::Decoder<'_, D>,
2904            offset: usize,
2905            _depth: fidl::encoding::Depth,
2906        ) -> fidl::Result<()> {
2907            decoder.debug_check_bounds::<Self>(offset);
2908            let prim = decoder.read_num::<u32>(offset);
2909
2910            *self = Self::from_primitive_allow_unknown(prim);
2911            Ok(())
2912        }
2913    }
2914    unsafe impl fidl::encoding::TypeMarker for RouteValidatorError {
2915        type Owned = Self;
2916
2917        #[inline(always)]
2918        fn inline_align(_context: fidl::encoding::Context) -> usize {
2919            std::mem::align_of::<u32>()
2920        }
2921
2922        #[inline(always)]
2923        fn inline_size(_context: fidl::encoding::Context) -> usize {
2924            std::mem::size_of::<u32>()
2925        }
2926
2927        #[inline(always)]
2928        fn encode_is_copy() -> bool {
2929            false
2930        }
2931
2932        #[inline(always)]
2933        fn decode_is_copy() -> bool {
2934            false
2935        }
2936    }
2937
2938    impl fidl::encoding::ValueTypeMarker for RouteValidatorError {
2939        type Borrowed<'a> = Self;
2940        #[inline(always)]
2941        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2942            *value
2943        }
2944    }
2945
2946    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2947        for RouteValidatorError
2948    {
2949        #[inline]
2950        unsafe fn encode(
2951            self,
2952            encoder: &mut fidl::encoding::Encoder<'_, D>,
2953            offset: usize,
2954            _depth: fidl::encoding::Depth,
2955        ) -> fidl::Result<()> {
2956            encoder.debug_check_bounds::<Self>(offset);
2957            encoder.write_num(self.into_primitive(), offset);
2958            Ok(())
2959        }
2960    }
2961
2962    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RouteValidatorError {
2963        #[inline(always)]
2964        fn new_empty() -> Self {
2965            Self::unknown()
2966        }
2967
2968        #[inline]
2969        unsafe fn decode(
2970            &mut self,
2971            decoder: &mut fidl::encoding::Decoder<'_, D>,
2972            offset: usize,
2973            _depth: fidl::encoding::Depth,
2974        ) -> fidl::Result<()> {
2975            decoder.debug_check_bounds::<Self>(offset);
2976            let prim = decoder.read_num::<u32>(offset);
2977
2978            *self = Self::from_primitive_allow_unknown(prim);
2979            Ok(())
2980        }
2981    }
2982    unsafe impl fidl::encoding::TypeMarker for StartError {
2983        type Owned = Self;
2984
2985        #[inline(always)]
2986        fn inline_align(_context: fidl::encoding::Context) -> usize {
2987            std::mem::align_of::<u32>()
2988        }
2989
2990        #[inline(always)]
2991        fn inline_size(_context: fidl::encoding::Context) -> usize {
2992            std::mem::size_of::<u32>()
2993        }
2994
2995        #[inline(always)]
2996        fn encode_is_copy() -> bool {
2997            false
2998        }
2999
3000        #[inline(always)]
3001        fn decode_is_copy() -> bool {
3002            false
3003        }
3004    }
3005
3006    impl fidl::encoding::ValueTypeMarker for StartError {
3007        type Borrowed<'a> = Self;
3008        #[inline(always)]
3009        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3010            *value
3011        }
3012    }
3013
3014    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StartError {
3015        #[inline]
3016        unsafe fn encode(
3017            self,
3018            encoder: &mut fidl::encoding::Encoder<'_, D>,
3019            offset: usize,
3020            _depth: fidl::encoding::Depth,
3021        ) -> fidl::Result<()> {
3022            encoder.debug_check_bounds::<Self>(offset);
3023            encoder.write_num(self.into_primitive(), offset);
3024            Ok(())
3025        }
3026    }
3027
3028    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartError {
3029        #[inline(always)]
3030        fn new_empty() -> Self {
3031            Self::unknown()
3032        }
3033
3034        #[inline]
3035        unsafe fn decode(
3036            &mut self,
3037            decoder: &mut fidl::encoding::Decoder<'_, D>,
3038            offset: usize,
3039            _depth: fidl::encoding::Depth,
3040        ) -> fidl::Result<()> {
3041            decoder.debug_check_bounds::<Self>(offset);
3042            let prim = decoder.read_num::<u32>(offset);
3043
3044            *self = Self::from_primitive_allow_unknown(prim);
3045            Ok(())
3046        }
3047    }
3048    unsafe impl fidl::encoding::TypeMarker for StatusError {
3049        type Owned = Self;
3050
3051        #[inline(always)]
3052        fn inline_align(_context: fidl::encoding::Context) -> usize {
3053            std::mem::align_of::<u32>()
3054        }
3055
3056        #[inline(always)]
3057        fn inline_size(_context: fidl::encoding::Context) -> usize {
3058            std::mem::size_of::<u32>()
3059        }
3060
3061        #[inline(always)]
3062        fn encode_is_copy() -> bool {
3063            true
3064        }
3065
3066        #[inline(always)]
3067        fn decode_is_copy() -> bool {
3068            false
3069        }
3070    }
3071
3072    impl fidl::encoding::ValueTypeMarker for StatusError {
3073        type Borrowed<'a> = Self;
3074        #[inline(always)]
3075        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3076            *value
3077        }
3078    }
3079
3080    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StatusError {
3081        #[inline]
3082        unsafe fn encode(
3083            self,
3084            encoder: &mut fidl::encoding::Encoder<'_, D>,
3085            offset: usize,
3086            _depth: fidl::encoding::Depth,
3087        ) -> fidl::Result<()> {
3088            encoder.debug_check_bounds::<Self>(offset);
3089            encoder.write_num(self.into_primitive(), offset);
3090            Ok(())
3091        }
3092    }
3093
3094    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StatusError {
3095        #[inline(always)]
3096        fn new_empty() -> Self {
3097            Self::Provider
3098        }
3099
3100        #[inline]
3101        unsafe fn decode(
3102            &mut self,
3103            decoder: &mut fidl::encoding::Decoder<'_, D>,
3104            offset: usize,
3105            _depth: fidl::encoding::Depth,
3106        ) -> fidl::Result<()> {
3107            decoder.debug_check_bounds::<Self>(offset);
3108            let prim = decoder.read_num::<u32>(offset);
3109
3110            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3111            Ok(())
3112        }
3113    }
3114    unsafe impl fidl::encoding::TypeMarker for StopError {
3115        type Owned = Self;
3116
3117        #[inline(always)]
3118        fn inline_align(_context: fidl::encoding::Context) -> usize {
3119            std::mem::align_of::<u32>()
3120        }
3121
3122        #[inline(always)]
3123        fn inline_size(_context: fidl::encoding::Context) -> usize {
3124            std::mem::size_of::<u32>()
3125        }
3126
3127        #[inline(always)]
3128        fn encode_is_copy() -> bool {
3129            false
3130        }
3131
3132        #[inline(always)]
3133        fn decode_is_copy() -> bool {
3134            false
3135        }
3136    }
3137
3138    impl fidl::encoding::ValueTypeMarker for StopError {
3139        type Borrowed<'a> = Self;
3140        #[inline(always)]
3141        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3142            *value
3143        }
3144    }
3145
3146    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StopError {
3147        #[inline]
3148        unsafe fn encode(
3149            self,
3150            encoder: &mut fidl::encoding::Encoder<'_, D>,
3151            offset: usize,
3152            _depth: fidl::encoding::Depth,
3153        ) -> fidl::Result<()> {
3154            encoder.debug_check_bounds::<Self>(offset);
3155            encoder.write_num(self.into_primitive(), offset);
3156            Ok(())
3157        }
3158    }
3159
3160    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StopError {
3161        #[inline(always)]
3162        fn new_empty() -> Self {
3163            Self::unknown()
3164        }
3165
3166        #[inline]
3167        unsafe fn decode(
3168            &mut self,
3169            decoder: &mut fidl::encoding::Decoder<'_, D>,
3170            offset: usize,
3171            _depth: fidl::encoding::Depth,
3172        ) -> fidl::Result<()> {
3173            decoder.debug_check_bounds::<Self>(offset);
3174            let prim = decoder.read_num::<u32>(offset);
3175
3176            *self = Self::from_primitive_allow_unknown(prim);
3177            Ok(())
3178        }
3179    }
3180    unsafe impl fidl::encoding::TypeMarker for UnresolveError {
3181        type Owned = Self;
3182
3183        #[inline(always)]
3184        fn inline_align(_context: fidl::encoding::Context) -> usize {
3185            std::mem::align_of::<u32>()
3186        }
3187
3188        #[inline(always)]
3189        fn inline_size(_context: fidl::encoding::Context) -> usize {
3190            std::mem::size_of::<u32>()
3191        }
3192
3193        #[inline(always)]
3194        fn encode_is_copy() -> bool {
3195            false
3196        }
3197
3198        #[inline(always)]
3199        fn decode_is_copy() -> bool {
3200            false
3201        }
3202    }
3203
3204    impl fidl::encoding::ValueTypeMarker for UnresolveError {
3205        type Borrowed<'a> = Self;
3206        #[inline(always)]
3207        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3208            *value
3209        }
3210    }
3211
3212    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for UnresolveError {
3213        #[inline]
3214        unsafe fn encode(
3215            self,
3216            encoder: &mut fidl::encoding::Encoder<'_, D>,
3217            offset: usize,
3218            _depth: fidl::encoding::Depth,
3219        ) -> fidl::Result<()> {
3220            encoder.debug_check_bounds::<Self>(offset);
3221            encoder.write_num(self.into_primitive(), offset);
3222            Ok(())
3223        }
3224    }
3225
3226    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UnresolveError {
3227        #[inline(always)]
3228        fn new_empty() -> Self {
3229            Self::unknown()
3230        }
3231
3232        #[inline]
3233        unsafe fn decode(
3234            &mut self,
3235            decoder: &mut fidl::encoding::Decoder<'_, D>,
3236            offset: usize,
3237            _depth: fidl::encoding::Depth,
3238        ) -> fidl::Result<()> {
3239            decoder.debug_check_bounds::<Self>(offset);
3240            let prim = decoder.read_num::<u32>(offset);
3241
3242            *self = Self::from_primitive_allow_unknown(prim);
3243            Ok(())
3244        }
3245    }
3246
3247    impl fidl::encoding::ValueTypeMarker for ConfigOverrideSetStructuredConfigRequest {
3248        type Borrowed<'a> = &'a Self;
3249        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3250            value
3251        }
3252    }
3253
3254    unsafe impl fidl::encoding::TypeMarker for ConfigOverrideSetStructuredConfigRequest {
3255        type Owned = Self;
3256
3257        #[inline(always)]
3258        fn inline_align(_context: fidl::encoding::Context) -> usize {
3259            8
3260        }
3261
3262        #[inline(always)]
3263        fn inline_size(_context: fidl::encoding::Context) -> usize {
3264            32
3265        }
3266    }
3267
3268    unsafe impl<D: fidl::encoding::ResourceDialect>
3269        fidl::encoding::Encode<ConfigOverrideSetStructuredConfigRequest, D>
3270        for &ConfigOverrideSetStructuredConfigRequest
3271    {
3272        #[inline]
3273        unsafe fn encode(
3274            self,
3275            encoder: &mut fidl::encoding::Encoder<'_, D>,
3276            offset: usize,
3277            _depth: fidl::encoding::Depth,
3278        ) -> fidl::Result<()> {
3279            encoder.debug_check_bounds::<ConfigOverrideSetStructuredConfigRequest>(offset);
3280            // Delegate to tuple encoding.
3281            fidl::encoding::Encode::<ConfigOverrideSetStructuredConfigRequest, D>::encode(
3282                (
3283                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.moniker),
3284                    <fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::ConfigOverride> as fidl::encoding::ValueTypeMarker>::borrow(&self.fields),
3285                ),
3286                encoder, offset, _depth
3287            )
3288        }
3289    }
3290    unsafe impl<
3291            D: fidl::encoding::ResourceDialect,
3292            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
3293            T1: fidl::encoding::Encode<
3294                fidl::encoding::UnboundedVector<
3295                    fidl_fuchsia_component_decl__common::ConfigOverride,
3296                >,
3297                D,
3298            >,
3299        > fidl::encoding::Encode<ConfigOverrideSetStructuredConfigRequest, D> for (T0, T1)
3300    {
3301        #[inline]
3302        unsafe fn encode(
3303            self,
3304            encoder: &mut fidl::encoding::Encoder<'_, D>,
3305            offset: usize,
3306            depth: fidl::encoding::Depth,
3307        ) -> fidl::Result<()> {
3308            encoder.debug_check_bounds::<ConfigOverrideSetStructuredConfigRequest>(offset);
3309            // Zero out padding regions. There's no need to apply masks
3310            // because the unmasked parts will be overwritten by fields.
3311            // Write the fields.
3312            self.0.encode(encoder, offset + 0, depth)?;
3313            self.1.encode(encoder, offset + 16, depth)?;
3314            Ok(())
3315        }
3316    }
3317
3318    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3319        for ConfigOverrideSetStructuredConfigRequest
3320    {
3321        #[inline(always)]
3322        fn new_empty() -> Self {
3323            Self {
3324                moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
3325                fields: fidl::new_empty!(
3326                    fidl::encoding::UnboundedVector<
3327                        fidl_fuchsia_component_decl__common::ConfigOverride,
3328                    >,
3329                    D
3330                ),
3331            }
3332        }
3333
3334        #[inline]
3335        unsafe fn decode(
3336            &mut self,
3337            decoder: &mut fidl::encoding::Decoder<'_, D>,
3338            offset: usize,
3339            _depth: fidl::encoding::Depth,
3340        ) -> fidl::Result<()> {
3341            decoder.debug_check_bounds::<Self>(offset);
3342            // Verify that padding bytes are zero.
3343            fidl::decode!(
3344                fidl::encoding::BoundedString<4096>,
3345                D,
3346                &mut self.moniker,
3347                decoder,
3348                offset + 0,
3349                _depth
3350            )?;
3351            fidl::decode!(
3352                fidl::encoding::UnboundedVector<
3353                    fidl_fuchsia_component_decl__common::ConfigOverride,
3354                >,
3355                D,
3356                &mut self.fields,
3357                decoder,
3358                offset + 16,
3359                _depth
3360            )?;
3361            Ok(())
3362        }
3363    }
3364
3365    impl fidl::encoding::ValueTypeMarker for ConfigOverrideUnsetStructuredConfigRequest {
3366        type Borrowed<'a> = &'a Self;
3367        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3368            value
3369        }
3370    }
3371
3372    unsafe impl fidl::encoding::TypeMarker for ConfigOverrideUnsetStructuredConfigRequest {
3373        type Owned = Self;
3374
3375        #[inline(always)]
3376        fn inline_align(_context: fidl::encoding::Context) -> usize {
3377            8
3378        }
3379
3380        #[inline(always)]
3381        fn inline_size(_context: fidl::encoding::Context) -> usize {
3382            16
3383        }
3384    }
3385
3386    unsafe impl<D: fidl::encoding::ResourceDialect>
3387        fidl::encoding::Encode<ConfigOverrideUnsetStructuredConfigRequest, D>
3388        for &ConfigOverrideUnsetStructuredConfigRequest
3389    {
3390        #[inline]
3391        unsafe fn encode(
3392            self,
3393            encoder: &mut fidl::encoding::Encoder<'_, D>,
3394            offset: usize,
3395            _depth: fidl::encoding::Depth,
3396        ) -> fidl::Result<()> {
3397            encoder.debug_check_bounds::<ConfigOverrideUnsetStructuredConfigRequest>(offset);
3398            // Delegate to tuple encoding.
3399            fidl::encoding::Encode::<ConfigOverrideUnsetStructuredConfigRequest, D>::encode(
3400                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
3401                    &self.moniker,
3402                ),),
3403                encoder,
3404                offset,
3405                _depth,
3406            )
3407        }
3408    }
3409    unsafe impl<
3410            D: fidl::encoding::ResourceDialect,
3411            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
3412        > fidl::encoding::Encode<ConfigOverrideUnsetStructuredConfigRequest, D> for (T0,)
3413    {
3414        #[inline]
3415        unsafe fn encode(
3416            self,
3417            encoder: &mut fidl::encoding::Encoder<'_, D>,
3418            offset: usize,
3419            depth: fidl::encoding::Depth,
3420        ) -> fidl::Result<()> {
3421            encoder.debug_check_bounds::<ConfigOverrideUnsetStructuredConfigRequest>(offset);
3422            // Zero out padding regions. There's no need to apply masks
3423            // because the unmasked parts will be overwritten by fields.
3424            // Write the fields.
3425            self.0.encode(encoder, offset + 0, depth)?;
3426            Ok(())
3427        }
3428    }
3429
3430    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3431        for ConfigOverrideUnsetStructuredConfigRequest
3432    {
3433        #[inline(always)]
3434        fn new_empty() -> Self {
3435            Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
3436        }
3437
3438        #[inline]
3439        unsafe fn decode(
3440            &mut self,
3441            decoder: &mut fidl::encoding::Decoder<'_, D>,
3442            offset: usize,
3443            _depth: fidl::encoding::Depth,
3444        ) -> fidl::Result<()> {
3445            decoder.debug_check_bounds::<Self>(offset);
3446            // Verify that padding bytes are zero.
3447            fidl::decode!(
3448                fidl::encoding::BoundedString<4096>,
3449                D,
3450                &mut self.moniker,
3451                decoder,
3452                offset + 0,
3453                _depth
3454            )?;
3455            Ok(())
3456        }
3457    }
3458
3459    impl fidl::encoding::ValueTypeMarker for CrashIntrospectFindComponentByThreadKoidResponse {
3460        type Borrowed<'a> = &'a Self;
3461        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3462            value
3463        }
3464    }
3465
3466    unsafe impl fidl::encoding::TypeMarker for CrashIntrospectFindComponentByThreadKoidResponse {
3467        type Owned = Self;
3468
3469        #[inline(always)]
3470        fn inline_align(_context: fidl::encoding::Context) -> usize {
3471            8
3472        }
3473
3474        #[inline(always)]
3475        fn inline_size(_context: fidl::encoding::Context) -> usize {
3476            16
3477        }
3478    }
3479
3480    unsafe impl<D: fidl::encoding::ResourceDialect>
3481        fidl::encoding::Encode<CrashIntrospectFindComponentByThreadKoidResponse, D>
3482        for &CrashIntrospectFindComponentByThreadKoidResponse
3483    {
3484        #[inline]
3485        unsafe fn encode(
3486            self,
3487            encoder: &mut fidl::encoding::Encoder<'_, D>,
3488            offset: usize,
3489            _depth: fidl::encoding::Depth,
3490        ) -> fidl::Result<()> {
3491            encoder.debug_check_bounds::<CrashIntrospectFindComponentByThreadKoidResponse>(offset);
3492            // Delegate to tuple encoding.
3493            fidl::encoding::Encode::<CrashIntrospectFindComponentByThreadKoidResponse, D>::encode(
3494                (<ComponentCrashInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
3495                encoder,
3496                offset,
3497                _depth,
3498            )
3499        }
3500    }
3501    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ComponentCrashInfo, D>>
3502        fidl::encoding::Encode<CrashIntrospectFindComponentByThreadKoidResponse, D> for (T0,)
3503    {
3504        #[inline]
3505        unsafe fn encode(
3506            self,
3507            encoder: &mut fidl::encoding::Encoder<'_, D>,
3508            offset: usize,
3509            depth: fidl::encoding::Depth,
3510        ) -> fidl::Result<()> {
3511            encoder.debug_check_bounds::<CrashIntrospectFindComponentByThreadKoidResponse>(offset);
3512            // Zero out padding regions. There's no need to apply masks
3513            // because the unmasked parts will be overwritten by fields.
3514            // Write the fields.
3515            self.0.encode(encoder, offset + 0, depth)?;
3516            Ok(())
3517        }
3518    }
3519
3520    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3521        for CrashIntrospectFindComponentByThreadKoidResponse
3522    {
3523        #[inline(always)]
3524        fn new_empty() -> Self {
3525            Self { info: fidl::new_empty!(ComponentCrashInfo, D) }
3526        }
3527
3528        #[inline]
3529        unsafe fn decode(
3530            &mut self,
3531            decoder: &mut fidl::encoding::Decoder<'_, D>,
3532            offset: usize,
3533            _depth: fidl::encoding::Depth,
3534        ) -> fidl::Result<()> {
3535            decoder.debug_check_bounds::<Self>(offset);
3536            // Verify that padding bytes are zero.
3537            fidl::decode!(ComponentCrashInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
3538            Ok(())
3539        }
3540    }
3541
3542    impl fidl::encoding::ValueTypeMarker for InstanceIteratorNextResponse {
3543        type Borrowed<'a> = &'a Self;
3544        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3545            value
3546        }
3547    }
3548
3549    unsafe impl fidl::encoding::TypeMarker for InstanceIteratorNextResponse {
3550        type Owned = Self;
3551
3552        #[inline(always)]
3553        fn inline_align(_context: fidl::encoding::Context) -> usize {
3554            8
3555        }
3556
3557        #[inline(always)]
3558        fn inline_size(_context: fidl::encoding::Context) -> usize {
3559            16
3560        }
3561    }
3562
3563    unsafe impl<D: fidl::encoding::ResourceDialect>
3564        fidl::encoding::Encode<InstanceIteratorNextResponse, D> for &InstanceIteratorNextResponse
3565    {
3566        #[inline]
3567        unsafe fn encode(
3568            self,
3569            encoder: &mut fidl::encoding::Encoder<'_, D>,
3570            offset: usize,
3571            _depth: fidl::encoding::Depth,
3572        ) -> fidl::Result<()> {
3573            encoder.debug_check_bounds::<InstanceIteratorNextResponse>(offset);
3574            // Delegate to tuple encoding.
3575            fidl::encoding::Encode::<InstanceIteratorNextResponse, D>::encode(
3576                (
3577                    <fidl::encoding::UnboundedVector<Instance> as fidl::encoding::ValueTypeMarker>::borrow(&self.infos),
3578                ),
3579                encoder, offset, _depth
3580            )
3581        }
3582    }
3583    unsafe impl<
3584            D: fidl::encoding::ResourceDialect,
3585            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Instance>, D>,
3586        > fidl::encoding::Encode<InstanceIteratorNextResponse, D> for (T0,)
3587    {
3588        #[inline]
3589        unsafe fn encode(
3590            self,
3591            encoder: &mut fidl::encoding::Encoder<'_, D>,
3592            offset: usize,
3593            depth: fidl::encoding::Depth,
3594        ) -> fidl::Result<()> {
3595            encoder.debug_check_bounds::<InstanceIteratorNextResponse>(offset);
3596            // Zero out padding regions. There's no need to apply masks
3597            // because the unmasked parts will be overwritten by fields.
3598            // Write the fields.
3599            self.0.encode(encoder, offset + 0, depth)?;
3600            Ok(())
3601        }
3602    }
3603
3604    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3605        for InstanceIteratorNextResponse
3606    {
3607        #[inline(always)]
3608        fn new_empty() -> Self {
3609            Self { infos: fidl::new_empty!(fidl::encoding::UnboundedVector<Instance>, D) }
3610        }
3611
3612        #[inline]
3613        unsafe fn decode(
3614            &mut self,
3615            decoder: &mut fidl::encoding::Decoder<'_, D>,
3616            offset: usize,
3617            _depth: fidl::encoding::Depth,
3618        ) -> fidl::Result<()> {
3619            decoder.debug_check_bounds::<Self>(offset);
3620            // Verify that padding bytes are zero.
3621            fidl::decode!(
3622                fidl::encoding::UnboundedVector<Instance>,
3623                D,
3624                &mut self.infos,
3625                decoder,
3626                offset + 0,
3627                _depth
3628            )?;
3629            Ok(())
3630        }
3631    }
3632
3633    impl fidl::encoding::ValueTypeMarker for LifecycleControllerDestroyInstanceRequest {
3634        type Borrowed<'a> = &'a Self;
3635        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3636            value
3637        }
3638    }
3639
3640    unsafe impl fidl::encoding::TypeMarker for LifecycleControllerDestroyInstanceRequest {
3641        type Owned = Self;
3642
3643        #[inline(always)]
3644        fn inline_align(_context: fidl::encoding::Context) -> usize {
3645            8
3646        }
3647
3648        #[inline(always)]
3649        fn inline_size(_context: fidl::encoding::Context) -> usize {
3650            48
3651        }
3652    }
3653
3654    unsafe impl<D: fidl::encoding::ResourceDialect>
3655        fidl::encoding::Encode<LifecycleControllerDestroyInstanceRequest, D>
3656        for &LifecycleControllerDestroyInstanceRequest
3657    {
3658        #[inline]
3659        unsafe fn encode(
3660            self,
3661            encoder: &mut fidl::encoding::Encoder<'_, D>,
3662            offset: usize,
3663            _depth: fidl::encoding::Depth,
3664        ) -> fidl::Result<()> {
3665            encoder.debug_check_bounds::<LifecycleControllerDestroyInstanceRequest>(offset);
3666            // Delegate to tuple encoding.
3667            fidl::encoding::Encode::<LifecycleControllerDestroyInstanceRequest, D>::encode(
3668                (
3669                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.parent_moniker),
3670                    <fidl_fuchsia_component_decl__common::ChildRef as fidl::encoding::ValueTypeMarker>::borrow(&self.child),
3671                ),
3672                encoder, offset, _depth
3673            )
3674        }
3675    }
3676    unsafe impl<
3677            D: fidl::encoding::ResourceDialect,
3678            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
3679            T1: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::ChildRef, D>,
3680        > fidl::encoding::Encode<LifecycleControllerDestroyInstanceRequest, D> for (T0, T1)
3681    {
3682        #[inline]
3683        unsafe fn encode(
3684            self,
3685            encoder: &mut fidl::encoding::Encoder<'_, D>,
3686            offset: usize,
3687            depth: fidl::encoding::Depth,
3688        ) -> fidl::Result<()> {
3689            encoder.debug_check_bounds::<LifecycleControllerDestroyInstanceRequest>(offset);
3690            // Zero out padding regions. There's no need to apply masks
3691            // because the unmasked parts will be overwritten by fields.
3692            // Write the fields.
3693            self.0.encode(encoder, offset + 0, depth)?;
3694            self.1.encode(encoder, offset + 16, depth)?;
3695            Ok(())
3696        }
3697    }
3698
3699    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3700        for LifecycleControllerDestroyInstanceRequest
3701    {
3702        #[inline(always)]
3703        fn new_empty() -> Self {
3704            Self {
3705                parent_moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
3706                child: fidl::new_empty!(fidl_fuchsia_component_decl__common::ChildRef, D),
3707            }
3708        }
3709
3710        #[inline]
3711        unsafe fn decode(
3712            &mut self,
3713            decoder: &mut fidl::encoding::Decoder<'_, D>,
3714            offset: usize,
3715            _depth: fidl::encoding::Depth,
3716        ) -> fidl::Result<()> {
3717            decoder.debug_check_bounds::<Self>(offset);
3718            // Verify that padding bytes are zero.
3719            fidl::decode!(
3720                fidl::encoding::BoundedString<4096>,
3721                D,
3722                &mut self.parent_moniker,
3723                decoder,
3724                offset + 0,
3725                _depth
3726            )?;
3727            fidl::decode!(
3728                fidl_fuchsia_component_decl__common::ChildRef,
3729                D,
3730                &mut self.child,
3731                decoder,
3732                offset + 16,
3733                _depth
3734            )?;
3735            Ok(())
3736        }
3737    }
3738
3739    impl fidl::encoding::ValueTypeMarker for LifecycleControllerResolveInstanceRequest {
3740        type Borrowed<'a> = &'a Self;
3741        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3742            value
3743        }
3744    }
3745
3746    unsafe impl fidl::encoding::TypeMarker for LifecycleControllerResolveInstanceRequest {
3747        type Owned = Self;
3748
3749        #[inline(always)]
3750        fn inline_align(_context: fidl::encoding::Context) -> usize {
3751            8
3752        }
3753
3754        #[inline(always)]
3755        fn inline_size(_context: fidl::encoding::Context) -> usize {
3756            16
3757        }
3758    }
3759
3760    unsafe impl<D: fidl::encoding::ResourceDialect>
3761        fidl::encoding::Encode<LifecycleControllerResolveInstanceRequest, D>
3762        for &LifecycleControllerResolveInstanceRequest
3763    {
3764        #[inline]
3765        unsafe fn encode(
3766            self,
3767            encoder: &mut fidl::encoding::Encoder<'_, D>,
3768            offset: usize,
3769            _depth: fidl::encoding::Depth,
3770        ) -> fidl::Result<()> {
3771            encoder.debug_check_bounds::<LifecycleControllerResolveInstanceRequest>(offset);
3772            // Delegate to tuple encoding.
3773            fidl::encoding::Encode::<LifecycleControllerResolveInstanceRequest, D>::encode(
3774                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
3775                    &self.moniker,
3776                ),),
3777                encoder,
3778                offset,
3779                _depth,
3780            )
3781        }
3782    }
3783    unsafe impl<
3784            D: fidl::encoding::ResourceDialect,
3785            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
3786        > fidl::encoding::Encode<LifecycleControllerResolveInstanceRequest, D> for (T0,)
3787    {
3788        #[inline]
3789        unsafe fn encode(
3790            self,
3791            encoder: &mut fidl::encoding::Encoder<'_, D>,
3792            offset: usize,
3793            depth: fidl::encoding::Depth,
3794        ) -> fidl::Result<()> {
3795            encoder.debug_check_bounds::<LifecycleControllerResolveInstanceRequest>(offset);
3796            // Zero out padding regions. There's no need to apply masks
3797            // because the unmasked parts will be overwritten by fields.
3798            // Write the fields.
3799            self.0.encode(encoder, offset + 0, depth)?;
3800            Ok(())
3801        }
3802    }
3803
3804    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3805        for LifecycleControllerResolveInstanceRequest
3806    {
3807        #[inline(always)]
3808        fn new_empty() -> Self {
3809            Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
3810        }
3811
3812        #[inline]
3813        unsafe fn decode(
3814            &mut self,
3815            decoder: &mut fidl::encoding::Decoder<'_, D>,
3816            offset: usize,
3817            _depth: fidl::encoding::Depth,
3818        ) -> fidl::Result<()> {
3819            decoder.debug_check_bounds::<Self>(offset);
3820            // Verify that padding bytes are zero.
3821            fidl::decode!(
3822                fidl::encoding::BoundedString<4096>,
3823                D,
3824                &mut self.moniker,
3825                decoder,
3826                offset + 0,
3827                _depth
3828            )?;
3829            Ok(())
3830        }
3831    }
3832
3833    impl fidl::encoding::ValueTypeMarker for LifecycleControllerStopInstanceRequest {
3834        type Borrowed<'a> = &'a Self;
3835        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3836            value
3837        }
3838    }
3839
3840    unsafe impl fidl::encoding::TypeMarker for LifecycleControllerStopInstanceRequest {
3841        type Owned = Self;
3842
3843        #[inline(always)]
3844        fn inline_align(_context: fidl::encoding::Context) -> usize {
3845            8
3846        }
3847
3848        #[inline(always)]
3849        fn inline_size(_context: fidl::encoding::Context) -> usize {
3850            16
3851        }
3852    }
3853
3854    unsafe impl<D: fidl::encoding::ResourceDialect>
3855        fidl::encoding::Encode<LifecycleControllerStopInstanceRequest, D>
3856        for &LifecycleControllerStopInstanceRequest
3857    {
3858        #[inline]
3859        unsafe fn encode(
3860            self,
3861            encoder: &mut fidl::encoding::Encoder<'_, D>,
3862            offset: usize,
3863            _depth: fidl::encoding::Depth,
3864        ) -> fidl::Result<()> {
3865            encoder.debug_check_bounds::<LifecycleControllerStopInstanceRequest>(offset);
3866            // Delegate to tuple encoding.
3867            fidl::encoding::Encode::<LifecycleControllerStopInstanceRequest, D>::encode(
3868                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
3869                    &self.moniker,
3870                ),),
3871                encoder,
3872                offset,
3873                _depth,
3874            )
3875        }
3876    }
3877    unsafe impl<
3878            D: fidl::encoding::ResourceDialect,
3879            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
3880        > fidl::encoding::Encode<LifecycleControllerStopInstanceRequest, D> for (T0,)
3881    {
3882        #[inline]
3883        unsafe fn encode(
3884            self,
3885            encoder: &mut fidl::encoding::Encoder<'_, D>,
3886            offset: usize,
3887            depth: fidl::encoding::Depth,
3888        ) -> fidl::Result<()> {
3889            encoder.debug_check_bounds::<LifecycleControllerStopInstanceRequest>(offset);
3890            // Zero out padding regions. There's no need to apply masks
3891            // because the unmasked parts will be overwritten by fields.
3892            // Write the fields.
3893            self.0.encode(encoder, offset + 0, depth)?;
3894            Ok(())
3895        }
3896    }
3897
3898    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3899        for LifecycleControllerStopInstanceRequest
3900    {
3901        #[inline(always)]
3902        fn new_empty() -> Self {
3903            Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
3904        }
3905
3906        #[inline]
3907        unsafe fn decode(
3908            &mut self,
3909            decoder: &mut fidl::encoding::Decoder<'_, D>,
3910            offset: usize,
3911            _depth: fidl::encoding::Depth,
3912        ) -> fidl::Result<()> {
3913            decoder.debug_check_bounds::<Self>(offset);
3914            // Verify that padding bytes are zero.
3915            fidl::decode!(
3916                fidl::encoding::BoundedString<4096>,
3917                D,
3918                &mut self.moniker,
3919                decoder,
3920                offset + 0,
3921                _depth
3922            )?;
3923            Ok(())
3924        }
3925    }
3926
3927    impl fidl::encoding::ValueTypeMarker for LifecycleControllerUnresolveInstanceRequest {
3928        type Borrowed<'a> = &'a Self;
3929        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3930            value
3931        }
3932    }
3933
3934    unsafe impl fidl::encoding::TypeMarker for LifecycleControllerUnresolveInstanceRequest {
3935        type Owned = Self;
3936
3937        #[inline(always)]
3938        fn inline_align(_context: fidl::encoding::Context) -> usize {
3939            8
3940        }
3941
3942        #[inline(always)]
3943        fn inline_size(_context: fidl::encoding::Context) -> usize {
3944            16
3945        }
3946    }
3947
3948    unsafe impl<D: fidl::encoding::ResourceDialect>
3949        fidl::encoding::Encode<LifecycleControllerUnresolveInstanceRequest, D>
3950        for &LifecycleControllerUnresolveInstanceRequest
3951    {
3952        #[inline]
3953        unsafe fn encode(
3954            self,
3955            encoder: &mut fidl::encoding::Encoder<'_, D>,
3956            offset: usize,
3957            _depth: fidl::encoding::Depth,
3958        ) -> fidl::Result<()> {
3959            encoder.debug_check_bounds::<LifecycleControllerUnresolveInstanceRequest>(offset);
3960            // Delegate to tuple encoding.
3961            fidl::encoding::Encode::<LifecycleControllerUnresolveInstanceRequest, D>::encode(
3962                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
3963                    &self.moniker,
3964                ),),
3965                encoder,
3966                offset,
3967                _depth,
3968            )
3969        }
3970    }
3971    unsafe impl<
3972            D: fidl::encoding::ResourceDialect,
3973            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
3974        > fidl::encoding::Encode<LifecycleControllerUnresolveInstanceRequest, D> for (T0,)
3975    {
3976        #[inline]
3977        unsafe fn encode(
3978            self,
3979            encoder: &mut fidl::encoding::Encoder<'_, D>,
3980            offset: usize,
3981            depth: fidl::encoding::Depth,
3982        ) -> fidl::Result<()> {
3983            encoder.debug_check_bounds::<LifecycleControllerUnresolveInstanceRequest>(offset);
3984            // Zero out padding regions. There's no need to apply masks
3985            // because the unmasked parts will be overwritten by fields.
3986            // Write the fields.
3987            self.0.encode(encoder, offset + 0, depth)?;
3988            Ok(())
3989        }
3990    }
3991
3992    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3993        for LifecycleControllerUnresolveInstanceRequest
3994    {
3995        #[inline(always)]
3996        fn new_empty() -> Self {
3997            Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
3998        }
3999
4000        #[inline]
4001        unsafe fn decode(
4002            &mut self,
4003            decoder: &mut fidl::encoding::Decoder<'_, D>,
4004            offset: usize,
4005            _depth: fidl::encoding::Depth,
4006        ) -> fidl::Result<()> {
4007            decoder.debug_check_bounds::<Self>(offset);
4008            // Verify that padding bytes are zero.
4009            fidl::decode!(
4010                fidl::encoding::BoundedString<4096>,
4011                D,
4012                &mut self.moniker,
4013                decoder,
4014                offset + 0,
4015                _depth
4016            )?;
4017            Ok(())
4018        }
4019    }
4020
4021    impl fidl::encoding::ValueTypeMarker for ManifestBytesIteratorNextResponse {
4022        type Borrowed<'a> = &'a Self;
4023        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4024            value
4025        }
4026    }
4027
4028    unsafe impl fidl::encoding::TypeMarker for ManifestBytesIteratorNextResponse {
4029        type Owned = Self;
4030
4031        #[inline(always)]
4032        fn inline_align(_context: fidl::encoding::Context) -> usize {
4033            8
4034        }
4035
4036        #[inline(always)]
4037        fn inline_size(_context: fidl::encoding::Context) -> usize {
4038            16
4039        }
4040    }
4041
4042    unsafe impl<D: fidl::encoding::ResourceDialect>
4043        fidl::encoding::Encode<ManifestBytesIteratorNextResponse, D>
4044        for &ManifestBytesIteratorNextResponse
4045    {
4046        #[inline]
4047        unsafe fn encode(
4048            self,
4049            encoder: &mut fidl::encoding::Encoder<'_, D>,
4050            offset: usize,
4051            _depth: fidl::encoding::Depth,
4052        ) -> fidl::Result<()> {
4053            encoder.debug_check_bounds::<ManifestBytesIteratorNextResponse>(offset);
4054            // Delegate to tuple encoding.
4055            fidl::encoding::Encode::<ManifestBytesIteratorNextResponse, D>::encode(
4056                (<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(
4057                    &self.infos,
4058                ),),
4059                encoder,
4060                offset,
4061                _depth,
4062            )
4063        }
4064    }
4065    unsafe impl<
4066            D: fidl::encoding::ResourceDialect,
4067            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
4068        > fidl::encoding::Encode<ManifestBytesIteratorNextResponse, D> for (T0,)
4069    {
4070        #[inline]
4071        unsafe fn encode(
4072            self,
4073            encoder: &mut fidl::encoding::Encoder<'_, D>,
4074            offset: usize,
4075            depth: fidl::encoding::Depth,
4076        ) -> fidl::Result<()> {
4077            encoder.debug_check_bounds::<ManifestBytesIteratorNextResponse>(offset);
4078            // Zero out padding regions. There's no need to apply masks
4079            // because the unmasked parts will be overwritten by fields.
4080            // Write the fields.
4081            self.0.encode(encoder, offset + 0, depth)?;
4082            Ok(())
4083        }
4084    }
4085
4086    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4087        for ManifestBytesIteratorNextResponse
4088    {
4089        #[inline(always)]
4090        fn new_empty() -> Self {
4091            Self { infos: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D) }
4092        }
4093
4094        #[inline]
4095        unsafe fn decode(
4096            &mut self,
4097            decoder: &mut fidl::encoding::Decoder<'_, D>,
4098            offset: usize,
4099            _depth: fidl::encoding::Depth,
4100        ) -> fidl::Result<()> {
4101            decoder.debug_check_bounds::<Self>(offset);
4102            // Verify that padding bytes are zero.
4103            fidl::decode!(
4104                fidl::encoding::UnboundedVector<u8>,
4105                D,
4106                &mut self.infos,
4107                decoder,
4108                offset + 0,
4109                _depth
4110            )?;
4111            Ok(())
4112        }
4113    }
4114
4115    impl fidl::encoding::ValueTypeMarker for RealmQueryConstructNamespaceRequest {
4116        type Borrowed<'a> = &'a Self;
4117        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4118            value
4119        }
4120    }
4121
4122    unsafe impl fidl::encoding::TypeMarker for RealmQueryConstructNamespaceRequest {
4123        type Owned = Self;
4124
4125        #[inline(always)]
4126        fn inline_align(_context: fidl::encoding::Context) -> usize {
4127            8
4128        }
4129
4130        #[inline(always)]
4131        fn inline_size(_context: fidl::encoding::Context) -> usize {
4132            16
4133        }
4134    }
4135
4136    unsafe impl<D: fidl::encoding::ResourceDialect>
4137        fidl::encoding::Encode<RealmQueryConstructNamespaceRequest, D>
4138        for &RealmQueryConstructNamespaceRequest
4139    {
4140        #[inline]
4141        unsafe fn encode(
4142            self,
4143            encoder: &mut fidl::encoding::Encoder<'_, D>,
4144            offset: usize,
4145            _depth: fidl::encoding::Depth,
4146        ) -> fidl::Result<()> {
4147            encoder.debug_check_bounds::<RealmQueryConstructNamespaceRequest>(offset);
4148            // Delegate to tuple encoding.
4149            fidl::encoding::Encode::<RealmQueryConstructNamespaceRequest, D>::encode(
4150                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
4151                    &self.moniker,
4152                ),),
4153                encoder,
4154                offset,
4155                _depth,
4156            )
4157        }
4158    }
4159    unsafe impl<
4160            D: fidl::encoding::ResourceDialect,
4161            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
4162        > fidl::encoding::Encode<RealmQueryConstructNamespaceRequest, D> for (T0,)
4163    {
4164        #[inline]
4165        unsafe fn encode(
4166            self,
4167            encoder: &mut fidl::encoding::Encoder<'_, D>,
4168            offset: usize,
4169            depth: fidl::encoding::Depth,
4170        ) -> fidl::Result<()> {
4171            encoder.debug_check_bounds::<RealmQueryConstructNamespaceRequest>(offset);
4172            // Zero out padding regions. There's no need to apply masks
4173            // because the unmasked parts will be overwritten by fields.
4174            // Write the fields.
4175            self.0.encode(encoder, offset + 0, depth)?;
4176            Ok(())
4177        }
4178    }
4179
4180    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4181        for RealmQueryConstructNamespaceRequest
4182    {
4183        #[inline(always)]
4184        fn new_empty() -> Self {
4185            Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
4186        }
4187
4188        #[inline]
4189        unsafe fn decode(
4190            &mut self,
4191            decoder: &mut fidl::encoding::Decoder<'_, D>,
4192            offset: usize,
4193            _depth: fidl::encoding::Depth,
4194        ) -> fidl::Result<()> {
4195            decoder.debug_check_bounds::<Self>(offset);
4196            // Verify that padding bytes are zero.
4197            fidl::decode!(
4198                fidl::encoding::BoundedString<4096>,
4199                D,
4200                &mut self.moniker,
4201                decoder,
4202                offset + 0,
4203                _depth
4204            )?;
4205            Ok(())
4206        }
4207    }
4208
4209    impl fidl::encoding::ValueTypeMarker for RealmQueryGetInstanceRequest {
4210        type Borrowed<'a> = &'a Self;
4211        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4212            value
4213        }
4214    }
4215
4216    unsafe impl fidl::encoding::TypeMarker for RealmQueryGetInstanceRequest {
4217        type Owned = Self;
4218
4219        #[inline(always)]
4220        fn inline_align(_context: fidl::encoding::Context) -> usize {
4221            8
4222        }
4223
4224        #[inline(always)]
4225        fn inline_size(_context: fidl::encoding::Context) -> usize {
4226            16
4227        }
4228    }
4229
4230    unsafe impl<D: fidl::encoding::ResourceDialect>
4231        fidl::encoding::Encode<RealmQueryGetInstanceRequest, D> for &RealmQueryGetInstanceRequest
4232    {
4233        #[inline]
4234        unsafe fn encode(
4235            self,
4236            encoder: &mut fidl::encoding::Encoder<'_, D>,
4237            offset: usize,
4238            _depth: fidl::encoding::Depth,
4239        ) -> fidl::Result<()> {
4240            encoder.debug_check_bounds::<RealmQueryGetInstanceRequest>(offset);
4241            // Delegate to tuple encoding.
4242            fidl::encoding::Encode::<RealmQueryGetInstanceRequest, D>::encode(
4243                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
4244                    &self.moniker,
4245                ),),
4246                encoder,
4247                offset,
4248                _depth,
4249            )
4250        }
4251    }
4252    unsafe impl<
4253            D: fidl::encoding::ResourceDialect,
4254            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
4255        > fidl::encoding::Encode<RealmQueryGetInstanceRequest, D> for (T0,)
4256    {
4257        #[inline]
4258        unsafe fn encode(
4259            self,
4260            encoder: &mut fidl::encoding::Encoder<'_, D>,
4261            offset: usize,
4262            depth: fidl::encoding::Depth,
4263        ) -> fidl::Result<()> {
4264            encoder.debug_check_bounds::<RealmQueryGetInstanceRequest>(offset);
4265            // Zero out padding regions. There's no need to apply masks
4266            // because the unmasked parts will be overwritten by fields.
4267            // Write the fields.
4268            self.0.encode(encoder, offset + 0, depth)?;
4269            Ok(())
4270        }
4271    }
4272
4273    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4274        for RealmQueryGetInstanceRequest
4275    {
4276        #[inline(always)]
4277        fn new_empty() -> Self {
4278            Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
4279        }
4280
4281        #[inline]
4282        unsafe fn decode(
4283            &mut self,
4284            decoder: &mut fidl::encoding::Decoder<'_, D>,
4285            offset: usize,
4286            _depth: fidl::encoding::Depth,
4287        ) -> fidl::Result<()> {
4288            decoder.debug_check_bounds::<Self>(offset);
4289            // Verify that padding bytes are zero.
4290            fidl::decode!(
4291                fidl::encoding::BoundedString<4096>,
4292                D,
4293                &mut self.moniker,
4294                decoder,
4295                offset + 0,
4296                _depth
4297            )?;
4298            Ok(())
4299        }
4300    }
4301
4302    impl fidl::encoding::ValueTypeMarker for RealmQueryGetManifestRequest {
4303        type Borrowed<'a> = &'a Self;
4304        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4305            value
4306        }
4307    }
4308
4309    unsafe impl fidl::encoding::TypeMarker for RealmQueryGetManifestRequest {
4310        type Owned = Self;
4311
4312        #[inline(always)]
4313        fn inline_align(_context: fidl::encoding::Context) -> usize {
4314            8
4315        }
4316
4317        #[inline(always)]
4318        fn inline_size(_context: fidl::encoding::Context) -> usize {
4319            16
4320        }
4321    }
4322
4323    unsafe impl<D: fidl::encoding::ResourceDialect>
4324        fidl::encoding::Encode<RealmQueryGetManifestRequest, D> for &RealmQueryGetManifestRequest
4325    {
4326        #[inline]
4327        unsafe fn encode(
4328            self,
4329            encoder: &mut fidl::encoding::Encoder<'_, D>,
4330            offset: usize,
4331            _depth: fidl::encoding::Depth,
4332        ) -> fidl::Result<()> {
4333            encoder.debug_check_bounds::<RealmQueryGetManifestRequest>(offset);
4334            // Delegate to tuple encoding.
4335            fidl::encoding::Encode::<RealmQueryGetManifestRequest, D>::encode(
4336                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
4337                    &self.moniker,
4338                ),),
4339                encoder,
4340                offset,
4341                _depth,
4342            )
4343        }
4344    }
4345    unsafe impl<
4346            D: fidl::encoding::ResourceDialect,
4347            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
4348        > fidl::encoding::Encode<RealmQueryGetManifestRequest, D> for (T0,)
4349    {
4350        #[inline]
4351        unsafe fn encode(
4352            self,
4353            encoder: &mut fidl::encoding::Encoder<'_, D>,
4354            offset: usize,
4355            depth: fidl::encoding::Depth,
4356        ) -> fidl::Result<()> {
4357            encoder.debug_check_bounds::<RealmQueryGetManifestRequest>(offset);
4358            // Zero out padding regions. There's no need to apply masks
4359            // because the unmasked parts will be overwritten by fields.
4360            // Write the fields.
4361            self.0.encode(encoder, offset + 0, depth)?;
4362            Ok(())
4363        }
4364    }
4365
4366    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4367        for RealmQueryGetManifestRequest
4368    {
4369        #[inline(always)]
4370        fn new_empty() -> Self {
4371            Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
4372        }
4373
4374        #[inline]
4375        unsafe fn decode(
4376            &mut self,
4377            decoder: &mut fidl::encoding::Decoder<'_, D>,
4378            offset: usize,
4379            _depth: fidl::encoding::Depth,
4380        ) -> fidl::Result<()> {
4381            decoder.debug_check_bounds::<Self>(offset);
4382            // Verify that padding bytes are zero.
4383            fidl::decode!(
4384                fidl::encoding::BoundedString<4096>,
4385                D,
4386                &mut self.moniker,
4387                decoder,
4388                offset + 0,
4389                _depth
4390            )?;
4391            Ok(())
4392        }
4393    }
4394
4395    impl fidl::encoding::ValueTypeMarker for RealmQueryGetResolvedDeclarationRequest {
4396        type Borrowed<'a> = &'a Self;
4397        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4398            value
4399        }
4400    }
4401
4402    unsafe impl fidl::encoding::TypeMarker for RealmQueryGetResolvedDeclarationRequest {
4403        type Owned = Self;
4404
4405        #[inline(always)]
4406        fn inline_align(_context: fidl::encoding::Context) -> usize {
4407            8
4408        }
4409
4410        #[inline(always)]
4411        fn inline_size(_context: fidl::encoding::Context) -> usize {
4412            16
4413        }
4414    }
4415
4416    unsafe impl<D: fidl::encoding::ResourceDialect>
4417        fidl::encoding::Encode<RealmQueryGetResolvedDeclarationRequest, D>
4418        for &RealmQueryGetResolvedDeclarationRequest
4419    {
4420        #[inline]
4421        unsafe fn encode(
4422            self,
4423            encoder: &mut fidl::encoding::Encoder<'_, D>,
4424            offset: usize,
4425            _depth: fidl::encoding::Depth,
4426        ) -> fidl::Result<()> {
4427            encoder.debug_check_bounds::<RealmQueryGetResolvedDeclarationRequest>(offset);
4428            // Delegate to tuple encoding.
4429            fidl::encoding::Encode::<RealmQueryGetResolvedDeclarationRequest, D>::encode(
4430                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
4431                    &self.moniker,
4432                ),),
4433                encoder,
4434                offset,
4435                _depth,
4436            )
4437        }
4438    }
4439    unsafe impl<
4440            D: fidl::encoding::ResourceDialect,
4441            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
4442        > fidl::encoding::Encode<RealmQueryGetResolvedDeclarationRequest, D> for (T0,)
4443    {
4444        #[inline]
4445        unsafe fn encode(
4446            self,
4447            encoder: &mut fidl::encoding::Encoder<'_, D>,
4448            offset: usize,
4449            depth: fidl::encoding::Depth,
4450        ) -> fidl::Result<()> {
4451            encoder.debug_check_bounds::<RealmQueryGetResolvedDeclarationRequest>(offset);
4452            // Zero out padding regions. There's no need to apply masks
4453            // because the unmasked parts will be overwritten by fields.
4454            // Write the fields.
4455            self.0.encode(encoder, offset + 0, depth)?;
4456            Ok(())
4457        }
4458    }
4459
4460    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4461        for RealmQueryGetResolvedDeclarationRequest
4462    {
4463        #[inline(always)]
4464        fn new_empty() -> Self {
4465            Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
4466        }
4467
4468        #[inline]
4469        unsafe fn decode(
4470            &mut self,
4471            decoder: &mut fidl::encoding::Decoder<'_, D>,
4472            offset: usize,
4473            _depth: fidl::encoding::Depth,
4474        ) -> fidl::Result<()> {
4475            decoder.debug_check_bounds::<Self>(offset);
4476            // Verify that padding bytes are zero.
4477            fidl::decode!(
4478                fidl::encoding::BoundedString<4096>,
4479                D,
4480                &mut self.moniker,
4481                decoder,
4482                offset + 0,
4483                _depth
4484            )?;
4485            Ok(())
4486        }
4487    }
4488
4489    impl fidl::encoding::ValueTypeMarker for RealmQueryGetStructuredConfigRequest {
4490        type Borrowed<'a> = &'a Self;
4491        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4492            value
4493        }
4494    }
4495
4496    unsafe impl fidl::encoding::TypeMarker for RealmQueryGetStructuredConfigRequest {
4497        type Owned = Self;
4498
4499        #[inline(always)]
4500        fn inline_align(_context: fidl::encoding::Context) -> usize {
4501            8
4502        }
4503
4504        #[inline(always)]
4505        fn inline_size(_context: fidl::encoding::Context) -> usize {
4506            16
4507        }
4508    }
4509
4510    unsafe impl<D: fidl::encoding::ResourceDialect>
4511        fidl::encoding::Encode<RealmQueryGetStructuredConfigRequest, D>
4512        for &RealmQueryGetStructuredConfigRequest
4513    {
4514        #[inline]
4515        unsafe fn encode(
4516            self,
4517            encoder: &mut fidl::encoding::Encoder<'_, D>,
4518            offset: usize,
4519            _depth: fidl::encoding::Depth,
4520        ) -> fidl::Result<()> {
4521            encoder.debug_check_bounds::<RealmQueryGetStructuredConfigRequest>(offset);
4522            // Delegate to tuple encoding.
4523            fidl::encoding::Encode::<RealmQueryGetStructuredConfigRequest, D>::encode(
4524                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
4525                    &self.moniker,
4526                ),),
4527                encoder,
4528                offset,
4529                _depth,
4530            )
4531        }
4532    }
4533    unsafe impl<
4534            D: fidl::encoding::ResourceDialect,
4535            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
4536        > fidl::encoding::Encode<RealmQueryGetStructuredConfigRequest, D> for (T0,)
4537    {
4538        #[inline]
4539        unsafe fn encode(
4540            self,
4541            encoder: &mut fidl::encoding::Encoder<'_, D>,
4542            offset: usize,
4543            depth: fidl::encoding::Depth,
4544        ) -> fidl::Result<()> {
4545            encoder.debug_check_bounds::<RealmQueryGetStructuredConfigRequest>(offset);
4546            // Zero out padding regions. There's no need to apply masks
4547            // because the unmasked parts will be overwritten by fields.
4548            // Write the fields.
4549            self.0.encode(encoder, offset + 0, depth)?;
4550            Ok(())
4551        }
4552    }
4553
4554    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4555        for RealmQueryGetStructuredConfigRequest
4556    {
4557        #[inline(always)]
4558        fn new_empty() -> Self {
4559            Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
4560        }
4561
4562        #[inline]
4563        unsafe fn decode(
4564            &mut self,
4565            decoder: &mut fidl::encoding::Decoder<'_, D>,
4566            offset: usize,
4567            _depth: fidl::encoding::Depth,
4568        ) -> fidl::Result<()> {
4569            decoder.debug_check_bounds::<Self>(offset);
4570            // Verify that padding bytes are zero.
4571            fidl::decode!(
4572                fidl::encoding::BoundedString<4096>,
4573                D,
4574                &mut self.moniker,
4575                decoder,
4576                offset + 0,
4577                _depth
4578            )?;
4579            Ok(())
4580        }
4581    }
4582
4583    impl fidl::encoding::ValueTypeMarker for RealmQueryResolveDeclarationRequest {
4584        type Borrowed<'a> = &'a Self;
4585        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4586            value
4587        }
4588    }
4589
4590    unsafe impl fidl::encoding::TypeMarker for RealmQueryResolveDeclarationRequest {
4591        type Owned = Self;
4592
4593        #[inline(always)]
4594        fn inline_align(_context: fidl::encoding::Context) -> usize {
4595            8
4596        }
4597
4598        #[inline(always)]
4599        fn inline_size(_context: fidl::encoding::Context) -> usize {
4600            48
4601        }
4602    }
4603
4604    unsafe impl<D: fidl::encoding::ResourceDialect>
4605        fidl::encoding::Encode<RealmQueryResolveDeclarationRequest, D>
4606        for &RealmQueryResolveDeclarationRequest
4607    {
4608        #[inline]
4609        unsafe fn encode(
4610            self,
4611            encoder: &mut fidl::encoding::Encoder<'_, D>,
4612            offset: usize,
4613            _depth: fidl::encoding::Depth,
4614        ) -> fidl::Result<()> {
4615            encoder.debug_check_bounds::<RealmQueryResolveDeclarationRequest>(offset);
4616            // Delegate to tuple encoding.
4617            fidl::encoding::Encode::<RealmQueryResolveDeclarationRequest, D>::encode(
4618                (
4619                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.parent),
4620                    <ChildLocation as fidl::encoding::ValueTypeMarker>::borrow(&self.child_location),
4621                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.url),
4622                ),
4623                encoder, offset, _depth
4624            )
4625        }
4626    }
4627    unsafe impl<
4628            D: fidl::encoding::ResourceDialect,
4629            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
4630            T1: fidl::encoding::Encode<ChildLocation, D>,
4631            T2: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
4632        > fidl::encoding::Encode<RealmQueryResolveDeclarationRequest, D> for (T0, T1, T2)
4633    {
4634        #[inline]
4635        unsafe fn encode(
4636            self,
4637            encoder: &mut fidl::encoding::Encoder<'_, D>,
4638            offset: usize,
4639            depth: fidl::encoding::Depth,
4640        ) -> fidl::Result<()> {
4641            encoder.debug_check_bounds::<RealmQueryResolveDeclarationRequest>(offset);
4642            // Zero out padding regions. There's no need to apply masks
4643            // because the unmasked parts will be overwritten by fields.
4644            // Write the fields.
4645            self.0.encode(encoder, offset + 0, depth)?;
4646            self.1.encode(encoder, offset + 16, depth)?;
4647            self.2.encode(encoder, offset + 32, depth)?;
4648            Ok(())
4649        }
4650    }
4651
4652    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4653        for RealmQueryResolveDeclarationRequest
4654    {
4655        #[inline(always)]
4656        fn new_empty() -> Self {
4657            Self {
4658                parent: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
4659                child_location: fidl::new_empty!(ChildLocation, D),
4660                url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
4661            }
4662        }
4663
4664        #[inline]
4665        unsafe fn decode(
4666            &mut self,
4667            decoder: &mut fidl::encoding::Decoder<'_, D>,
4668            offset: usize,
4669            _depth: fidl::encoding::Depth,
4670        ) -> fidl::Result<()> {
4671            decoder.debug_check_bounds::<Self>(offset);
4672            // Verify that padding bytes are zero.
4673            fidl::decode!(
4674                fidl::encoding::BoundedString<4096>,
4675                D,
4676                &mut self.parent,
4677                decoder,
4678                offset + 0,
4679                _depth
4680            )?;
4681            fidl::decode!(
4682                ChildLocation,
4683                D,
4684                &mut self.child_location,
4685                decoder,
4686                offset + 16,
4687                _depth
4688            )?;
4689            fidl::decode!(
4690                fidl::encoding::BoundedString<4096>,
4691                D,
4692                &mut self.url,
4693                decoder,
4694                offset + 32,
4695                _depth
4696            )?;
4697            Ok(())
4698        }
4699    }
4700
4701    impl fidl::encoding::ValueTypeMarker for RealmQueryGetInstanceResponse {
4702        type Borrowed<'a> = &'a Self;
4703        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4704            value
4705        }
4706    }
4707
4708    unsafe impl fidl::encoding::TypeMarker for RealmQueryGetInstanceResponse {
4709        type Owned = Self;
4710
4711        #[inline(always)]
4712        fn inline_align(_context: fidl::encoding::Context) -> usize {
4713            8
4714        }
4715
4716        #[inline(always)]
4717        fn inline_size(_context: fidl::encoding::Context) -> usize {
4718            16
4719        }
4720    }
4721
4722    unsafe impl<D: fidl::encoding::ResourceDialect>
4723        fidl::encoding::Encode<RealmQueryGetInstanceResponse, D>
4724        for &RealmQueryGetInstanceResponse
4725    {
4726        #[inline]
4727        unsafe fn encode(
4728            self,
4729            encoder: &mut fidl::encoding::Encoder<'_, D>,
4730            offset: usize,
4731            _depth: fidl::encoding::Depth,
4732        ) -> fidl::Result<()> {
4733            encoder.debug_check_bounds::<RealmQueryGetInstanceResponse>(offset);
4734            // Delegate to tuple encoding.
4735            fidl::encoding::Encode::<RealmQueryGetInstanceResponse, D>::encode(
4736                (<Instance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),),
4737                encoder,
4738                offset,
4739                _depth,
4740            )
4741        }
4742    }
4743    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Instance, D>>
4744        fidl::encoding::Encode<RealmQueryGetInstanceResponse, D> for (T0,)
4745    {
4746        #[inline]
4747        unsafe fn encode(
4748            self,
4749            encoder: &mut fidl::encoding::Encoder<'_, D>,
4750            offset: usize,
4751            depth: fidl::encoding::Depth,
4752        ) -> fidl::Result<()> {
4753            encoder.debug_check_bounds::<RealmQueryGetInstanceResponse>(offset);
4754            // Zero out padding regions. There's no need to apply masks
4755            // because the unmasked parts will be overwritten by fields.
4756            // Write the fields.
4757            self.0.encode(encoder, offset + 0, depth)?;
4758            Ok(())
4759        }
4760    }
4761
4762    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4763        for RealmQueryGetInstanceResponse
4764    {
4765        #[inline(always)]
4766        fn new_empty() -> Self {
4767            Self { instance: fidl::new_empty!(Instance, D) }
4768        }
4769
4770        #[inline]
4771        unsafe fn decode(
4772            &mut self,
4773            decoder: &mut fidl::encoding::Decoder<'_, D>,
4774            offset: usize,
4775            _depth: fidl::encoding::Depth,
4776        ) -> fidl::Result<()> {
4777            decoder.debug_check_bounds::<Self>(offset);
4778            // Verify that padding bytes are zero.
4779            fidl::decode!(Instance, D, &mut self.instance, decoder, offset + 0, _depth)?;
4780            Ok(())
4781        }
4782    }
4783
4784    impl fidl::encoding::ValueTypeMarker for RealmQueryGetStructuredConfigResponse {
4785        type Borrowed<'a> = &'a Self;
4786        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4787            value
4788        }
4789    }
4790
4791    unsafe impl fidl::encoding::TypeMarker for RealmQueryGetStructuredConfigResponse {
4792        type Owned = Self;
4793
4794        #[inline(always)]
4795        fn inline_align(_context: fidl::encoding::Context) -> usize {
4796            8
4797        }
4798
4799        #[inline(always)]
4800        fn inline_size(_context: fidl::encoding::Context) -> usize {
4801            32
4802        }
4803    }
4804
4805    unsafe impl<D: fidl::encoding::ResourceDialect>
4806        fidl::encoding::Encode<RealmQueryGetStructuredConfigResponse, D>
4807        for &RealmQueryGetStructuredConfigResponse
4808    {
4809        #[inline]
4810        unsafe fn encode(
4811            self,
4812            encoder: &mut fidl::encoding::Encoder<'_, D>,
4813            offset: usize,
4814            _depth: fidl::encoding::Depth,
4815        ) -> fidl::Result<()> {
4816            encoder.debug_check_bounds::<RealmQueryGetStructuredConfigResponse>(offset);
4817            // Delegate to tuple encoding.
4818            fidl::encoding::Encode::<RealmQueryGetStructuredConfigResponse, D>::encode(
4819                (
4820                    <fidl_fuchsia_component_decl__common::ResolvedConfig as fidl::encoding::ValueTypeMarker>::borrow(&self.config),
4821                ),
4822                encoder, offset, _depth
4823            )
4824        }
4825    }
4826    unsafe impl<
4827            D: fidl::encoding::ResourceDialect,
4828            T0: fidl::encoding::Encode<fidl_fuchsia_component_decl__common::ResolvedConfig, D>,
4829        > fidl::encoding::Encode<RealmQueryGetStructuredConfigResponse, D> for (T0,)
4830    {
4831        #[inline]
4832        unsafe fn encode(
4833            self,
4834            encoder: &mut fidl::encoding::Encoder<'_, D>,
4835            offset: usize,
4836            depth: fidl::encoding::Depth,
4837        ) -> fidl::Result<()> {
4838            encoder.debug_check_bounds::<RealmQueryGetStructuredConfigResponse>(offset);
4839            // Zero out padding regions. There's no need to apply masks
4840            // because the unmasked parts will be overwritten by fields.
4841            // Write the fields.
4842            self.0.encode(encoder, offset + 0, depth)?;
4843            Ok(())
4844        }
4845    }
4846
4847    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4848        for RealmQueryGetStructuredConfigResponse
4849    {
4850        #[inline(always)]
4851        fn new_empty() -> Self {
4852            Self {
4853                config: fidl::new_empty!(fidl_fuchsia_component_decl__common::ResolvedConfig, D),
4854            }
4855        }
4856
4857        #[inline]
4858        unsafe fn decode(
4859            &mut self,
4860            decoder: &mut fidl::encoding::Decoder<'_, D>,
4861            offset: usize,
4862            _depth: fidl::encoding::Depth,
4863        ) -> fidl::Result<()> {
4864            decoder.debug_check_bounds::<Self>(offset);
4865            // Verify that padding bytes are zero.
4866            fidl::decode!(
4867                fidl_fuchsia_component_decl__common::ResolvedConfig,
4868                D,
4869                &mut self.config,
4870                decoder,
4871                offset + 0,
4872                _depth
4873            )?;
4874            Ok(())
4875        }
4876    }
4877
4878    impl fidl::encoding::ValueTypeMarker for RouteTarget {
4879        type Borrowed<'a> = &'a Self;
4880        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4881            value
4882        }
4883    }
4884
4885    unsafe impl fidl::encoding::TypeMarker for RouteTarget {
4886        type Owned = Self;
4887
4888        #[inline(always)]
4889        fn inline_align(_context: fidl::encoding::Context) -> usize {
4890            8
4891        }
4892
4893        #[inline(always)]
4894        fn inline_size(_context: fidl::encoding::Context) -> usize {
4895            24
4896        }
4897    }
4898
4899    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RouteTarget, D>
4900        for &RouteTarget
4901    {
4902        #[inline]
4903        unsafe fn encode(
4904            self,
4905            encoder: &mut fidl::encoding::Encoder<'_, D>,
4906            offset: usize,
4907            _depth: fidl::encoding::Depth,
4908        ) -> fidl::Result<()> {
4909            encoder.debug_check_bounds::<RouteTarget>(offset);
4910            // Delegate to tuple encoding.
4911            fidl::encoding::Encode::<RouteTarget, D>::encode(
4912                (
4913                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
4914                        &self.name,
4915                    ),
4916                    <DeclType as fidl::encoding::ValueTypeMarker>::borrow(&self.decl_type),
4917                ),
4918                encoder,
4919                offset,
4920                _depth,
4921            )
4922        }
4923    }
4924    unsafe impl<
4925            D: fidl::encoding::ResourceDialect,
4926            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
4927            T1: fidl::encoding::Encode<DeclType, D>,
4928        > fidl::encoding::Encode<RouteTarget, D> for (T0, T1)
4929    {
4930        #[inline]
4931        unsafe fn encode(
4932            self,
4933            encoder: &mut fidl::encoding::Encoder<'_, D>,
4934            offset: usize,
4935            depth: fidl::encoding::Depth,
4936        ) -> fidl::Result<()> {
4937            encoder.debug_check_bounds::<RouteTarget>(offset);
4938            // Zero out padding regions. There's no need to apply masks
4939            // because the unmasked parts will be overwritten by fields.
4940            unsafe {
4941                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
4942                (ptr as *mut u64).write_unaligned(0);
4943            }
4944            // Write the fields.
4945            self.0.encode(encoder, offset + 0, depth)?;
4946            self.1.encode(encoder, offset + 16, depth)?;
4947            Ok(())
4948        }
4949    }
4950
4951    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RouteTarget {
4952        #[inline(always)]
4953        fn new_empty() -> Self {
4954            Self {
4955                name: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
4956                decl_type: fidl::new_empty!(DeclType, D),
4957            }
4958        }
4959
4960        #[inline]
4961        unsafe fn decode(
4962            &mut self,
4963            decoder: &mut fidl::encoding::Decoder<'_, D>,
4964            offset: usize,
4965            _depth: fidl::encoding::Depth,
4966        ) -> fidl::Result<()> {
4967            decoder.debug_check_bounds::<Self>(offset);
4968            // Verify that padding bytes are zero.
4969            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
4970            let padval = unsafe { (ptr as *const u64).read_unaligned() };
4971            let mask = 0xffffffff00000000u64;
4972            let maskedval = padval & mask;
4973            if maskedval != 0 {
4974                return Err(fidl::Error::NonZeroPadding {
4975                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
4976                });
4977            }
4978            fidl::decode!(
4979                fidl::encoding::BoundedString<255>,
4980                D,
4981                &mut self.name,
4982                decoder,
4983                offset + 0,
4984                _depth
4985            )?;
4986            fidl::decode!(DeclType, D, &mut self.decl_type, decoder, offset + 16, _depth)?;
4987            Ok(())
4988        }
4989    }
4990
4991    impl fidl::encoding::ValueTypeMarker for RouteValidatorRouteRequest {
4992        type Borrowed<'a> = &'a Self;
4993        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4994            value
4995        }
4996    }
4997
4998    unsafe impl fidl::encoding::TypeMarker for RouteValidatorRouteRequest {
4999        type Owned = Self;
5000
5001        #[inline(always)]
5002        fn inline_align(_context: fidl::encoding::Context) -> usize {
5003            8
5004        }
5005
5006        #[inline(always)]
5007        fn inline_size(_context: fidl::encoding::Context) -> usize {
5008            32
5009        }
5010    }
5011
5012    unsafe impl<D: fidl::encoding::ResourceDialect>
5013        fidl::encoding::Encode<RouteValidatorRouteRequest, D> for &RouteValidatorRouteRequest
5014    {
5015        #[inline]
5016        unsafe fn encode(
5017            self,
5018            encoder: &mut fidl::encoding::Encoder<'_, D>,
5019            offset: usize,
5020            _depth: fidl::encoding::Depth,
5021        ) -> fidl::Result<()> {
5022            encoder.debug_check_bounds::<RouteValidatorRouteRequest>(offset);
5023            // Delegate to tuple encoding.
5024            fidl::encoding::Encode::<RouteValidatorRouteRequest, D>::encode(
5025                (
5026                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.moniker),
5027                    <fidl::encoding::UnboundedVector<RouteTarget> as fidl::encoding::ValueTypeMarker>::borrow(&self.targets),
5028                ),
5029                encoder, offset, _depth
5030            )
5031        }
5032    }
5033    unsafe impl<
5034            D: fidl::encoding::ResourceDialect,
5035            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
5036            T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<RouteTarget>, D>,
5037        > fidl::encoding::Encode<RouteValidatorRouteRequest, D> for (T0, T1)
5038    {
5039        #[inline]
5040        unsafe fn encode(
5041            self,
5042            encoder: &mut fidl::encoding::Encoder<'_, D>,
5043            offset: usize,
5044            depth: fidl::encoding::Depth,
5045        ) -> fidl::Result<()> {
5046            encoder.debug_check_bounds::<RouteValidatorRouteRequest>(offset);
5047            // Zero out padding regions. There's no need to apply masks
5048            // because the unmasked parts will be overwritten by fields.
5049            // Write the fields.
5050            self.0.encode(encoder, offset + 0, depth)?;
5051            self.1.encode(encoder, offset + 16, depth)?;
5052            Ok(())
5053        }
5054    }
5055
5056    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5057        for RouteValidatorRouteRequest
5058    {
5059        #[inline(always)]
5060        fn new_empty() -> Self {
5061            Self {
5062                moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D),
5063                targets: fidl::new_empty!(fidl::encoding::UnboundedVector<RouteTarget>, D),
5064            }
5065        }
5066
5067        #[inline]
5068        unsafe fn decode(
5069            &mut self,
5070            decoder: &mut fidl::encoding::Decoder<'_, D>,
5071            offset: usize,
5072            _depth: fidl::encoding::Depth,
5073        ) -> fidl::Result<()> {
5074            decoder.debug_check_bounds::<Self>(offset);
5075            // Verify that padding bytes are zero.
5076            fidl::decode!(
5077                fidl::encoding::BoundedString<4096>,
5078                D,
5079                &mut self.moniker,
5080                decoder,
5081                offset + 0,
5082                _depth
5083            )?;
5084            fidl::decode!(
5085                fidl::encoding::UnboundedVector<RouteTarget>,
5086                D,
5087                &mut self.targets,
5088                decoder,
5089                offset + 16,
5090                _depth
5091            )?;
5092            Ok(())
5093        }
5094    }
5095
5096    impl fidl::encoding::ValueTypeMarker for RouteValidatorValidateRequest {
5097        type Borrowed<'a> = &'a Self;
5098        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5099            value
5100        }
5101    }
5102
5103    unsafe impl fidl::encoding::TypeMarker for RouteValidatorValidateRequest {
5104        type Owned = Self;
5105
5106        #[inline(always)]
5107        fn inline_align(_context: fidl::encoding::Context) -> usize {
5108            8
5109        }
5110
5111        #[inline(always)]
5112        fn inline_size(_context: fidl::encoding::Context) -> usize {
5113            16
5114        }
5115    }
5116
5117    unsafe impl<D: fidl::encoding::ResourceDialect>
5118        fidl::encoding::Encode<RouteValidatorValidateRequest, D>
5119        for &RouteValidatorValidateRequest
5120    {
5121        #[inline]
5122        unsafe fn encode(
5123            self,
5124            encoder: &mut fidl::encoding::Encoder<'_, D>,
5125            offset: usize,
5126            _depth: fidl::encoding::Depth,
5127        ) -> fidl::Result<()> {
5128            encoder.debug_check_bounds::<RouteValidatorValidateRequest>(offset);
5129            // Delegate to tuple encoding.
5130            fidl::encoding::Encode::<RouteValidatorValidateRequest, D>::encode(
5131                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
5132                    &self.moniker,
5133                ),),
5134                encoder,
5135                offset,
5136                _depth,
5137            )
5138        }
5139    }
5140    unsafe impl<
5141            D: fidl::encoding::ResourceDialect,
5142            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
5143        > fidl::encoding::Encode<RouteValidatorValidateRequest, D> for (T0,)
5144    {
5145        #[inline]
5146        unsafe fn encode(
5147            self,
5148            encoder: &mut fidl::encoding::Encoder<'_, D>,
5149            offset: usize,
5150            depth: fidl::encoding::Depth,
5151        ) -> fidl::Result<()> {
5152            encoder.debug_check_bounds::<RouteValidatorValidateRequest>(offset);
5153            // Zero out padding regions. There's no need to apply masks
5154            // because the unmasked parts will be overwritten by fields.
5155            // Write the fields.
5156            self.0.encode(encoder, offset + 0, depth)?;
5157            Ok(())
5158        }
5159    }
5160
5161    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5162        for RouteValidatorValidateRequest
5163    {
5164        #[inline(always)]
5165        fn new_empty() -> Self {
5166            Self { moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
5167        }
5168
5169        #[inline]
5170        unsafe fn decode(
5171            &mut self,
5172            decoder: &mut fidl::encoding::Decoder<'_, D>,
5173            offset: usize,
5174            _depth: fidl::encoding::Depth,
5175        ) -> fidl::Result<()> {
5176            decoder.debug_check_bounds::<Self>(offset);
5177            // Verify that padding bytes are zero.
5178            fidl::decode!(
5179                fidl::encoding::BoundedString<4096>,
5180                D,
5181                &mut self.moniker,
5182                decoder,
5183                offset + 0,
5184                _depth
5185            )?;
5186            Ok(())
5187        }
5188    }
5189
5190    impl fidl::encoding::ValueTypeMarker for RouteValidatorRouteResponse {
5191        type Borrowed<'a> = &'a Self;
5192        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5193            value
5194        }
5195    }
5196
5197    unsafe impl fidl::encoding::TypeMarker for RouteValidatorRouteResponse {
5198        type Owned = Self;
5199
5200        #[inline(always)]
5201        fn inline_align(_context: fidl::encoding::Context) -> usize {
5202            8
5203        }
5204
5205        #[inline(always)]
5206        fn inline_size(_context: fidl::encoding::Context) -> usize {
5207            16
5208        }
5209    }
5210
5211    unsafe impl<D: fidl::encoding::ResourceDialect>
5212        fidl::encoding::Encode<RouteValidatorRouteResponse, D> for &RouteValidatorRouteResponse
5213    {
5214        #[inline]
5215        unsafe fn encode(
5216            self,
5217            encoder: &mut fidl::encoding::Encoder<'_, D>,
5218            offset: usize,
5219            _depth: fidl::encoding::Depth,
5220        ) -> fidl::Result<()> {
5221            encoder.debug_check_bounds::<RouteValidatorRouteResponse>(offset);
5222            // Delegate to tuple encoding.
5223            fidl::encoding::Encode::<RouteValidatorRouteResponse, D>::encode(
5224                (
5225                    <fidl::encoding::UnboundedVector<RouteReport> as fidl::encoding::ValueTypeMarker>::borrow(&self.reports),
5226                ),
5227                encoder, offset, _depth
5228            )
5229        }
5230    }
5231    unsafe impl<
5232            D: fidl::encoding::ResourceDialect,
5233            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<RouteReport>, D>,
5234        > fidl::encoding::Encode<RouteValidatorRouteResponse, D> for (T0,)
5235    {
5236        #[inline]
5237        unsafe fn encode(
5238            self,
5239            encoder: &mut fidl::encoding::Encoder<'_, D>,
5240            offset: usize,
5241            depth: fidl::encoding::Depth,
5242        ) -> fidl::Result<()> {
5243            encoder.debug_check_bounds::<RouteValidatorRouteResponse>(offset);
5244            // Zero out padding regions. There's no need to apply masks
5245            // because the unmasked parts will be overwritten by fields.
5246            // Write the fields.
5247            self.0.encode(encoder, offset + 0, depth)?;
5248            Ok(())
5249        }
5250    }
5251
5252    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5253        for RouteValidatorRouteResponse
5254    {
5255        #[inline(always)]
5256        fn new_empty() -> Self {
5257            Self { reports: fidl::new_empty!(fidl::encoding::UnboundedVector<RouteReport>, D) }
5258        }
5259
5260        #[inline]
5261        unsafe fn decode(
5262            &mut self,
5263            decoder: &mut fidl::encoding::Decoder<'_, D>,
5264            offset: usize,
5265            _depth: fidl::encoding::Depth,
5266        ) -> fidl::Result<()> {
5267            decoder.debug_check_bounds::<Self>(offset);
5268            // Verify that padding bytes are zero.
5269            fidl::decode!(
5270                fidl::encoding::UnboundedVector<RouteReport>,
5271                D,
5272                &mut self.reports,
5273                decoder,
5274                offset + 0,
5275                _depth
5276            )?;
5277            Ok(())
5278        }
5279    }
5280
5281    impl fidl::encoding::ValueTypeMarker for RouteValidatorValidateResponse {
5282        type Borrowed<'a> = &'a Self;
5283        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5284            value
5285        }
5286    }
5287
5288    unsafe impl fidl::encoding::TypeMarker for RouteValidatorValidateResponse {
5289        type Owned = Self;
5290
5291        #[inline(always)]
5292        fn inline_align(_context: fidl::encoding::Context) -> usize {
5293            8
5294        }
5295
5296        #[inline(always)]
5297        fn inline_size(_context: fidl::encoding::Context) -> usize {
5298            16
5299        }
5300    }
5301
5302    unsafe impl<D: fidl::encoding::ResourceDialect>
5303        fidl::encoding::Encode<RouteValidatorValidateResponse, D>
5304        for &RouteValidatorValidateResponse
5305    {
5306        #[inline]
5307        unsafe fn encode(
5308            self,
5309            encoder: &mut fidl::encoding::Encoder<'_, D>,
5310            offset: usize,
5311            _depth: fidl::encoding::Depth,
5312        ) -> fidl::Result<()> {
5313            encoder.debug_check_bounds::<RouteValidatorValidateResponse>(offset);
5314            // Delegate to tuple encoding.
5315            fidl::encoding::Encode::<RouteValidatorValidateResponse, D>::encode(
5316                (
5317                    <fidl::encoding::UnboundedVector<RouteReport> as fidl::encoding::ValueTypeMarker>::borrow(&self.reports),
5318                ),
5319                encoder, offset, _depth
5320            )
5321        }
5322    }
5323    unsafe impl<
5324            D: fidl::encoding::ResourceDialect,
5325            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<RouteReport>, D>,
5326        > fidl::encoding::Encode<RouteValidatorValidateResponse, D> for (T0,)
5327    {
5328        #[inline]
5329        unsafe fn encode(
5330            self,
5331            encoder: &mut fidl::encoding::Encoder<'_, D>,
5332            offset: usize,
5333            depth: fidl::encoding::Depth,
5334        ) -> fidl::Result<()> {
5335            encoder.debug_check_bounds::<RouteValidatorValidateResponse>(offset);
5336            // Zero out padding regions. There's no need to apply masks
5337            // because the unmasked parts will be overwritten by fields.
5338            // Write the fields.
5339            self.0.encode(encoder, offset + 0, depth)?;
5340            Ok(())
5341        }
5342    }
5343
5344    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5345        for RouteValidatorValidateResponse
5346    {
5347        #[inline(always)]
5348        fn new_empty() -> Self {
5349            Self { reports: fidl::new_empty!(fidl::encoding::UnboundedVector<RouteReport>, D) }
5350        }
5351
5352        #[inline]
5353        unsafe fn decode(
5354            &mut self,
5355            decoder: &mut fidl::encoding::Decoder<'_, D>,
5356            offset: usize,
5357            _depth: fidl::encoding::Depth,
5358        ) -> fidl::Result<()> {
5359            decoder.debug_check_bounds::<Self>(offset);
5360            // Verify that padding bytes are zero.
5361            fidl::decode!(
5362                fidl::encoding::UnboundedVector<RouteReport>,
5363                D,
5364                &mut self.reports,
5365                decoder,
5366                offset + 0,
5367                _depth
5368            )?;
5369            Ok(())
5370        }
5371    }
5372
5373    impl fidl::encoding::ValueTypeMarker for StorageAdminDeleteComponentStorageRequest {
5374        type Borrowed<'a> = &'a Self;
5375        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5376            value
5377        }
5378    }
5379
5380    unsafe impl fidl::encoding::TypeMarker for StorageAdminDeleteComponentStorageRequest {
5381        type Owned = Self;
5382
5383        #[inline(always)]
5384        fn inline_align(_context: fidl::encoding::Context) -> usize {
5385            8
5386        }
5387
5388        #[inline(always)]
5389        fn inline_size(_context: fidl::encoding::Context) -> usize {
5390            16
5391        }
5392    }
5393
5394    unsafe impl<D: fidl::encoding::ResourceDialect>
5395        fidl::encoding::Encode<StorageAdminDeleteComponentStorageRequest, D>
5396        for &StorageAdminDeleteComponentStorageRequest
5397    {
5398        #[inline]
5399        unsafe fn encode(
5400            self,
5401            encoder: &mut fidl::encoding::Encoder<'_, D>,
5402            offset: usize,
5403            _depth: fidl::encoding::Depth,
5404        ) -> fidl::Result<()> {
5405            encoder.debug_check_bounds::<StorageAdminDeleteComponentStorageRequest>(offset);
5406            // Delegate to tuple encoding.
5407            fidl::encoding::Encode::<StorageAdminDeleteComponentStorageRequest, D>::encode(
5408                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
5409                    &self.relative_moniker,
5410                ),),
5411                encoder,
5412                offset,
5413                _depth,
5414            )
5415        }
5416    }
5417    unsafe impl<
5418            D: fidl::encoding::ResourceDialect,
5419            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
5420        > fidl::encoding::Encode<StorageAdminDeleteComponentStorageRequest, D> for (T0,)
5421    {
5422        #[inline]
5423        unsafe fn encode(
5424            self,
5425            encoder: &mut fidl::encoding::Encoder<'_, D>,
5426            offset: usize,
5427            depth: fidl::encoding::Depth,
5428        ) -> fidl::Result<()> {
5429            encoder.debug_check_bounds::<StorageAdminDeleteComponentStorageRequest>(offset);
5430            // Zero out padding regions. There's no need to apply masks
5431            // because the unmasked parts will be overwritten by fields.
5432            // Write the fields.
5433            self.0.encode(encoder, offset + 0, depth)?;
5434            Ok(())
5435        }
5436    }
5437
5438    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5439        for StorageAdminDeleteComponentStorageRequest
5440    {
5441        #[inline(always)]
5442        fn new_empty() -> Self {
5443            Self { relative_moniker: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
5444        }
5445
5446        #[inline]
5447        unsafe fn decode(
5448            &mut self,
5449            decoder: &mut fidl::encoding::Decoder<'_, D>,
5450            offset: usize,
5451            _depth: fidl::encoding::Depth,
5452        ) -> fidl::Result<()> {
5453            decoder.debug_check_bounds::<Self>(offset);
5454            // Verify that padding bytes are zero.
5455            fidl::decode!(
5456                fidl::encoding::BoundedString<4096>,
5457                D,
5458                &mut self.relative_moniker,
5459                decoder,
5460                offset + 0,
5461                _depth
5462            )?;
5463            Ok(())
5464        }
5465    }
5466
5467    impl fidl::encoding::ValueTypeMarker for StorageIteratorNextResponse {
5468        type Borrowed<'a> = &'a Self;
5469        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5470            value
5471        }
5472    }
5473
5474    unsafe impl fidl::encoding::TypeMarker for StorageIteratorNextResponse {
5475        type Owned = Self;
5476
5477        #[inline(always)]
5478        fn inline_align(_context: fidl::encoding::Context) -> usize {
5479            8
5480        }
5481
5482        #[inline(always)]
5483        fn inline_size(_context: fidl::encoding::Context) -> usize {
5484            16
5485        }
5486    }
5487
5488    unsafe impl<D: fidl::encoding::ResourceDialect>
5489        fidl::encoding::Encode<StorageIteratorNextResponse, D> for &StorageIteratorNextResponse
5490    {
5491        #[inline]
5492        unsafe fn encode(
5493            self,
5494            encoder: &mut fidl::encoding::Encoder<'_, D>,
5495            offset: usize,
5496            _depth: fidl::encoding::Depth,
5497        ) -> fidl::Result<()> {
5498            encoder.debug_check_bounds::<StorageIteratorNextResponse>(offset);
5499            // Delegate to tuple encoding.
5500            fidl::encoding::Encode::<StorageIteratorNextResponse, D>::encode(
5501                (
5502                    <fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<4096>> as fidl::encoding::ValueTypeMarker>::borrow(&self.relative_monikers),
5503                ),
5504                encoder, offset, _depth
5505            )
5506        }
5507    }
5508    unsafe impl<
5509            D: fidl::encoding::ResourceDialect,
5510            T0: fidl::encoding::Encode<
5511                fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<4096>>,
5512                D,
5513            >,
5514        > fidl::encoding::Encode<StorageIteratorNextResponse, D> for (T0,)
5515    {
5516        #[inline]
5517        unsafe fn encode(
5518            self,
5519            encoder: &mut fidl::encoding::Encoder<'_, D>,
5520            offset: usize,
5521            depth: fidl::encoding::Depth,
5522        ) -> fidl::Result<()> {
5523            encoder.debug_check_bounds::<StorageIteratorNextResponse>(offset);
5524            // Zero out padding regions. There's no need to apply masks
5525            // because the unmasked parts will be overwritten by fields.
5526            // Write the fields.
5527            self.0.encode(encoder, offset + 0, depth)?;
5528            Ok(())
5529        }
5530    }
5531
5532    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5533        for StorageIteratorNextResponse
5534    {
5535        #[inline(always)]
5536        fn new_empty() -> Self {
5537            Self {
5538                relative_monikers: fidl::new_empty!(
5539                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<4096>>,
5540                    D
5541                ),
5542            }
5543        }
5544
5545        #[inline]
5546        unsafe fn decode(
5547            &mut self,
5548            decoder: &mut fidl::encoding::Decoder<'_, D>,
5549            offset: usize,
5550            _depth: fidl::encoding::Depth,
5551        ) -> fidl::Result<()> {
5552            decoder.debug_check_bounds::<Self>(offset);
5553            // Verify that padding bytes are zero.
5554            fidl::decode!(
5555                fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<4096>>,
5556                D,
5557                &mut self.relative_monikers,
5558                decoder,
5559                offset + 0,
5560                _depth
5561            )?;
5562            Ok(())
5563        }
5564    }
5565
5566    impl ComponentCrashInfo {
5567        #[inline(always)]
5568        fn max_ordinal_present(&self) -> u64 {
5569            if let Some(_) = self.moniker {
5570                return 2;
5571            }
5572            if let Some(_) = self.url {
5573                return 1;
5574            }
5575            0
5576        }
5577    }
5578
5579    impl fidl::encoding::ValueTypeMarker for ComponentCrashInfo {
5580        type Borrowed<'a> = &'a Self;
5581        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5582            value
5583        }
5584    }
5585
5586    unsafe impl fidl::encoding::TypeMarker for ComponentCrashInfo {
5587        type Owned = Self;
5588
5589        #[inline(always)]
5590        fn inline_align(_context: fidl::encoding::Context) -> usize {
5591            8
5592        }
5593
5594        #[inline(always)]
5595        fn inline_size(_context: fidl::encoding::Context) -> usize {
5596            16
5597        }
5598    }
5599
5600    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ComponentCrashInfo, D>
5601        for &ComponentCrashInfo
5602    {
5603        unsafe fn encode(
5604            self,
5605            encoder: &mut fidl::encoding::Encoder<'_, D>,
5606            offset: usize,
5607            mut depth: fidl::encoding::Depth,
5608        ) -> fidl::Result<()> {
5609            encoder.debug_check_bounds::<ComponentCrashInfo>(offset);
5610            // Vector header
5611            let max_ordinal: u64 = self.max_ordinal_present();
5612            encoder.write_num(max_ordinal, offset);
5613            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5614            // Calling encoder.out_of_line_offset(0) is not allowed.
5615            if max_ordinal == 0 {
5616                return Ok(());
5617            }
5618            depth.increment()?;
5619            let envelope_size = 8;
5620            let bytes_len = max_ordinal as usize * envelope_size;
5621            #[allow(unused_variables)]
5622            let offset = encoder.out_of_line_offset(bytes_len);
5623            let mut _prev_end_offset: usize = 0;
5624            if 1 > max_ordinal {
5625                return Ok(());
5626            }
5627
5628            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5629            // are envelope_size bytes.
5630            let cur_offset: usize = (1 - 1) * envelope_size;
5631
5632            // Zero reserved fields.
5633            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5634
5635            // Safety:
5636            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5637            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5638            //   envelope_size bytes, there is always sufficient room.
5639            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
5640            self.url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
5641            encoder, offset + cur_offset, depth
5642        )?;
5643
5644            _prev_end_offset = cur_offset + envelope_size;
5645            if 2 > max_ordinal {
5646                return Ok(());
5647            }
5648
5649            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5650            // are envelope_size bytes.
5651            let cur_offset: usize = (2 - 1) * envelope_size;
5652
5653            // Zero reserved fields.
5654            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5655
5656            // Safety:
5657            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5658            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5659            //   envelope_size bytes, there is always sufficient room.
5660            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
5661            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
5662            encoder, offset + cur_offset, depth
5663        )?;
5664
5665            _prev_end_offset = cur_offset + envelope_size;
5666
5667            Ok(())
5668        }
5669    }
5670
5671    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ComponentCrashInfo {
5672        #[inline(always)]
5673        fn new_empty() -> Self {
5674            Self::default()
5675        }
5676
5677        unsafe fn decode(
5678            &mut self,
5679            decoder: &mut fidl::encoding::Decoder<'_, D>,
5680            offset: usize,
5681            mut depth: fidl::encoding::Depth,
5682        ) -> fidl::Result<()> {
5683            decoder.debug_check_bounds::<Self>(offset);
5684            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5685                None => return Err(fidl::Error::NotNullable),
5686                Some(len) => len,
5687            };
5688            // Calling decoder.out_of_line_offset(0) is not allowed.
5689            if len == 0 {
5690                return Ok(());
5691            };
5692            depth.increment()?;
5693            let envelope_size = 8;
5694            let bytes_len = len * envelope_size;
5695            let offset = decoder.out_of_line_offset(bytes_len)?;
5696            // Decode the envelope for each type.
5697            let mut _next_ordinal_to_read = 0;
5698            let mut next_offset = offset;
5699            let end_offset = offset + bytes_len;
5700            _next_ordinal_to_read += 1;
5701            if next_offset >= end_offset {
5702                return Ok(());
5703            }
5704
5705            // Decode unknown envelopes for gaps in ordinals.
5706            while _next_ordinal_to_read < 1 {
5707                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5708                _next_ordinal_to_read += 1;
5709                next_offset += envelope_size;
5710            }
5711
5712            let next_out_of_line = decoder.next_out_of_line();
5713            let handles_before = decoder.remaining_handles();
5714            if let Some((inlined, num_bytes, num_handles)) =
5715                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5716            {
5717                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5718                if inlined != (member_inline_size <= 4) {
5719                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5720                }
5721                let inner_offset;
5722                let mut inner_depth = depth.clone();
5723                if inlined {
5724                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5725                    inner_offset = next_offset;
5726                } else {
5727                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5728                    inner_depth.increment()?;
5729                }
5730                let val_ref = self.url.get_or_insert_with(|| {
5731                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
5732                });
5733                fidl::decode!(
5734                    fidl::encoding::BoundedString<4096>,
5735                    D,
5736                    val_ref,
5737                    decoder,
5738                    inner_offset,
5739                    inner_depth
5740                )?;
5741                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5742                {
5743                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5744                }
5745                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5746                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5747                }
5748            }
5749
5750            next_offset += envelope_size;
5751            _next_ordinal_to_read += 1;
5752            if next_offset >= end_offset {
5753                return Ok(());
5754            }
5755
5756            // Decode unknown envelopes for gaps in ordinals.
5757            while _next_ordinal_to_read < 2 {
5758                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5759                _next_ordinal_to_read += 1;
5760                next_offset += envelope_size;
5761            }
5762
5763            let next_out_of_line = decoder.next_out_of_line();
5764            let handles_before = decoder.remaining_handles();
5765            if let Some((inlined, num_bytes, num_handles)) =
5766                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5767            {
5768                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5769                if inlined != (member_inline_size <= 4) {
5770                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5771                }
5772                let inner_offset;
5773                let mut inner_depth = depth.clone();
5774                if inlined {
5775                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5776                    inner_offset = next_offset;
5777                } else {
5778                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5779                    inner_depth.increment()?;
5780                }
5781                let val_ref = self.moniker.get_or_insert_with(|| {
5782                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
5783                });
5784                fidl::decode!(
5785                    fidl::encoding::BoundedString<4096>,
5786                    D,
5787                    val_ref,
5788                    decoder,
5789                    inner_offset,
5790                    inner_depth
5791                )?;
5792                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5793                {
5794                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5795                }
5796                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5797                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5798                }
5799            }
5800
5801            next_offset += envelope_size;
5802
5803            // Decode the remaining unknown envelopes.
5804            while next_offset < end_offset {
5805                _next_ordinal_to_read += 1;
5806                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5807                next_offset += envelope_size;
5808            }
5809
5810            Ok(())
5811        }
5812    }
5813
5814    impl ExecutionInfo {
5815        #[inline(always)]
5816        fn max_ordinal_present(&self) -> u64 {
5817            if let Some(_) = self.start_reason {
5818                return 1;
5819            }
5820            0
5821        }
5822    }
5823
5824    impl fidl::encoding::ValueTypeMarker for ExecutionInfo {
5825        type Borrowed<'a> = &'a Self;
5826        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5827            value
5828        }
5829    }
5830
5831    unsafe impl fidl::encoding::TypeMarker for ExecutionInfo {
5832        type Owned = Self;
5833
5834        #[inline(always)]
5835        fn inline_align(_context: fidl::encoding::Context) -> usize {
5836            8
5837        }
5838
5839        #[inline(always)]
5840        fn inline_size(_context: fidl::encoding::Context) -> usize {
5841            16
5842        }
5843    }
5844
5845    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExecutionInfo, D>
5846        for &ExecutionInfo
5847    {
5848        unsafe fn encode(
5849            self,
5850            encoder: &mut fidl::encoding::Encoder<'_, D>,
5851            offset: usize,
5852            mut depth: fidl::encoding::Depth,
5853        ) -> fidl::Result<()> {
5854            encoder.debug_check_bounds::<ExecutionInfo>(offset);
5855            // Vector header
5856            let max_ordinal: u64 = self.max_ordinal_present();
5857            encoder.write_num(max_ordinal, offset);
5858            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5859            // Calling encoder.out_of_line_offset(0) is not allowed.
5860            if max_ordinal == 0 {
5861                return Ok(());
5862            }
5863            depth.increment()?;
5864            let envelope_size = 8;
5865            let bytes_len = max_ordinal as usize * envelope_size;
5866            #[allow(unused_variables)]
5867            let offset = encoder.out_of_line_offset(bytes_len);
5868            let mut _prev_end_offset: usize = 0;
5869            if 1 > max_ordinal {
5870                return Ok(());
5871            }
5872
5873            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5874            // are envelope_size bytes.
5875            let cur_offset: usize = (1 - 1) * envelope_size;
5876
5877            // Zero reserved fields.
5878            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5879
5880            // Safety:
5881            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5882            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5883            //   envelope_size bytes, there is always sufficient room.
5884            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<5000>, D>(
5885            self.start_reason.as_ref().map(<fidl::encoding::BoundedString<5000> as fidl::encoding::ValueTypeMarker>::borrow),
5886            encoder, offset + cur_offset, depth
5887        )?;
5888
5889            _prev_end_offset = cur_offset + envelope_size;
5890
5891            Ok(())
5892        }
5893    }
5894
5895    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExecutionInfo {
5896        #[inline(always)]
5897        fn new_empty() -> Self {
5898            Self::default()
5899        }
5900
5901        unsafe fn decode(
5902            &mut self,
5903            decoder: &mut fidl::encoding::Decoder<'_, D>,
5904            offset: usize,
5905            mut depth: fidl::encoding::Depth,
5906        ) -> fidl::Result<()> {
5907            decoder.debug_check_bounds::<Self>(offset);
5908            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5909                None => return Err(fidl::Error::NotNullable),
5910                Some(len) => len,
5911            };
5912            // Calling decoder.out_of_line_offset(0) is not allowed.
5913            if len == 0 {
5914                return Ok(());
5915            };
5916            depth.increment()?;
5917            let envelope_size = 8;
5918            let bytes_len = len * envelope_size;
5919            let offset = decoder.out_of_line_offset(bytes_len)?;
5920            // Decode the envelope for each type.
5921            let mut _next_ordinal_to_read = 0;
5922            let mut next_offset = offset;
5923            let end_offset = offset + bytes_len;
5924            _next_ordinal_to_read += 1;
5925            if next_offset >= end_offset {
5926                return Ok(());
5927            }
5928
5929            // Decode unknown envelopes for gaps in ordinals.
5930            while _next_ordinal_to_read < 1 {
5931                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5932                _next_ordinal_to_read += 1;
5933                next_offset += envelope_size;
5934            }
5935
5936            let next_out_of_line = decoder.next_out_of_line();
5937            let handles_before = decoder.remaining_handles();
5938            if let Some((inlined, num_bytes, num_handles)) =
5939                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5940            {
5941                let member_inline_size = <fidl::encoding::BoundedString<5000> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5942                if inlined != (member_inline_size <= 4) {
5943                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5944                }
5945                let inner_offset;
5946                let mut inner_depth = depth.clone();
5947                if inlined {
5948                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5949                    inner_offset = next_offset;
5950                } else {
5951                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5952                    inner_depth.increment()?;
5953                }
5954                let val_ref = self.start_reason.get_or_insert_with(|| {
5955                    fidl::new_empty!(fidl::encoding::BoundedString<5000>, D)
5956                });
5957                fidl::decode!(
5958                    fidl::encoding::BoundedString<5000>,
5959                    D,
5960                    val_ref,
5961                    decoder,
5962                    inner_offset,
5963                    inner_depth
5964                )?;
5965                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5966                {
5967                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5968                }
5969                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5970                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5971                }
5972            }
5973
5974            next_offset += envelope_size;
5975
5976            // Decode the remaining unknown envelopes.
5977            while next_offset < end_offset {
5978                _next_ordinal_to_read += 1;
5979                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5980                next_offset += envelope_size;
5981            }
5982
5983            Ok(())
5984        }
5985    }
5986
5987    impl Instance {
5988        #[inline(always)]
5989        fn max_ordinal_present(&self) -> u64 {
5990            if let Some(_) = self.environment {
5991                return 5;
5992            }
5993            if let Some(_) = self.resolved_info {
5994                return 4;
5995            }
5996            if let Some(_) = self.instance_id {
5997                return 3;
5998            }
5999            if let Some(_) = self.url {
6000                return 2;
6001            }
6002            if let Some(_) = self.moniker {
6003                return 1;
6004            }
6005            0
6006        }
6007    }
6008
6009    impl fidl::encoding::ValueTypeMarker for Instance {
6010        type Borrowed<'a> = &'a Self;
6011        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6012            value
6013        }
6014    }
6015
6016    unsafe impl fidl::encoding::TypeMarker for Instance {
6017        type Owned = Self;
6018
6019        #[inline(always)]
6020        fn inline_align(_context: fidl::encoding::Context) -> usize {
6021            8
6022        }
6023
6024        #[inline(always)]
6025        fn inline_size(_context: fidl::encoding::Context) -> usize {
6026            16
6027        }
6028    }
6029
6030    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Instance, D> for &Instance {
6031        unsafe fn encode(
6032            self,
6033            encoder: &mut fidl::encoding::Encoder<'_, D>,
6034            offset: usize,
6035            mut depth: fidl::encoding::Depth,
6036        ) -> fidl::Result<()> {
6037            encoder.debug_check_bounds::<Instance>(offset);
6038            // Vector header
6039            let max_ordinal: u64 = self.max_ordinal_present();
6040            encoder.write_num(max_ordinal, offset);
6041            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6042            // Calling encoder.out_of_line_offset(0) is not allowed.
6043            if max_ordinal == 0 {
6044                return Ok(());
6045            }
6046            depth.increment()?;
6047            let envelope_size = 8;
6048            let bytes_len = max_ordinal as usize * envelope_size;
6049            #[allow(unused_variables)]
6050            let offset = encoder.out_of_line_offset(bytes_len);
6051            let mut _prev_end_offset: usize = 0;
6052            if 1 > max_ordinal {
6053                return Ok(());
6054            }
6055
6056            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6057            // are envelope_size bytes.
6058            let cur_offset: usize = (1 - 1) * envelope_size;
6059
6060            // Zero reserved fields.
6061            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6062
6063            // Safety:
6064            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6065            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6066            //   envelope_size bytes, there is always sufficient room.
6067            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6068            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6069            encoder, offset + cur_offset, depth
6070        )?;
6071
6072            _prev_end_offset = cur_offset + envelope_size;
6073            if 2 > max_ordinal {
6074                return Ok(());
6075            }
6076
6077            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6078            // are envelope_size bytes.
6079            let cur_offset: usize = (2 - 1) * envelope_size;
6080
6081            // Zero reserved fields.
6082            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6083
6084            // Safety:
6085            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6086            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6087            //   envelope_size bytes, there is always sufficient room.
6088            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6089            self.url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6090            encoder, offset + cur_offset, depth
6091        )?;
6092
6093            _prev_end_offset = cur_offset + envelope_size;
6094            if 3 > max_ordinal {
6095                return Ok(());
6096            }
6097
6098            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6099            // are envelope_size bytes.
6100            let cur_offset: usize = (3 - 1) * envelope_size;
6101
6102            // Zero reserved fields.
6103            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6104
6105            // Safety:
6106            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6107            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6108            //   envelope_size bytes, there is always sufficient room.
6109            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
6110                self.instance_id.as_ref().map(
6111                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
6112                ),
6113                encoder,
6114                offset + cur_offset,
6115                depth,
6116            )?;
6117
6118            _prev_end_offset = cur_offset + envelope_size;
6119            if 4 > max_ordinal {
6120                return Ok(());
6121            }
6122
6123            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6124            // are envelope_size bytes.
6125            let cur_offset: usize = (4 - 1) * envelope_size;
6126
6127            // Zero reserved fields.
6128            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6129
6130            // Safety:
6131            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6132            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6133            //   envelope_size bytes, there is always sufficient room.
6134            fidl::encoding::encode_in_envelope_optional::<ResolvedInfo, D>(
6135                self.resolved_info
6136                    .as_ref()
6137                    .map(<ResolvedInfo as fidl::encoding::ValueTypeMarker>::borrow),
6138                encoder,
6139                offset + cur_offset,
6140                depth,
6141            )?;
6142
6143            _prev_end_offset = cur_offset + envelope_size;
6144            if 5 > max_ordinal {
6145                return Ok(());
6146            }
6147
6148            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6149            // are envelope_size bytes.
6150            let cur_offset: usize = (5 - 1) * envelope_size;
6151
6152            // Zero reserved fields.
6153            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6154
6155            // Safety:
6156            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6157            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6158            //   envelope_size bytes, there is always sufficient room.
6159            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6160            self.environment.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6161            encoder, offset + cur_offset, depth
6162        )?;
6163
6164            _prev_end_offset = cur_offset + envelope_size;
6165
6166            Ok(())
6167        }
6168    }
6169
6170    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Instance {
6171        #[inline(always)]
6172        fn new_empty() -> Self {
6173            Self::default()
6174        }
6175
6176        unsafe fn decode(
6177            &mut self,
6178            decoder: &mut fidl::encoding::Decoder<'_, D>,
6179            offset: usize,
6180            mut depth: fidl::encoding::Depth,
6181        ) -> fidl::Result<()> {
6182            decoder.debug_check_bounds::<Self>(offset);
6183            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6184                None => return Err(fidl::Error::NotNullable),
6185                Some(len) => len,
6186            };
6187            // Calling decoder.out_of_line_offset(0) is not allowed.
6188            if len == 0 {
6189                return Ok(());
6190            };
6191            depth.increment()?;
6192            let envelope_size = 8;
6193            let bytes_len = len * envelope_size;
6194            let offset = decoder.out_of_line_offset(bytes_len)?;
6195            // Decode the envelope for each type.
6196            let mut _next_ordinal_to_read = 0;
6197            let mut next_offset = offset;
6198            let end_offset = offset + bytes_len;
6199            _next_ordinal_to_read += 1;
6200            if next_offset >= end_offset {
6201                return Ok(());
6202            }
6203
6204            // Decode unknown envelopes for gaps in ordinals.
6205            while _next_ordinal_to_read < 1 {
6206                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6207                _next_ordinal_to_read += 1;
6208                next_offset += envelope_size;
6209            }
6210
6211            let next_out_of_line = decoder.next_out_of_line();
6212            let handles_before = decoder.remaining_handles();
6213            if let Some((inlined, num_bytes, num_handles)) =
6214                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6215            {
6216                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6217                if inlined != (member_inline_size <= 4) {
6218                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6219                }
6220                let inner_offset;
6221                let mut inner_depth = depth.clone();
6222                if inlined {
6223                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6224                    inner_offset = next_offset;
6225                } else {
6226                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6227                    inner_depth.increment()?;
6228                }
6229                let val_ref = self.moniker.get_or_insert_with(|| {
6230                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
6231                });
6232                fidl::decode!(
6233                    fidl::encoding::BoundedString<4096>,
6234                    D,
6235                    val_ref,
6236                    decoder,
6237                    inner_offset,
6238                    inner_depth
6239                )?;
6240                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6241                {
6242                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6243                }
6244                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6245                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6246                }
6247            }
6248
6249            next_offset += envelope_size;
6250            _next_ordinal_to_read += 1;
6251            if next_offset >= end_offset {
6252                return Ok(());
6253            }
6254
6255            // Decode unknown envelopes for gaps in ordinals.
6256            while _next_ordinal_to_read < 2 {
6257                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6258                _next_ordinal_to_read += 1;
6259                next_offset += envelope_size;
6260            }
6261
6262            let next_out_of_line = decoder.next_out_of_line();
6263            let handles_before = decoder.remaining_handles();
6264            if let Some((inlined, num_bytes, num_handles)) =
6265                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6266            {
6267                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6268                if inlined != (member_inline_size <= 4) {
6269                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6270                }
6271                let inner_offset;
6272                let mut inner_depth = depth.clone();
6273                if inlined {
6274                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6275                    inner_offset = next_offset;
6276                } else {
6277                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6278                    inner_depth.increment()?;
6279                }
6280                let val_ref = self.url.get_or_insert_with(|| {
6281                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
6282                });
6283                fidl::decode!(
6284                    fidl::encoding::BoundedString<4096>,
6285                    D,
6286                    val_ref,
6287                    decoder,
6288                    inner_offset,
6289                    inner_depth
6290                )?;
6291                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6292                {
6293                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6294                }
6295                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6296                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6297                }
6298            }
6299
6300            next_offset += envelope_size;
6301            _next_ordinal_to_read += 1;
6302            if next_offset >= end_offset {
6303                return Ok(());
6304            }
6305
6306            // Decode unknown envelopes for gaps in ordinals.
6307            while _next_ordinal_to_read < 3 {
6308                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6309                _next_ordinal_to_read += 1;
6310                next_offset += envelope_size;
6311            }
6312
6313            let next_out_of_line = decoder.next_out_of_line();
6314            let handles_before = decoder.remaining_handles();
6315            if let Some((inlined, num_bytes, num_handles)) =
6316                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6317            {
6318                let member_inline_size =
6319                    <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
6320                        decoder.context,
6321                    );
6322                if inlined != (member_inline_size <= 4) {
6323                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6324                }
6325                let inner_offset;
6326                let mut inner_depth = depth.clone();
6327                if inlined {
6328                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6329                    inner_offset = next_offset;
6330                } else {
6331                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6332                    inner_depth.increment()?;
6333                }
6334                let val_ref = self
6335                    .instance_id
6336                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
6337                fidl::decode!(
6338                    fidl::encoding::BoundedString<64>,
6339                    D,
6340                    val_ref,
6341                    decoder,
6342                    inner_offset,
6343                    inner_depth
6344                )?;
6345                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6346                {
6347                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6348                }
6349                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6350                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6351                }
6352            }
6353
6354            next_offset += envelope_size;
6355            _next_ordinal_to_read += 1;
6356            if next_offset >= end_offset {
6357                return Ok(());
6358            }
6359
6360            // Decode unknown envelopes for gaps in ordinals.
6361            while _next_ordinal_to_read < 4 {
6362                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6363                _next_ordinal_to_read += 1;
6364                next_offset += envelope_size;
6365            }
6366
6367            let next_out_of_line = decoder.next_out_of_line();
6368            let handles_before = decoder.remaining_handles();
6369            if let Some((inlined, num_bytes, num_handles)) =
6370                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6371            {
6372                let member_inline_size =
6373                    <ResolvedInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6374                if inlined != (member_inline_size <= 4) {
6375                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6376                }
6377                let inner_offset;
6378                let mut inner_depth = depth.clone();
6379                if inlined {
6380                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6381                    inner_offset = next_offset;
6382                } else {
6383                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6384                    inner_depth.increment()?;
6385                }
6386                let val_ref =
6387                    self.resolved_info.get_or_insert_with(|| fidl::new_empty!(ResolvedInfo, D));
6388                fidl::decode!(ResolvedInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
6389                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6390                {
6391                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6392                }
6393                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6394                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6395                }
6396            }
6397
6398            next_offset += envelope_size;
6399            _next_ordinal_to_read += 1;
6400            if next_offset >= end_offset {
6401                return Ok(());
6402            }
6403
6404            // Decode unknown envelopes for gaps in ordinals.
6405            while _next_ordinal_to_read < 5 {
6406                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6407                _next_ordinal_to_read += 1;
6408                next_offset += envelope_size;
6409            }
6410
6411            let next_out_of_line = decoder.next_out_of_line();
6412            let handles_before = decoder.remaining_handles();
6413            if let Some((inlined, num_bytes, num_handles)) =
6414                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6415            {
6416                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6417                if inlined != (member_inline_size <= 4) {
6418                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6419                }
6420                let inner_offset;
6421                let mut inner_depth = depth.clone();
6422                if inlined {
6423                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6424                    inner_offset = next_offset;
6425                } else {
6426                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6427                    inner_depth.increment()?;
6428                }
6429                let val_ref = self.environment.get_or_insert_with(|| {
6430                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
6431                });
6432                fidl::decode!(
6433                    fidl::encoding::BoundedString<4096>,
6434                    D,
6435                    val_ref,
6436                    decoder,
6437                    inner_offset,
6438                    inner_depth
6439                )?;
6440                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6441                {
6442                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6443                }
6444                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6445                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6446                }
6447            }
6448
6449            next_offset += envelope_size;
6450
6451            // Decode the remaining unknown envelopes.
6452            while next_offset < end_offset {
6453                _next_ordinal_to_read += 1;
6454                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6455                next_offset += envelope_size;
6456            }
6457
6458            Ok(())
6459        }
6460    }
6461
6462    impl ResolvedInfo {
6463        #[inline(always)]
6464        fn max_ordinal_present(&self) -> u64 {
6465            if let Some(_) = self.execution_info {
6466                return 2;
6467            }
6468            if let Some(_) = self.resolved_url {
6469                return 1;
6470            }
6471            0
6472        }
6473    }
6474
6475    impl fidl::encoding::ValueTypeMarker for ResolvedInfo {
6476        type Borrowed<'a> = &'a Self;
6477        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6478            value
6479        }
6480    }
6481
6482    unsafe impl fidl::encoding::TypeMarker for ResolvedInfo {
6483        type Owned = Self;
6484
6485        #[inline(always)]
6486        fn inline_align(_context: fidl::encoding::Context) -> usize {
6487            8
6488        }
6489
6490        #[inline(always)]
6491        fn inline_size(_context: fidl::encoding::Context) -> usize {
6492            16
6493        }
6494    }
6495
6496    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ResolvedInfo, D>
6497        for &ResolvedInfo
6498    {
6499        unsafe fn encode(
6500            self,
6501            encoder: &mut fidl::encoding::Encoder<'_, D>,
6502            offset: usize,
6503            mut depth: fidl::encoding::Depth,
6504        ) -> fidl::Result<()> {
6505            encoder.debug_check_bounds::<ResolvedInfo>(offset);
6506            // Vector header
6507            let max_ordinal: u64 = self.max_ordinal_present();
6508            encoder.write_num(max_ordinal, offset);
6509            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6510            // Calling encoder.out_of_line_offset(0) is not allowed.
6511            if max_ordinal == 0 {
6512                return Ok(());
6513            }
6514            depth.increment()?;
6515            let envelope_size = 8;
6516            let bytes_len = max_ordinal as usize * envelope_size;
6517            #[allow(unused_variables)]
6518            let offset = encoder.out_of_line_offset(bytes_len);
6519            let mut _prev_end_offset: usize = 0;
6520            if 1 > max_ordinal {
6521                return Ok(());
6522            }
6523
6524            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6525            // are envelope_size bytes.
6526            let cur_offset: usize = (1 - 1) * envelope_size;
6527
6528            // Zero reserved fields.
6529            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6530
6531            // Safety:
6532            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6533            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6534            //   envelope_size bytes, there is always sufficient room.
6535            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6536            self.resolved_url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6537            encoder, offset + cur_offset, depth
6538        )?;
6539
6540            _prev_end_offset = cur_offset + envelope_size;
6541            if 2 > max_ordinal {
6542                return Ok(());
6543            }
6544
6545            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6546            // are envelope_size bytes.
6547            let cur_offset: usize = (2 - 1) * envelope_size;
6548
6549            // Zero reserved fields.
6550            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6551
6552            // Safety:
6553            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6554            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6555            //   envelope_size bytes, there is always sufficient room.
6556            fidl::encoding::encode_in_envelope_optional::<ExecutionInfo, D>(
6557                self.execution_info
6558                    .as_ref()
6559                    .map(<ExecutionInfo as fidl::encoding::ValueTypeMarker>::borrow),
6560                encoder,
6561                offset + cur_offset,
6562                depth,
6563            )?;
6564
6565            _prev_end_offset = cur_offset + envelope_size;
6566
6567            Ok(())
6568        }
6569    }
6570
6571    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolvedInfo {
6572        #[inline(always)]
6573        fn new_empty() -> Self {
6574            Self::default()
6575        }
6576
6577        unsafe fn decode(
6578            &mut self,
6579            decoder: &mut fidl::encoding::Decoder<'_, D>,
6580            offset: usize,
6581            mut depth: fidl::encoding::Depth,
6582        ) -> fidl::Result<()> {
6583            decoder.debug_check_bounds::<Self>(offset);
6584            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6585                None => return Err(fidl::Error::NotNullable),
6586                Some(len) => len,
6587            };
6588            // Calling decoder.out_of_line_offset(0) is not allowed.
6589            if len == 0 {
6590                return Ok(());
6591            };
6592            depth.increment()?;
6593            let envelope_size = 8;
6594            let bytes_len = len * envelope_size;
6595            let offset = decoder.out_of_line_offset(bytes_len)?;
6596            // Decode the envelope for each type.
6597            let mut _next_ordinal_to_read = 0;
6598            let mut next_offset = offset;
6599            let end_offset = offset + bytes_len;
6600            _next_ordinal_to_read += 1;
6601            if next_offset >= end_offset {
6602                return Ok(());
6603            }
6604
6605            // Decode unknown envelopes for gaps in ordinals.
6606            while _next_ordinal_to_read < 1 {
6607                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6608                _next_ordinal_to_read += 1;
6609                next_offset += envelope_size;
6610            }
6611
6612            let next_out_of_line = decoder.next_out_of_line();
6613            let handles_before = decoder.remaining_handles();
6614            if let Some((inlined, num_bytes, num_handles)) =
6615                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6616            {
6617                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6618                if inlined != (member_inline_size <= 4) {
6619                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6620                }
6621                let inner_offset;
6622                let mut inner_depth = depth.clone();
6623                if inlined {
6624                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6625                    inner_offset = next_offset;
6626                } else {
6627                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6628                    inner_depth.increment()?;
6629                }
6630                let val_ref = self.resolved_url.get_or_insert_with(|| {
6631                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
6632                });
6633                fidl::decode!(
6634                    fidl::encoding::BoundedString<4096>,
6635                    D,
6636                    val_ref,
6637                    decoder,
6638                    inner_offset,
6639                    inner_depth
6640                )?;
6641                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6642                {
6643                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6644                }
6645                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6646                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6647                }
6648            }
6649
6650            next_offset += envelope_size;
6651            _next_ordinal_to_read += 1;
6652            if next_offset >= end_offset {
6653                return Ok(());
6654            }
6655
6656            // Decode unknown envelopes for gaps in ordinals.
6657            while _next_ordinal_to_read < 2 {
6658                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6659                _next_ordinal_to_read += 1;
6660                next_offset += envelope_size;
6661            }
6662
6663            let next_out_of_line = decoder.next_out_of_line();
6664            let handles_before = decoder.remaining_handles();
6665            if let Some((inlined, num_bytes, num_handles)) =
6666                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6667            {
6668                let member_inline_size =
6669                    <ExecutionInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6670                if inlined != (member_inline_size <= 4) {
6671                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6672                }
6673                let inner_offset;
6674                let mut inner_depth = depth.clone();
6675                if inlined {
6676                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6677                    inner_offset = next_offset;
6678                } else {
6679                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6680                    inner_depth.increment()?;
6681                }
6682                let val_ref =
6683                    self.execution_info.get_or_insert_with(|| fidl::new_empty!(ExecutionInfo, D));
6684                fidl::decode!(ExecutionInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
6685                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6686                {
6687                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6688                }
6689                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6690                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6691                }
6692            }
6693
6694            next_offset += envelope_size;
6695
6696            // Decode the remaining unknown envelopes.
6697            while next_offset < end_offset {
6698                _next_ordinal_to_read += 1;
6699                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6700                next_offset += envelope_size;
6701            }
6702
6703            Ok(())
6704        }
6705    }
6706
6707    impl RouteError {
6708        #[inline(always)]
6709        fn max_ordinal_present(&self) -> u64 {
6710            if let Some(_) = self.summary {
6711                return 1;
6712            }
6713            0
6714        }
6715    }
6716
6717    impl fidl::encoding::ValueTypeMarker for RouteError {
6718        type Borrowed<'a> = &'a Self;
6719        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6720            value
6721        }
6722    }
6723
6724    unsafe impl fidl::encoding::TypeMarker for RouteError {
6725        type Owned = Self;
6726
6727        #[inline(always)]
6728        fn inline_align(_context: fidl::encoding::Context) -> usize {
6729            8
6730        }
6731
6732        #[inline(always)]
6733        fn inline_size(_context: fidl::encoding::Context) -> usize {
6734            16
6735        }
6736    }
6737
6738    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RouteError, D>
6739        for &RouteError
6740    {
6741        unsafe fn encode(
6742            self,
6743            encoder: &mut fidl::encoding::Encoder<'_, D>,
6744            offset: usize,
6745            mut depth: fidl::encoding::Depth,
6746        ) -> fidl::Result<()> {
6747            encoder.debug_check_bounds::<RouteError>(offset);
6748            // Vector header
6749            let max_ordinal: u64 = self.max_ordinal_present();
6750            encoder.write_num(max_ordinal, offset);
6751            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6752            // Calling encoder.out_of_line_offset(0) is not allowed.
6753            if max_ordinal == 0 {
6754                return Ok(());
6755            }
6756            depth.increment()?;
6757            let envelope_size = 8;
6758            let bytes_len = max_ordinal as usize * envelope_size;
6759            #[allow(unused_variables)]
6760            let offset = encoder.out_of_line_offset(bytes_len);
6761            let mut _prev_end_offset: usize = 0;
6762            if 1 > max_ordinal {
6763                return Ok(());
6764            }
6765
6766            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6767            // are envelope_size bytes.
6768            let cur_offset: usize = (1 - 1) * envelope_size;
6769
6770            // Zero reserved fields.
6771            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6772
6773            // Safety:
6774            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6775            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6776            //   envelope_size bytes, there is always sufficient room.
6777            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
6778                self.summary.as_ref().map(
6779                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
6780                ),
6781                encoder,
6782                offset + cur_offset,
6783                depth,
6784            )?;
6785
6786            _prev_end_offset = cur_offset + envelope_size;
6787
6788            Ok(())
6789        }
6790    }
6791
6792    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RouteError {
6793        #[inline(always)]
6794        fn new_empty() -> Self {
6795            Self::default()
6796        }
6797
6798        unsafe fn decode(
6799            &mut self,
6800            decoder: &mut fidl::encoding::Decoder<'_, D>,
6801            offset: usize,
6802            mut depth: fidl::encoding::Depth,
6803        ) -> fidl::Result<()> {
6804            decoder.debug_check_bounds::<Self>(offset);
6805            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6806                None => return Err(fidl::Error::NotNullable),
6807                Some(len) => len,
6808            };
6809            // Calling decoder.out_of_line_offset(0) is not allowed.
6810            if len == 0 {
6811                return Ok(());
6812            };
6813            depth.increment()?;
6814            let envelope_size = 8;
6815            let bytes_len = len * envelope_size;
6816            let offset = decoder.out_of_line_offset(bytes_len)?;
6817            // Decode the envelope for each type.
6818            let mut _next_ordinal_to_read = 0;
6819            let mut next_offset = offset;
6820            let end_offset = offset + bytes_len;
6821            _next_ordinal_to_read += 1;
6822            if next_offset >= end_offset {
6823                return Ok(());
6824            }
6825
6826            // Decode unknown envelopes for gaps in ordinals.
6827            while _next_ordinal_to_read < 1 {
6828                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6829                _next_ordinal_to_read += 1;
6830                next_offset += envelope_size;
6831            }
6832
6833            let next_out_of_line = decoder.next_out_of_line();
6834            let handles_before = decoder.remaining_handles();
6835            if let Some((inlined, num_bytes, num_handles)) =
6836                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6837            {
6838                let member_inline_size =
6839                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
6840                        decoder.context,
6841                    );
6842                if inlined != (member_inline_size <= 4) {
6843                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6844                }
6845                let inner_offset;
6846                let mut inner_depth = depth.clone();
6847                if inlined {
6848                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6849                    inner_offset = next_offset;
6850                } else {
6851                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6852                    inner_depth.increment()?;
6853                }
6854                let val_ref = self
6855                    .summary
6856                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
6857                fidl::decode!(
6858                    fidl::encoding::UnboundedString,
6859                    D,
6860                    val_ref,
6861                    decoder,
6862                    inner_offset,
6863                    inner_depth
6864                )?;
6865                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6866                {
6867                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6868                }
6869                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6870                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6871                }
6872            }
6873
6874            next_offset += envelope_size;
6875
6876            // Decode the remaining unknown envelopes.
6877            while next_offset < end_offset {
6878                _next_ordinal_to_read += 1;
6879                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6880                next_offset += envelope_size;
6881            }
6882
6883            Ok(())
6884        }
6885    }
6886
6887    impl RouteReport {
6888        #[inline(always)]
6889        fn max_ordinal_present(&self) -> u64 {
6890            if let Some(_) = self.outcome {
6891                return 7;
6892            }
6893            if let Some(_) = self.availability {
6894                return 6;
6895            }
6896            if let Some(_) = self.service_instances {
6897                return 5;
6898            }
6899            if let Some(_) = self.source_moniker {
6900                return 4;
6901            }
6902            if let Some(_) = self.error {
6903                return 3;
6904            }
6905            if let Some(_) = self.decl_type {
6906                return 2;
6907            }
6908            if let Some(_) = self.capability {
6909                return 1;
6910            }
6911            0
6912        }
6913    }
6914
6915    impl fidl::encoding::ValueTypeMarker for RouteReport {
6916        type Borrowed<'a> = &'a Self;
6917        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6918            value
6919        }
6920    }
6921
6922    unsafe impl fidl::encoding::TypeMarker for RouteReport {
6923        type Owned = Self;
6924
6925        #[inline(always)]
6926        fn inline_align(_context: fidl::encoding::Context) -> usize {
6927            8
6928        }
6929
6930        #[inline(always)]
6931        fn inline_size(_context: fidl::encoding::Context) -> usize {
6932            16
6933        }
6934    }
6935
6936    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RouteReport, D>
6937        for &RouteReport
6938    {
6939        unsafe fn encode(
6940            self,
6941            encoder: &mut fidl::encoding::Encoder<'_, D>,
6942            offset: usize,
6943            mut depth: fidl::encoding::Depth,
6944        ) -> fidl::Result<()> {
6945            encoder.debug_check_bounds::<RouteReport>(offset);
6946            // Vector header
6947            let max_ordinal: u64 = self.max_ordinal_present();
6948            encoder.write_num(max_ordinal, offset);
6949            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6950            // Calling encoder.out_of_line_offset(0) is not allowed.
6951            if max_ordinal == 0 {
6952                return Ok(());
6953            }
6954            depth.increment()?;
6955            let envelope_size = 8;
6956            let bytes_len = max_ordinal as usize * envelope_size;
6957            #[allow(unused_variables)]
6958            let offset = encoder.out_of_line_offset(bytes_len);
6959            let mut _prev_end_offset: usize = 0;
6960            if 1 > max_ordinal {
6961                return Ok(());
6962            }
6963
6964            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6965            // are envelope_size bytes.
6966            let cur_offset: usize = (1 - 1) * envelope_size;
6967
6968            // Zero reserved fields.
6969            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6970
6971            // Safety:
6972            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6973            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6974            //   envelope_size bytes, there is always sufficient room.
6975            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
6976                self.capability.as_ref().map(
6977                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
6978                ),
6979                encoder,
6980                offset + cur_offset,
6981                depth,
6982            )?;
6983
6984            _prev_end_offset = cur_offset + envelope_size;
6985            if 2 > max_ordinal {
6986                return Ok(());
6987            }
6988
6989            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6990            // are envelope_size bytes.
6991            let cur_offset: usize = (2 - 1) * envelope_size;
6992
6993            // Zero reserved fields.
6994            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6995
6996            // Safety:
6997            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6998            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6999            //   envelope_size bytes, there is always sufficient room.
7000            fidl::encoding::encode_in_envelope_optional::<DeclType, D>(
7001                self.decl_type.as_ref().map(<DeclType as fidl::encoding::ValueTypeMarker>::borrow),
7002                encoder,
7003                offset + cur_offset,
7004                depth,
7005            )?;
7006
7007            _prev_end_offset = cur_offset + envelope_size;
7008            if 3 > max_ordinal {
7009                return Ok(());
7010            }
7011
7012            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7013            // are envelope_size bytes.
7014            let cur_offset: usize = (3 - 1) * envelope_size;
7015
7016            // Zero reserved fields.
7017            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7018
7019            // Safety:
7020            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7021            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7022            //   envelope_size bytes, there is always sufficient room.
7023            fidl::encoding::encode_in_envelope_optional::<RouteError, D>(
7024                self.error.as_ref().map(<RouteError as fidl::encoding::ValueTypeMarker>::borrow),
7025                encoder,
7026                offset + cur_offset,
7027                depth,
7028            )?;
7029
7030            _prev_end_offset = cur_offset + envelope_size;
7031            if 4 > max_ordinal {
7032                return Ok(());
7033            }
7034
7035            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7036            // are envelope_size bytes.
7037            let cur_offset: usize = (4 - 1) * envelope_size;
7038
7039            // Zero reserved fields.
7040            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7041
7042            // Safety:
7043            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7044            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7045            //   envelope_size bytes, there is always sufficient room.
7046            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
7047                self.source_moniker.as_ref().map(
7048                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
7049                ),
7050                encoder,
7051                offset + cur_offset,
7052                depth,
7053            )?;
7054
7055            _prev_end_offset = cur_offset + envelope_size;
7056            if 5 > max_ordinal {
7057                return Ok(());
7058            }
7059
7060            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7061            // are envelope_size bytes.
7062            let cur_offset: usize = (5 - 1) * envelope_size;
7063
7064            // Zero reserved fields.
7065            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7066
7067            // Safety:
7068            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7069            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7070            //   envelope_size bytes, there is always sufficient room.
7071            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ServiceInstance>, D>(
7072            self.service_instances.as_ref().map(<fidl::encoding::UnboundedVector<ServiceInstance> as fidl::encoding::ValueTypeMarker>::borrow),
7073            encoder, offset + cur_offset, depth
7074        )?;
7075
7076            _prev_end_offset = cur_offset + envelope_size;
7077            if 6 > max_ordinal {
7078                return Ok(());
7079            }
7080
7081            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7082            // are envelope_size bytes.
7083            let cur_offset: usize = (6 - 1) * envelope_size;
7084
7085            // Zero reserved fields.
7086            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7087
7088            // Safety:
7089            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7090            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7091            //   envelope_size bytes, there is always sufficient room.
7092            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Availability, D>(
7093            self.availability.as_ref().map(<fidl_fuchsia_component_decl__common::Availability as fidl::encoding::ValueTypeMarker>::borrow),
7094            encoder, offset + cur_offset, depth
7095        )?;
7096
7097            _prev_end_offset = cur_offset + envelope_size;
7098            if 7 > max_ordinal {
7099                return Ok(());
7100            }
7101
7102            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7103            // are envelope_size bytes.
7104            let cur_offset: usize = (7 - 1) * envelope_size;
7105
7106            // Zero reserved fields.
7107            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7108
7109            // Safety:
7110            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7111            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7112            //   envelope_size bytes, there is always sufficient room.
7113            fidl::encoding::encode_in_envelope_optional::<RouteOutcome, D>(
7114                self.outcome
7115                    .as_ref()
7116                    .map(<RouteOutcome as fidl::encoding::ValueTypeMarker>::borrow),
7117                encoder,
7118                offset + cur_offset,
7119                depth,
7120            )?;
7121
7122            _prev_end_offset = cur_offset + envelope_size;
7123
7124            Ok(())
7125        }
7126    }
7127
7128    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RouteReport {
7129        #[inline(always)]
7130        fn new_empty() -> Self {
7131            Self::default()
7132        }
7133
7134        unsafe fn decode(
7135            &mut self,
7136            decoder: &mut fidl::encoding::Decoder<'_, D>,
7137            offset: usize,
7138            mut depth: fidl::encoding::Depth,
7139        ) -> fidl::Result<()> {
7140            decoder.debug_check_bounds::<Self>(offset);
7141            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7142                None => return Err(fidl::Error::NotNullable),
7143                Some(len) => len,
7144            };
7145            // Calling decoder.out_of_line_offset(0) is not allowed.
7146            if len == 0 {
7147                return Ok(());
7148            };
7149            depth.increment()?;
7150            let envelope_size = 8;
7151            let bytes_len = len * envelope_size;
7152            let offset = decoder.out_of_line_offset(bytes_len)?;
7153            // Decode the envelope for each type.
7154            let mut _next_ordinal_to_read = 0;
7155            let mut next_offset = offset;
7156            let end_offset = offset + bytes_len;
7157            _next_ordinal_to_read += 1;
7158            if next_offset >= end_offset {
7159                return Ok(());
7160            }
7161
7162            // Decode unknown envelopes for gaps in ordinals.
7163            while _next_ordinal_to_read < 1 {
7164                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7165                _next_ordinal_to_read += 1;
7166                next_offset += envelope_size;
7167            }
7168
7169            let next_out_of_line = decoder.next_out_of_line();
7170            let handles_before = decoder.remaining_handles();
7171            if let Some((inlined, num_bytes, num_handles)) =
7172                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7173            {
7174                let member_inline_size =
7175                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
7176                        decoder.context,
7177                    );
7178                if inlined != (member_inline_size <= 4) {
7179                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7180                }
7181                let inner_offset;
7182                let mut inner_depth = depth.clone();
7183                if inlined {
7184                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7185                    inner_offset = next_offset;
7186                } else {
7187                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7188                    inner_depth.increment()?;
7189                }
7190                let val_ref = self
7191                    .capability
7192                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
7193                fidl::decode!(
7194                    fidl::encoding::UnboundedString,
7195                    D,
7196                    val_ref,
7197                    decoder,
7198                    inner_offset,
7199                    inner_depth
7200                )?;
7201                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7202                {
7203                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7204                }
7205                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7206                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7207                }
7208            }
7209
7210            next_offset += envelope_size;
7211            _next_ordinal_to_read += 1;
7212            if next_offset >= end_offset {
7213                return Ok(());
7214            }
7215
7216            // Decode unknown envelopes for gaps in ordinals.
7217            while _next_ordinal_to_read < 2 {
7218                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7219                _next_ordinal_to_read += 1;
7220                next_offset += envelope_size;
7221            }
7222
7223            let next_out_of_line = decoder.next_out_of_line();
7224            let handles_before = decoder.remaining_handles();
7225            if let Some((inlined, num_bytes, num_handles)) =
7226                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7227            {
7228                let member_inline_size =
7229                    <DeclType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7230                if inlined != (member_inline_size <= 4) {
7231                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7232                }
7233                let inner_offset;
7234                let mut inner_depth = depth.clone();
7235                if inlined {
7236                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7237                    inner_offset = next_offset;
7238                } else {
7239                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7240                    inner_depth.increment()?;
7241                }
7242                let val_ref = self.decl_type.get_or_insert_with(|| fidl::new_empty!(DeclType, D));
7243                fidl::decode!(DeclType, D, val_ref, decoder, inner_offset, inner_depth)?;
7244                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7245                {
7246                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7247                }
7248                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7249                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7250                }
7251            }
7252
7253            next_offset += envelope_size;
7254            _next_ordinal_to_read += 1;
7255            if next_offset >= end_offset {
7256                return Ok(());
7257            }
7258
7259            // Decode unknown envelopes for gaps in ordinals.
7260            while _next_ordinal_to_read < 3 {
7261                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7262                _next_ordinal_to_read += 1;
7263                next_offset += envelope_size;
7264            }
7265
7266            let next_out_of_line = decoder.next_out_of_line();
7267            let handles_before = decoder.remaining_handles();
7268            if let Some((inlined, num_bytes, num_handles)) =
7269                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7270            {
7271                let member_inline_size =
7272                    <RouteError as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7273                if inlined != (member_inline_size <= 4) {
7274                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7275                }
7276                let inner_offset;
7277                let mut inner_depth = depth.clone();
7278                if inlined {
7279                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7280                    inner_offset = next_offset;
7281                } else {
7282                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7283                    inner_depth.increment()?;
7284                }
7285                let val_ref = self.error.get_or_insert_with(|| fidl::new_empty!(RouteError, D));
7286                fidl::decode!(RouteError, D, val_ref, decoder, inner_offset, inner_depth)?;
7287                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7288                {
7289                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7290                }
7291                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7292                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7293                }
7294            }
7295
7296            next_offset += envelope_size;
7297            _next_ordinal_to_read += 1;
7298            if next_offset >= end_offset {
7299                return Ok(());
7300            }
7301
7302            // Decode unknown envelopes for gaps in ordinals.
7303            while _next_ordinal_to_read < 4 {
7304                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7305                _next_ordinal_to_read += 1;
7306                next_offset += envelope_size;
7307            }
7308
7309            let next_out_of_line = decoder.next_out_of_line();
7310            let handles_before = decoder.remaining_handles();
7311            if let Some((inlined, num_bytes, num_handles)) =
7312                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7313            {
7314                let member_inline_size =
7315                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
7316                        decoder.context,
7317                    );
7318                if inlined != (member_inline_size <= 4) {
7319                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7320                }
7321                let inner_offset;
7322                let mut inner_depth = depth.clone();
7323                if inlined {
7324                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7325                    inner_offset = next_offset;
7326                } else {
7327                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7328                    inner_depth.increment()?;
7329                }
7330                let val_ref = self
7331                    .source_moniker
7332                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
7333                fidl::decode!(
7334                    fidl::encoding::UnboundedString,
7335                    D,
7336                    val_ref,
7337                    decoder,
7338                    inner_offset,
7339                    inner_depth
7340                )?;
7341                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7342                {
7343                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7344                }
7345                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7346                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7347                }
7348            }
7349
7350            next_offset += envelope_size;
7351            _next_ordinal_to_read += 1;
7352            if next_offset >= end_offset {
7353                return Ok(());
7354            }
7355
7356            // Decode unknown envelopes for gaps in ordinals.
7357            while _next_ordinal_to_read < 5 {
7358                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7359                _next_ordinal_to_read += 1;
7360                next_offset += envelope_size;
7361            }
7362
7363            let next_out_of_line = decoder.next_out_of_line();
7364            let handles_before = decoder.remaining_handles();
7365            if let Some((inlined, num_bytes, num_handles)) =
7366                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7367            {
7368                let member_inline_size = <fidl::encoding::UnboundedVector<ServiceInstance> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7369                if inlined != (member_inline_size <= 4) {
7370                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7371                }
7372                let inner_offset;
7373                let mut inner_depth = depth.clone();
7374                if inlined {
7375                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7376                    inner_offset = next_offset;
7377                } else {
7378                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7379                    inner_depth.increment()?;
7380                }
7381                let val_ref = self.service_instances.get_or_insert_with(|| {
7382                    fidl::new_empty!(fidl::encoding::UnboundedVector<ServiceInstance>, D)
7383                });
7384                fidl::decode!(
7385                    fidl::encoding::UnboundedVector<ServiceInstance>,
7386                    D,
7387                    val_ref,
7388                    decoder,
7389                    inner_offset,
7390                    inner_depth
7391                )?;
7392                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7393                {
7394                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7395                }
7396                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7397                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7398                }
7399            }
7400
7401            next_offset += envelope_size;
7402            _next_ordinal_to_read += 1;
7403            if next_offset >= end_offset {
7404                return Ok(());
7405            }
7406
7407            // Decode unknown envelopes for gaps in ordinals.
7408            while _next_ordinal_to_read < 6 {
7409                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7410                _next_ordinal_to_read += 1;
7411                next_offset += envelope_size;
7412            }
7413
7414            let next_out_of_line = decoder.next_out_of_line();
7415            let handles_before = decoder.remaining_handles();
7416            if let Some((inlined, num_bytes, num_handles)) =
7417                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7418            {
7419                let member_inline_size = <fidl_fuchsia_component_decl__common::Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7420                if inlined != (member_inline_size <= 4) {
7421                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7422                }
7423                let inner_offset;
7424                let mut inner_depth = depth.clone();
7425                if inlined {
7426                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7427                    inner_offset = next_offset;
7428                } else {
7429                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7430                    inner_depth.increment()?;
7431                }
7432                let val_ref = self.availability.get_or_insert_with(|| {
7433                    fidl::new_empty!(fidl_fuchsia_component_decl__common::Availability, D)
7434                });
7435                fidl::decode!(
7436                    fidl_fuchsia_component_decl__common::Availability,
7437                    D,
7438                    val_ref,
7439                    decoder,
7440                    inner_offset,
7441                    inner_depth
7442                )?;
7443                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7444                {
7445                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7446                }
7447                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7448                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7449                }
7450            }
7451
7452            next_offset += envelope_size;
7453            _next_ordinal_to_read += 1;
7454            if next_offset >= end_offset {
7455                return Ok(());
7456            }
7457
7458            // Decode unknown envelopes for gaps in ordinals.
7459            while _next_ordinal_to_read < 7 {
7460                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7461                _next_ordinal_to_read += 1;
7462                next_offset += envelope_size;
7463            }
7464
7465            let next_out_of_line = decoder.next_out_of_line();
7466            let handles_before = decoder.remaining_handles();
7467            if let Some((inlined, num_bytes, num_handles)) =
7468                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7469            {
7470                let member_inline_size =
7471                    <RouteOutcome as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7472                if inlined != (member_inline_size <= 4) {
7473                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7474                }
7475                let inner_offset;
7476                let mut inner_depth = depth.clone();
7477                if inlined {
7478                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7479                    inner_offset = next_offset;
7480                } else {
7481                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7482                    inner_depth.increment()?;
7483                }
7484                let val_ref = self.outcome.get_or_insert_with(|| fidl::new_empty!(RouteOutcome, D));
7485                fidl::decode!(RouteOutcome, D, val_ref, decoder, inner_offset, inner_depth)?;
7486                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7487                {
7488                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7489                }
7490                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7491                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7492                }
7493            }
7494
7495            next_offset += envelope_size;
7496
7497            // Decode the remaining unknown envelopes.
7498            while next_offset < end_offset {
7499                _next_ordinal_to_read += 1;
7500                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7501                next_offset += envelope_size;
7502            }
7503
7504            Ok(())
7505        }
7506    }
7507
7508    impl ServiceInstance {
7509        #[inline(always)]
7510        fn max_ordinal_present(&self) -> u64 {
7511            if let Some(_) = self.child_instance_name {
7512                return 3;
7513            }
7514            if let Some(_) = self.child_name {
7515                return 2;
7516            }
7517            if let Some(_) = self.instance_name {
7518                return 1;
7519            }
7520            0
7521        }
7522    }
7523
7524    impl fidl::encoding::ValueTypeMarker for ServiceInstance {
7525        type Borrowed<'a> = &'a Self;
7526        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7527            value
7528        }
7529    }
7530
7531    unsafe impl fidl::encoding::TypeMarker for ServiceInstance {
7532        type Owned = Self;
7533
7534        #[inline(always)]
7535        fn inline_align(_context: fidl::encoding::Context) -> usize {
7536            8
7537        }
7538
7539        #[inline(always)]
7540        fn inline_size(_context: fidl::encoding::Context) -> usize {
7541            16
7542        }
7543    }
7544
7545    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceInstance, D>
7546        for &ServiceInstance
7547    {
7548        unsafe fn encode(
7549            self,
7550            encoder: &mut fidl::encoding::Encoder<'_, D>,
7551            offset: usize,
7552            mut depth: fidl::encoding::Depth,
7553        ) -> fidl::Result<()> {
7554            encoder.debug_check_bounds::<ServiceInstance>(offset);
7555            // Vector header
7556            let max_ordinal: u64 = self.max_ordinal_present();
7557            encoder.write_num(max_ordinal, offset);
7558            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7559            // Calling encoder.out_of_line_offset(0) is not allowed.
7560            if max_ordinal == 0 {
7561                return Ok(());
7562            }
7563            depth.increment()?;
7564            let envelope_size = 8;
7565            let bytes_len = max_ordinal as usize * envelope_size;
7566            #[allow(unused_variables)]
7567            let offset = encoder.out_of_line_offset(bytes_len);
7568            let mut _prev_end_offset: usize = 0;
7569            if 1 > max_ordinal {
7570                return Ok(());
7571            }
7572
7573            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7574            // are envelope_size bytes.
7575            let cur_offset: usize = (1 - 1) * envelope_size;
7576
7577            // Zero reserved fields.
7578            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7579
7580            // Safety:
7581            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7582            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7583            //   envelope_size bytes, there is always sufficient room.
7584            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
7585                self.instance_name.as_ref().map(
7586                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
7587                ),
7588                encoder,
7589                offset + cur_offset,
7590                depth,
7591            )?;
7592
7593            _prev_end_offset = cur_offset + envelope_size;
7594            if 2 > max_ordinal {
7595                return Ok(());
7596            }
7597
7598            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7599            // are envelope_size bytes.
7600            let cur_offset: usize = (2 - 1) * envelope_size;
7601
7602            // Zero reserved fields.
7603            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7604
7605            // Safety:
7606            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7607            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7608            //   envelope_size bytes, there is always sufficient room.
7609            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
7610                self.child_name.as_ref().map(
7611                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
7612                ),
7613                encoder,
7614                offset + cur_offset,
7615                depth,
7616            )?;
7617
7618            _prev_end_offset = cur_offset + envelope_size;
7619            if 3 > max_ordinal {
7620                return Ok(());
7621            }
7622
7623            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7624            // are envelope_size bytes.
7625            let cur_offset: usize = (3 - 1) * envelope_size;
7626
7627            // Zero reserved fields.
7628            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7629
7630            // Safety:
7631            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7632            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7633            //   envelope_size bytes, there is always sufficient room.
7634            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
7635                self.child_instance_name.as_ref().map(
7636                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
7637                ),
7638                encoder,
7639                offset + cur_offset,
7640                depth,
7641            )?;
7642
7643            _prev_end_offset = cur_offset + envelope_size;
7644
7645            Ok(())
7646        }
7647    }
7648
7649    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceInstance {
7650        #[inline(always)]
7651        fn new_empty() -> Self {
7652            Self::default()
7653        }
7654
7655        unsafe fn decode(
7656            &mut self,
7657            decoder: &mut fidl::encoding::Decoder<'_, D>,
7658            offset: usize,
7659            mut depth: fidl::encoding::Depth,
7660        ) -> fidl::Result<()> {
7661            decoder.debug_check_bounds::<Self>(offset);
7662            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7663                None => return Err(fidl::Error::NotNullable),
7664                Some(len) => len,
7665            };
7666            // Calling decoder.out_of_line_offset(0) is not allowed.
7667            if len == 0 {
7668                return Ok(());
7669            };
7670            depth.increment()?;
7671            let envelope_size = 8;
7672            let bytes_len = len * envelope_size;
7673            let offset = decoder.out_of_line_offset(bytes_len)?;
7674            // Decode the envelope for each type.
7675            let mut _next_ordinal_to_read = 0;
7676            let mut next_offset = offset;
7677            let end_offset = offset + bytes_len;
7678            _next_ordinal_to_read += 1;
7679            if next_offset >= end_offset {
7680                return Ok(());
7681            }
7682
7683            // Decode unknown envelopes for gaps in ordinals.
7684            while _next_ordinal_to_read < 1 {
7685                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7686                _next_ordinal_to_read += 1;
7687                next_offset += envelope_size;
7688            }
7689
7690            let next_out_of_line = decoder.next_out_of_line();
7691            let handles_before = decoder.remaining_handles();
7692            if let Some((inlined, num_bytes, num_handles)) =
7693                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7694            {
7695                let member_inline_size =
7696                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
7697                        decoder.context,
7698                    );
7699                if inlined != (member_inline_size <= 4) {
7700                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7701                }
7702                let inner_offset;
7703                let mut inner_depth = depth.clone();
7704                if inlined {
7705                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7706                    inner_offset = next_offset;
7707                } else {
7708                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7709                    inner_depth.increment()?;
7710                }
7711                let val_ref = self
7712                    .instance_name
7713                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
7714                fidl::decode!(
7715                    fidl::encoding::UnboundedString,
7716                    D,
7717                    val_ref,
7718                    decoder,
7719                    inner_offset,
7720                    inner_depth
7721                )?;
7722                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7723                {
7724                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7725                }
7726                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7727                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7728                }
7729            }
7730
7731            next_offset += envelope_size;
7732            _next_ordinal_to_read += 1;
7733            if next_offset >= end_offset {
7734                return Ok(());
7735            }
7736
7737            // Decode unknown envelopes for gaps in ordinals.
7738            while _next_ordinal_to_read < 2 {
7739                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7740                _next_ordinal_to_read += 1;
7741                next_offset += envelope_size;
7742            }
7743
7744            let next_out_of_line = decoder.next_out_of_line();
7745            let handles_before = decoder.remaining_handles();
7746            if let Some((inlined, num_bytes, num_handles)) =
7747                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7748            {
7749                let member_inline_size =
7750                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
7751                        decoder.context,
7752                    );
7753                if inlined != (member_inline_size <= 4) {
7754                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7755                }
7756                let inner_offset;
7757                let mut inner_depth = depth.clone();
7758                if inlined {
7759                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7760                    inner_offset = next_offset;
7761                } else {
7762                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7763                    inner_depth.increment()?;
7764                }
7765                let val_ref = self
7766                    .child_name
7767                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
7768                fidl::decode!(
7769                    fidl::encoding::UnboundedString,
7770                    D,
7771                    val_ref,
7772                    decoder,
7773                    inner_offset,
7774                    inner_depth
7775                )?;
7776                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7777                {
7778                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7779                }
7780                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7781                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7782                }
7783            }
7784
7785            next_offset += envelope_size;
7786            _next_ordinal_to_read += 1;
7787            if next_offset >= end_offset {
7788                return Ok(());
7789            }
7790
7791            // Decode unknown envelopes for gaps in ordinals.
7792            while _next_ordinal_to_read < 3 {
7793                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7794                _next_ordinal_to_read += 1;
7795                next_offset += envelope_size;
7796            }
7797
7798            let next_out_of_line = decoder.next_out_of_line();
7799            let handles_before = decoder.remaining_handles();
7800            if let Some((inlined, num_bytes, num_handles)) =
7801                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7802            {
7803                let member_inline_size =
7804                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
7805                        decoder.context,
7806                    );
7807                if inlined != (member_inline_size <= 4) {
7808                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7809                }
7810                let inner_offset;
7811                let mut inner_depth = depth.clone();
7812                if inlined {
7813                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7814                    inner_offset = next_offset;
7815                } else {
7816                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7817                    inner_depth.increment()?;
7818                }
7819                let val_ref = self
7820                    .child_instance_name
7821                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
7822                fidl::decode!(
7823                    fidl::encoding::UnboundedString,
7824                    D,
7825                    val_ref,
7826                    decoder,
7827                    inner_offset,
7828                    inner_depth
7829                )?;
7830                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7831                {
7832                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7833                }
7834                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7835                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7836                }
7837            }
7838
7839            next_offset += envelope_size;
7840
7841            // Decode the remaining unknown envelopes.
7842            while next_offset < end_offset {
7843                _next_ordinal_to_read += 1;
7844                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7845                next_offset += envelope_size;
7846            }
7847
7848            Ok(())
7849        }
7850    }
7851
7852    impl StorageStatus {
7853        #[inline(always)]
7854        fn max_ordinal_present(&self) -> u64 {
7855            if let Some(_) = self.used_size {
7856                return 2;
7857            }
7858            if let Some(_) = self.total_size {
7859                return 1;
7860            }
7861            0
7862        }
7863    }
7864
7865    impl fidl::encoding::ValueTypeMarker for StorageStatus {
7866        type Borrowed<'a> = &'a Self;
7867        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7868            value
7869        }
7870    }
7871
7872    unsafe impl fidl::encoding::TypeMarker for StorageStatus {
7873        type Owned = Self;
7874
7875        #[inline(always)]
7876        fn inline_align(_context: fidl::encoding::Context) -> usize {
7877            8
7878        }
7879
7880        #[inline(always)]
7881        fn inline_size(_context: fidl::encoding::Context) -> usize {
7882            16
7883        }
7884    }
7885
7886    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StorageStatus, D>
7887        for &StorageStatus
7888    {
7889        unsafe fn encode(
7890            self,
7891            encoder: &mut fidl::encoding::Encoder<'_, D>,
7892            offset: usize,
7893            mut depth: fidl::encoding::Depth,
7894        ) -> fidl::Result<()> {
7895            encoder.debug_check_bounds::<StorageStatus>(offset);
7896            // Vector header
7897            let max_ordinal: u64 = self.max_ordinal_present();
7898            encoder.write_num(max_ordinal, offset);
7899            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7900            // Calling encoder.out_of_line_offset(0) is not allowed.
7901            if max_ordinal == 0 {
7902                return Ok(());
7903            }
7904            depth.increment()?;
7905            let envelope_size = 8;
7906            let bytes_len = max_ordinal as usize * envelope_size;
7907            #[allow(unused_variables)]
7908            let offset = encoder.out_of_line_offset(bytes_len);
7909            let mut _prev_end_offset: usize = 0;
7910            if 1 > max_ordinal {
7911                return Ok(());
7912            }
7913
7914            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7915            // are envelope_size bytes.
7916            let cur_offset: usize = (1 - 1) * envelope_size;
7917
7918            // Zero reserved fields.
7919            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7920
7921            // Safety:
7922            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7923            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7924            //   envelope_size bytes, there is always sufficient room.
7925            fidl::encoding::encode_in_envelope_optional::<u64, D>(
7926                self.total_size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7927                encoder,
7928                offset + cur_offset,
7929                depth,
7930            )?;
7931
7932            _prev_end_offset = cur_offset + envelope_size;
7933            if 2 > max_ordinal {
7934                return Ok(());
7935            }
7936
7937            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7938            // are envelope_size bytes.
7939            let cur_offset: usize = (2 - 1) * envelope_size;
7940
7941            // Zero reserved fields.
7942            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7943
7944            // Safety:
7945            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7946            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7947            //   envelope_size bytes, there is always sufficient room.
7948            fidl::encoding::encode_in_envelope_optional::<u64, D>(
7949                self.used_size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7950                encoder,
7951                offset + cur_offset,
7952                depth,
7953            )?;
7954
7955            _prev_end_offset = cur_offset + envelope_size;
7956
7957            Ok(())
7958        }
7959    }
7960
7961    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StorageStatus {
7962        #[inline(always)]
7963        fn new_empty() -> Self {
7964            Self::default()
7965        }
7966
7967        unsafe fn decode(
7968            &mut self,
7969            decoder: &mut fidl::encoding::Decoder<'_, D>,
7970            offset: usize,
7971            mut depth: fidl::encoding::Depth,
7972        ) -> fidl::Result<()> {
7973            decoder.debug_check_bounds::<Self>(offset);
7974            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7975                None => return Err(fidl::Error::NotNullable),
7976                Some(len) => len,
7977            };
7978            // Calling decoder.out_of_line_offset(0) is not allowed.
7979            if len == 0 {
7980                return Ok(());
7981            };
7982            depth.increment()?;
7983            let envelope_size = 8;
7984            let bytes_len = len * envelope_size;
7985            let offset = decoder.out_of_line_offset(bytes_len)?;
7986            // Decode the envelope for each type.
7987            let mut _next_ordinal_to_read = 0;
7988            let mut next_offset = offset;
7989            let end_offset = offset + bytes_len;
7990            _next_ordinal_to_read += 1;
7991            if next_offset >= end_offset {
7992                return Ok(());
7993            }
7994
7995            // Decode unknown envelopes for gaps in ordinals.
7996            while _next_ordinal_to_read < 1 {
7997                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7998                _next_ordinal_to_read += 1;
7999                next_offset += envelope_size;
8000            }
8001
8002            let next_out_of_line = decoder.next_out_of_line();
8003            let handles_before = decoder.remaining_handles();
8004            if let Some((inlined, num_bytes, num_handles)) =
8005                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8006            {
8007                let member_inline_size =
8008                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8009                if inlined != (member_inline_size <= 4) {
8010                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8011                }
8012                let inner_offset;
8013                let mut inner_depth = depth.clone();
8014                if inlined {
8015                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8016                    inner_offset = next_offset;
8017                } else {
8018                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8019                    inner_depth.increment()?;
8020                }
8021                let val_ref = self.total_size.get_or_insert_with(|| fidl::new_empty!(u64, D));
8022                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
8023                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8024                {
8025                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8026                }
8027                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8028                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8029                }
8030            }
8031
8032            next_offset += envelope_size;
8033            _next_ordinal_to_read += 1;
8034            if next_offset >= end_offset {
8035                return Ok(());
8036            }
8037
8038            // Decode unknown envelopes for gaps in ordinals.
8039            while _next_ordinal_to_read < 2 {
8040                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8041                _next_ordinal_to_read += 1;
8042                next_offset += envelope_size;
8043            }
8044
8045            let next_out_of_line = decoder.next_out_of_line();
8046            let handles_before = decoder.remaining_handles();
8047            if let Some((inlined, num_bytes, num_handles)) =
8048                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8049            {
8050                let member_inline_size =
8051                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8052                if inlined != (member_inline_size <= 4) {
8053                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8054                }
8055                let inner_offset;
8056                let mut inner_depth = depth.clone();
8057                if inlined {
8058                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8059                    inner_offset = next_offset;
8060                } else {
8061                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8062                    inner_depth.increment()?;
8063                }
8064                let val_ref = self.used_size.get_or_insert_with(|| fidl::new_empty!(u64, D));
8065                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
8066                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8067                {
8068                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8069                }
8070                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8071                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8072                }
8073            }
8074
8075            next_offset += envelope_size;
8076
8077            // Decode the remaining unknown envelopes.
8078            while next_offset < end_offset {
8079                _next_ordinal_to_read += 1;
8080                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8081                next_offset += envelope_size;
8082            }
8083
8084            Ok(())
8085        }
8086    }
8087
8088    impl fidl::encoding::ValueTypeMarker for ChildLocation {
8089        type Borrowed<'a> = &'a Self;
8090        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8091            value
8092        }
8093    }
8094
8095    unsafe impl fidl::encoding::TypeMarker for ChildLocation {
8096        type Owned = Self;
8097
8098        #[inline(always)]
8099        fn inline_align(_context: fidl::encoding::Context) -> usize {
8100            8
8101        }
8102
8103        #[inline(always)]
8104        fn inline_size(_context: fidl::encoding::Context) -> usize {
8105            16
8106        }
8107    }
8108
8109    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChildLocation, D>
8110        for &ChildLocation
8111    {
8112        #[inline]
8113        unsafe fn encode(
8114            self,
8115            encoder: &mut fidl::encoding::Encoder<'_, D>,
8116            offset: usize,
8117            _depth: fidl::encoding::Depth,
8118        ) -> fidl::Result<()> {
8119            encoder.debug_check_bounds::<ChildLocation>(offset);
8120            encoder.write_num::<u64>(self.ordinal(), offset);
8121            match self {
8122                ChildLocation::Collection(ref val) => fidl::encoding::encode_in_envelope::<
8123                    fidl::encoding::BoundedString<255>,
8124                    D,
8125                >(
8126                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
8127                        val,
8128                    ),
8129                    encoder,
8130                    offset + 8,
8131                    _depth,
8132                ),
8133                ChildLocation::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
8134            }
8135        }
8136    }
8137
8138    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChildLocation {
8139        #[inline(always)]
8140        fn new_empty() -> Self {
8141            Self::__SourceBreaking { unknown_ordinal: 0 }
8142        }
8143
8144        #[inline]
8145        unsafe fn decode(
8146            &mut self,
8147            decoder: &mut fidl::encoding::Decoder<'_, D>,
8148            offset: usize,
8149            mut depth: fidl::encoding::Depth,
8150        ) -> fidl::Result<()> {
8151            decoder.debug_check_bounds::<Self>(offset);
8152            #[allow(unused_variables)]
8153            let next_out_of_line = decoder.next_out_of_line();
8154            let handles_before = decoder.remaining_handles();
8155            let (ordinal, inlined, num_bytes, num_handles) =
8156                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
8157
8158            let member_inline_size = match ordinal {
8159                1 => {
8160                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
8161                        decoder.context,
8162                    )
8163                }
8164                0 => return Err(fidl::Error::UnknownUnionTag),
8165                _ => num_bytes as usize,
8166            };
8167
8168            if inlined != (member_inline_size <= 4) {
8169                return Err(fidl::Error::InvalidInlineBitInEnvelope);
8170            }
8171            let _inner_offset;
8172            if inlined {
8173                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
8174                _inner_offset = offset + 8;
8175            } else {
8176                depth.increment()?;
8177                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8178            }
8179            match ordinal {
8180                1 => {
8181                    #[allow(irrefutable_let_patterns)]
8182                    if let ChildLocation::Collection(_) = self {
8183                        // Do nothing, read the value into the object
8184                    } else {
8185                        // Initialize `self` to the right variant
8186                        *self = ChildLocation::Collection(fidl::new_empty!(
8187                            fidl::encoding::BoundedString<255>,
8188                            D
8189                        ));
8190                    }
8191                    #[allow(irrefutable_let_patterns)]
8192                    if let ChildLocation::Collection(ref mut val) = self {
8193                        fidl::decode!(
8194                            fidl::encoding::BoundedString<255>,
8195                            D,
8196                            val,
8197                            decoder,
8198                            _inner_offset,
8199                            depth
8200                        )?;
8201                    } else {
8202                        unreachable!()
8203                    }
8204                }
8205                #[allow(deprecated)]
8206                ordinal => {
8207                    for _ in 0..num_handles {
8208                        decoder.drop_next_handle()?;
8209                    }
8210                    *self = ChildLocation::__SourceBreaking { unknown_ordinal: ordinal };
8211                }
8212            }
8213            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
8214                return Err(fidl::Error::InvalidNumBytesInEnvelope);
8215            }
8216            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8217                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8218            }
8219            Ok(())
8220        }
8221    }
8222}