fidl_fuchsia_component_internal__common/
fidl_fuchsia_component_internal__common.rs

Help
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/// A single entry in an allowlist, expressed in one of three forms:
12///
13///   1. Exact moniker - Most entries should fall under this case,
14///      where the exact monikers of allowed components are listed.
15///      For example, "/foo/bar".
16///   2. Realm - Realms can be allowlisted such that any descendant will be
17///      allowed without being listed explicitly. For example, "/foo/**"
18///      allows any descendant of "/foo" (but not foo itself).
19///   3. Collection - Individual collections can also be allowlisted. For
20///      example, "/foo/bar:**" will allow any child in foo's "bar"
21///      collection and any descendant thereof, but not foo or other
22///      children of foo.
23pub type AllowlistEntryMoniker = String;
24
25/// 256 bits encoded in lower-cased base64 (64 chars).
26pub type InstanceId = String;
27
28pub type Moniker = String;
29
30/// The maximum size of the JobPolicyAllowlists entries.
31/// This value is currently set arbitrarily.
32pub const MAX_ALLOWLIST_SIZE: u64 = 128;
33
34/// The builtin resolver to use for the fuchsia-boot scheme, if any.
35#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
36#[repr(u8)]
37pub enum BuiltinBootResolver {
38    /// No builtin boot resolver is used.
39    None = 1,
40    /// Try to use the /boot directory from the namespace. Typically this is provided
41    /// to component manager during initialization of the system.
42    Boot = 2,
43}
44
45impl BuiltinBootResolver {
46    #[inline]
47    pub fn from_primitive(prim: u8) -> Option<Self> {
48        match prim {
49            1 => Some(Self::None),
50            2 => Some(Self::Boot),
51            _ => None,
52        }
53    }
54
55    #[inline]
56    pub const fn into_primitive(self) -> u8 {
57        self as u8
58    }
59}
60
61/// Where to log to.
62#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
63#[repr(u8)]
64pub enum LogDestination {
65    /// Log to syslog.
66    Syslog = 1,
67    /// Log to klog.
68    Klog = 2,
69}
70
71impl LogDestination {
72    #[inline]
73    pub fn from_primitive(prim: u8) -> Option<Self> {
74        match prim {
75            1 => Some(Self::Syslog),
76            2 => Some(Self::Klog),
77            _ => None,
78        }
79    }
80
81    #[inline]
82    pub const fn into_primitive(self) -> u8 {
83        self as u8
84    }
85}
86
87/// If and how the realm builder resolver and runner will be used.
88#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
89#[repr(u8)]
90pub enum RealmBuilderResolverAndRunner {
91    /// The realm builder resolver and runner are not used.
92    None = 1,
93    /// The realm builder resolver and runner will be accessed through component
94    /// manager's namespace, and made available to the root realm.
95    Namespace = 2,
96}
97
98impl RealmBuilderResolverAndRunner {
99    #[inline]
100    pub fn from_primitive(prim: u8) -> Option<Self> {
101        match prim {
102            1 => Some(Self::None),
103            2 => Some(Self::Namespace),
104            _ => None,
105        }
106    }
107
108    #[inline]
109    pub const fn into_primitive(self) -> u8 {
110        self as u8
111    }
112}
113
114/// Where to obtain the trace provider from.
115/// to find the trace provider to register with.
116#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
117#[repr(u8)]
118pub enum TraceProvider {
119    /// Default. Get it from the normal fuchsia.tracing.provider.Registry.
120    Namespace = 1,
121    /// Get it from the root component's exposed directory. It is expected that the root
122    /// component exposes `fuchsia.tracing.provider.Registry` protocol to its parent.
123    RootExposed = 2,
124}
125
126impl TraceProvider {
127    #[inline]
128    pub fn from_primitive(prim: u8) -> Option<Self> {
129        match prim {
130            1 => Some(Self::Namespace),
131            2 => Some(Self::RootExposed),
132            _ => None,
133        }
134    }
135
136    #[inline]
137    pub const fn into_primitive(self) -> u8 {
138        self as u8
139    }
140}
141
142/// Where to obtain the vmex resource from, if this component_manager is hosting bootfs.
143#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
144#[repr(u8)]
145pub enum VmexSource {
146    /// Get it from the PA_SYSTEM_RESOURCE handle passed to component_manager
147    SystemResource = 1,
148    /// Get it from the /svc/fuchsia.kernel.VmexResource protocol in
149    /// component_manager's namespace.
150    Namespace = 2,
151}
152
153impl VmexSource {
154    #[inline]
155    pub fn from_primitive(prim: u8) -> Option<Self> {
156        match prim {
157            1 => Some(Self::SystemResource),
158            2 => Some(Self::Namespace),
159            _ => None,
160        }
161    }
162
163    #[inline]
164    pub const fn into_primitive(self) -> u8 {
165        self as u8
166    }
167}
168
169/// The enforcement and validation policy to apply to component target ABI revisions.
170#[derive(Clone, Debug, Default, PartialEq)]
171pub struct AbiRevisionPolicy {
172    /// Allowlist entry monikers for components that will be permitted to run
173    /// even if they fail ABI revision checks. This should _never_ be used. Any
174    /// component that bypasses these checks is unsupported by the platform and
175    /// may behave in unexpected ways!
176    pub allowlist: Option<Vec<String>>,
177    #[doc(hidden)]
178    pub __source_breaking: fidl::marker::SourceBreaking,
179}
180
181impl fidl::Persistable for AbiRevisionPolicy {}
182
183#[derive(Clone, Debug, Default, PartialEq)]
184pub struct AllowlistedDirectory {
185    #[doc(hidden)]
186    pub __source_breaking: fidl::marker::SourceBreaking,
187}
188
189impl fidl::Persistable for AllowlistedDirectory {}
190
191#[derive(Clone, Debug, Default, PartialEq)]
192pub struct AllowlistedProtocol {
193    #[doc(hidden)]
194    pub __source_breaking: fidl::marker::SourceBreaking,
195}
196
197impl fidl::Persistable for AllowlistedProtocol {}
198
199#[derive(Clone, Debug, Default, PartialEq)]
200pub struct AllowlistedResolver {
201    #[doc(hidden)]
202    pub __source_breaking: fidl::marker::SourceBreaking,
203}
204
205impl fidl::Persistable for AllowlistedResolver {}
206
207#[derive(Clone, Debug, Default, PartialEq)]
208pub struct AllowlistedRunner {
209    #[doc(hidden)]
210    pub __source_breaking: fidl::marker::SourceBreaking,
211}
212
213impl fidl::Persistable for AllowlistedRunner {}
214
215#[derive(Clone, Debug, Default, PartialEq)]
216pub struct AllowlistedService {
217    #[doc(hidden)]
218    pub __source_breaking: fidl::marker::SourceBreaking,
219}
220
221impl fidl::Persistable for AllowlistedService {}
222
223#[derive(Clone, Debug, Default, PartialEq)]
224pub struct AllowlistedStorage {
225    #[doc(hidden)]
226    pub __source_breaking: fidl::marker::SourceBreaking,
227}
228
229impl fidl::Persistable for AllowlistedStorage {}
230
231#[derive(Clone, Debug, Default, PartialEq)]
232pub struct AnonymizedAggregate {
233    pub capability: Option<AggregateCapability>,
234    pub moniker: Option<String>,
235    pub members: Option<Vec<AggregateMember>>,
236    pub sources: Option<Sources>,
237    pub instances: Option<Vec<fidl_fuchsia_sys2__common::ServiceInstance>>,
238    #[doc(hidden)]
239    pub __source_breaking: fidl::marker::SourceBreaking,
240}
241
242impl fidl::Persistable for AnonymizedAggregate {}
243
244#[derive(Clone, Debug, Default, PartialEq)]
245pub struct Builtin {
246    pub capability: Option<InternalCapability>,
247    #[doc(hidden)]
248    pub __source_breaking: fidl::marker::SourceBreaking,
249}
250
251impl fidl::Persistable for Builtin {}
252
253#[derive(Clone, Debug, Default, PartialEq)]
254pub struct Capability {
255    pub source_capability: Option<ComponentCapability>,
256    pub moniker: Option<String>,
257    #[doc(hidden)]
258    pub __source_breaking: fidl::marker::SourceBreaking,
259}
260
261impl fidl::Persistable for Capability {}
262
263/// Defines a single capability policy entry in the set of capability policy
264/// allowlists.
265#[derive(Clone, Debug, Default, PartialEq)]
266pub struct CapabilityAllowlistEntry {
267    /// The `source_moniker` represents the origin of a capability. The
268    /// `source_moniker` is either a moniker or '<component_manager>'.
269    pub source_moniker: Option<String>,
270    /// The source name of this particular capability.
271    pub source_name: Option<String>,
272    /// Represents the type of capability that is being restricted along
273    /// with any other properties required by a particular capability type.
274    pub capability: Option<AllowlistedCapability>,
275    /// The set of components, described by either exact monikers, realm, or collection,
276    /// that are allowed to use this specific capability.
277    pub target_monikers: Option<Vec<String>>,
278    /// The original source type of this capability, self or framework.
279    pub source: Option<fidl_fuchsia_component_decl__common::Ref>,
280    #[doc(hidden)]
281    pub __source_breaking: fidl::marker::SourceBreaking,
282}
283
284impl fidl::Persistable for CapabilityAllowlistEntry {}
285
286/// Defines the total set of capability allowlists. Each
287/// `source_moniker` + `capability` pair must be unique in the vector.
288#[derive(Clone, Debug, Default, PartialEq)]
289pub struct CapabilityPolicyAllowlists {
290    pub allowlist: Option<Vec<CapabilityAllowlistEntry>>,
291    #[doc(hidden)]
292    pub __source_breaking: fidl::marker::SourceBreaking,
293}
294
295impl fidl::Persistable for CapabilityPolicyAllowlists {}
296
297/// Allowlists for privileged child options.
298#[derive(Clone, Debug, Default, PartialEq)]
299pub struct ChildPolicyAllowlists {
300    /// Allowlist entry monikers of component instances allowed to have the
301    /// `on_terminate=REBOOT` in their `children` declaration.
302    pub reboot_on_terminate: Option<Vec<String>>,
303    #[doc(hidden)]
304    pub __source_breaking: fidl::marker::SourceBreaking,
305}
306
307impl fidl::Persistable for ChildPolicyAllowlists {}
308
309#[derive(Clone, Debug, Default, PartialEq)]
310pub struct Component {
311    pub capability: Option<ComponentCapability>,
312    pub moniker: Option<String>,
313    #[doc(hidden)]
314    pub __source_breaking: fidl::marker::SourceBreaking,
315}
316
317impl fidl::Persistable for Component {}
318
319/// Top-level type describing the component ID index.
320#[derive(Clone, Debug, Default, PartialEq)]
321pub struct ComponentIdIndex {
322    /// A list of component ID instance entries.
323    ///
324    /// Required, but may be empty.
325    pub instances: Option<Vec<InstanceIdEntry>>,
326    #[doc(hidden)]
327    pub __source_breaking: fidl::marker::SourceBreaking,
328}
329
330impl fidl::Persistable for ComponentIdIndex {}
331
332#[derive(Clone, Debug, Default, PartialEq)]
333pub struct Config {
334    /// If true, component manager will be in debug mode. In this mode, component manager
335    /// provides the `EventSource` protocol and exposes this protocol. Component
336    /// manager will not start until it is resumed by a call to
337    /// `EventSource.StartComponentTree`.
338    ///
339    /// This is done so that an external component (say an integration test) can subscribe
340    /// to events before the root component has started.
341    pub debug: Option<bool>,
342    /// How many children, maximum, are returned by a call to `Realm.ChildIterator.next()`.
343    pub list_children_batch_size: Option<u32>,
344    /// Security policy configuration.
345    pub security_policy: Option<SecurityPolicy>,
346    /// Capabilities offered from component manager's namespace.
347    pub namespace_capabilities: Option<Vec<fidl_fuchsia_component_decl__common::Capability>>,
348    /// If true, component_manager will serve an instance of fuchsia.process.Launcher and use this
349    /// launcher for the built-in ELF component runner. The root component can additionally
350    /// use and/or offer this service using `/builtin/fuchsia.process.Launcher` from realm.
351    /// This flag exists because the built-in process launcher *only* works when
352    /// component_manager runs under a job that has ZX_POL_NEW_PROCESS set to allow, like the root
353    /// job. Otherwise, the component_manager process cannot directly create process through
354    /// zx_process_create. When we run component_manager elsewhere, like in test environments, it
355    /// has to use the fuchsia.process.Launcher service provided through its namespace instead.
356    pub use_builtin_process_launcher: Option<bool>,
357    /// If true, component_manager will maintain a UTC kernel clock and vend write handles through
358    /// an instance of `fuchsia.time.Maintenance`. This flag should only be used with the top-level
359    /// component_manager.
360    pub maintain_utc_clock: Option<bool>,
361    /// The number of threads to use for running component_manager's executor.
362    /// If not present, interpreted as 1.
363    pub num_threads: Option<u8>,
364    /// URL of the root component to launch. This field is used if the no URL
365    /// is passed to component manager. If value is passed in both places, then
366    /// an error is raised.
367    pub root_component_url: Option<String>,
368    /// Path to the component ID index. An empty value defaults to an empty index.
369    /// An invalid index causes component_manager to abort.
370    pub component_id_index_path: Option<String>,
371    /// Where to log to.
372    pub log_destination: Option<LogDestination>,
373    /// If true, component manager will log all events dispatched in the topology.
374    pub log_all_events: Option<bool>,
375    /// Which builtin resolver to use for the fuchsia-boot scheme.
376    /// If not present, interpreted as BuiltinBootResolver.NONE.
377    pub builtin_boot_resolver: Option<BuiltinBootResolver>,
378    /// If and how the realm builder resolver and runner will be used. Typically
379    /// these capabilities from realm builder are available to a nested
380    /// component manager that is undergoing an integration test.
381    pub realm_builder_resolver_and_runner: Option<RealmBuilderResolverAndRunner>,
382    /// Capabilities offered from component manager as built-in capabilities.
383    pub builtin_capabilities: Option<Vec<fidl_fuchsia_component_decl__common::Capability>>,
384    /// Enables Component Manager's introspection APIs (RealmQuery, RealmExplorer,
385    /// RouteValidator, LifecycleController, etc.) for use by components.
386    pub enable_introspection: Option<bool>,
387    /// The enforcement and validation policy to apply to component target ABI
388    /// revisions.
389    pub abi_revision_policy: Option<AbiRevisionPolicy>,
390    /// Where to obtain the vmex resource from, if this component_manager is hosting bootfs.
391    /// If not present, defaults to `VmexSource::SYSTEM_RESOURCE`.
392    pub vmex_source: Option<VmexSource>,
393    /// Information about the health checks during the update process.
394    pub health_check: Option<HealthCheck>,
395    /// Where to look for the trace provider. If missing, defaults to TraceProvider::NAMESPACE.
396    /// This is ignored on non-tracing builds.
397    pub trace_provider: Option<TraceProvider>,
398    #[doc(hidden)]
399    pub __source_breaking: fidl::marker::SourceBreaking,
400}
401
402impl fidl::Persistable for Config {}
403
404/// Defines a capability policy entry in the set of debug capability policy
405/// allowlists.
406#[derive(Clone, Debug, Default, PartialEq)]
407pub struct DebugRegistrationAllowlistEntry {
408    /// The name of the capability as it's registered in the environment.
409    pub name: Option<String>,
410    /// Represents the type of capability that is being restricted along
411    /// with any other properties required by a particular capability type.
412    pub debug: Option<AllowlistedDebugRegistration>,
413    /// The moniker of the component which is allowed to register
414    /// this capability in its environment's debug sction.
415    pub moniker: Option<String>,
416    /// Name of the environment where this capability can be registered.
417    pub environment_name: Option<String>,
418    #[doc(hidden)]
419    pub __source_breaking: fidl::marker::SourceBreaking,
420}
421
422impl fidl::Persistable for DebugRegistrationAllowlistEntry {}
423
424/// Defines the total set of debug capability allowlists.
425#[derive(Clone, Debug, Default, PartialEq)]
426pub struct DebugRegistrationPolicyAllowlists {
427    pub allowlist: Option<Vec<DebugRegistrationAllowlistEntry>>,
428    #[doc(hidden)]
429    pub __source_breaking: fidl::marker::SourceBreaking,
430}
431
432impl fidl::Persistable for DebugRegistrationPolicyAllowlists {}
433
434#[derive(Clone, Debug, Default, PartialEq)]
435pub struct Environment {
436    pub capability: Option<ComponentCapability>,
437    pub moniker: Option<String>,
438    #[doc(hidden)]
439    pub __source_breaking: fidl::marker::SourceBreaking,
440}
441
442impl fidl::Persistable for Environment {}
443
444#[derive(Clone, Debug, Default, PartialEq)]
445pub struct EnvironmentSource {
446    pub source_name: Option<String>,
447    pub source: Option<fidl_fuchsia_component_decl__common::Ref>,
448    #[doc(hidden)]
449    pub __source_breaking: fidl::marker::SourceBreaking,
450}
451
452impl fidl::Persistable for EnvironmentSource {}
453
454#[derive(Clone, Debug, Default, PartialEq)]
455pub struct FilteredAggregateProvider {
456    pub capability: Option<AggregateCapability>,
457    pub moniker: Option<String>,
458    pub offer_service_decls: Option<Vec<fidl_fuchsia_component_decl__common::OfferService>>,
459    pub sources: Option<Sources>,
460    #[doc(hidden)]
461    pub __source_breaking: fidl::marker::SourceBreaking,
462}
463
464impl fidl::Persistable for FilteredAggregateProvider {}
465
466#[derive(Clone, Debug, Default, PartialEq)]
467pub struct FilteredProvider {
468    pub capability: Option<AggregateCapability>,
469    pub moniker: Option<String>,
470    pub service_capability: Option<ComponentCapability>,
471    pub offer_service_decl: Option<fidl_fuchsia_component_decl__common::OfferService>,
472    #[doc(hidden)]
473    pub __source_breaking: fidl::marker::SourceBreaking,
474}
475
476impl fidl::Persistable for FilteredProvider {}
477
478#[derive(Clone, Debug, Default, PartialEq)]
479pub struct Framework {
480    pub capability: Option<InternalCapability>,
481    pub moniker: Option<String>,
482    #[doc(hidden)]
483    pub __source_breaking: fidl::marker::SourceBreaking,
484}
485
486impl fidl::Persistable for Framework {}
487
488/// Information about the health checks during the update process.
489#[derive(Clone, Debug, Default, PartialEq)]
490pub struct HealthCheck {
491    /// Component monikers that must be healthy in order to complete an OTA update.
492    pub monikers: Option<Vec<String>>,
493    #[doc(hidden)]
494    pub __source_breaking: fidl::marker::SourceBreaking,
495}
496
497impl fidl::Persistable for HealthCheck {}
498
499#[derive(Clone, Debug, Default, PartialEq)]
500pub struct InstanceIdEntry {
501    /// A 256-bit identifier encoded in base64 which is unique across all other
502    /// instance IDs in the index.
503    pub instance_id: Option<String>,
504    /// The moniker identifying the component instance.
505    pub moniker: Option<String>,
506    #[doc(hidden)]
507    pub __source_breaking: fidl::marker::SourceBreaking,
508}
509
510impl fidl::Persistable for InstanceIdEntry {}
511
512/// Allowlists for Zircon job policy.
513#[derive(Clone, Debug, Default, PartialEq)]
514pub struct JobPolicyAllowlists {
515    /// Allowlist entry monikers for components allowed to be given the
516    /// ZX_POL_AMBIENT_MARK_VMO_EXEC job policy.
517    ///
518    /// Components must request this policy by including "job_policy_ambient_mark_vmo_exec: true" in
519    /// their CML's `program` section and must be using the ELF runner.
520    /// This is equivalent to the v1 'deprecated-ambient-replace-as-executable' feature.
521    pub ambient_mark_vmo_exec: Option<Vec<String>>,
522    /// Allowlist entry monikers for components allowed to have their original process
523    /// marked as critical to component_manager's job.
524    ///
525    /// Components must request this critical marking by including "main_process_critical: true" in
526    /// their CML's `program` section and must be using the ELF runner.
527    pub main_process_critical: Option<Vec<String>>,
528    /// Allowlist entry monikers for components allowed to call zx_process_create directly
529    /// (e.g., do not have ZX_POL_NEW_PROCESS set to ZX_POL_ACTION_DENY).
530    ///
531    /// Components must request this policy by including "job_policy_create_raw_processes: true" in
532    /// their manifest's program object and must be using the ELF runner.
533    pub create_raw_processes: Option<Vec<String>>,
534    #[doc(hidden)]
535    pub __source_breaking: fidl::marker::SourceBreaking,
536}
537
538impl fidl::Persistable for JobPolicyAllowlists {}
539
540#[derive(Clone, Debug, Default, PartialEq)]
541pub struct Namespace {
542    pub capability: Option<ComponentCapability>,
543    #[doc(hidden)]
544    pub __source_breaking: fidl::marker::SourceBreaking,
545}
546
547impl fidl::Persistable for Namespace {}
548
549/// Runtime security policy.
550#[derive(Clone, Debug, Default, PartialEq)]
551pub struct SecurityPolicy {
552    /// Allowlists for Zircon job policy.
553    pub job_policy: Option<JobPolicyAllowlists>,
554    /// Capability access policy.
555    pub capability_policy: Option<CapabilityPolicyAllowlists>,
556    /// Debug capability registration policy.
557    pub debug_registration_policy: Option<DebugRegistrationPolicyAllowlists>,
558    /// Component child options policy.
559    pub child_policy: Option<ChildPolicyAllowlists>,
560    #[doc(hidden)]
561    pub __source_breaking: fidl::marker::SourceBreaking,
562}
563
564impl fidl::Persistable for SecurityPolicy {}
565
566#[derive(Clone, Debug, Default, PartialEq)]
567pub struct Sources {
568    pub framework: Option<bool>,
569    pub builtin: Option<bool>,
570    pub capability: Option<bool>,
571    pub collection: Option<bool>,
572    pub namespace: Option<bool>,
573    pub component: Option<bool>,
574    pub capability_type: Option<String>,
575    #[doc(hidden)]
576    pub __source_breaking: fidl::marker::SourceBreaking,
577}
578
579impl fidl::Persistable for Sources {}
580
581#[derive(Clone, Debug, Default, PartialEq)]
582pub struct Void {
583    pub capability: Option<InternalCapability>,
584    pub moniker: Option<String>,
585    #[doc(hidden)]
586    pub __source_breaking: fidl::marker::SourceBreaking,
587}
588
589impl fidl::Persistable for Void {}
590
591#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
592pub enum AggregateCapability {
593    Service(String),
594}
595
596impl AggregateCapability {
597    #[inline]
598    pub fn ordinal(&self) -> u64 {
599        match *self {
600            Self::Service(_) => 1,
601        }
602    }
603}
604
605impl fidl::Persistable for AggregateCapability {}
606
607#[derive(Clone, Debug, PartialEq)]
608pub enum AggregateMember {
609    Child(fidl_fuchsia_component_decl__common::ChildRef),
610    Collection(String),
611    Parent(fidl_fuchsia_component_decl__common::ParentRef),
612    Self_(fidl_fuchsia_component_decl__common::SelfRef),
613}
614
615impl AggregateMember {
616    #[inline]
617    pub fn ordinal(&self) -> u64 {
618        match *self {
619            Self::Child(_) => 1,
620            Self::Collection(_) => 2,
621            Self::Parent(_) => 3,
622            Self::Self_(_) => 4,
623        }
624    }
625}
626
627impl fidl::Persistable for AggregateMember {}
628
629/// Represents the class of capabilities supported to be allowlisted.
630#[derive(Clone, Debug)]
631pub enum AllowlistedCapability {
632    Directory(AllowlistedDirectory),
633    Protocol(AllowlistedProtocol),
634    Service(AllowlistedService),
635    Storage(AllowlistedStorage),
636    Runner(AllowlistedRunner),
637    Resolver(AllowlistedResolver),
638    #[doc(hidden)]
639    __SourceBreaking {
640        unknown_ordinal: u64,
641    },
642}
643
644/// Pattern that matches an unknown `AllowlistedCapability` member.
645#[macro_export]
646macro_rules! AllowlistedCapabilityUnknown {
647    () => {
648        _
649    };
650}
651
652// Custom PartialEq so that unknown variants are not equal to themselves.
653impl PartialEq for AllowlistedCapability {
654    fn eq(&self, other: &Self) -> bool {
655        match (self, other) {
656            (Self::Directory(x), Self::Directory(y)) => *x == *y,
657            (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
658            (Self::Service(x), Self::Service(y)) => *x == *y,
659            (Self::Storage(x), Self::Storage(y)) => *x == *y,
660            (Self::Runner(x), Self::Runner(y)) => *x == *y,
661            (Self::Resolver(x), Self::Resolver(y)) => *x == *y,
662            _ => false,
663        }
664    }
665}
666
667impl AllowlistedCapability {
668    #[inline]
669    pub fn ordinal(&self) -> u64 {
670        match *self {
671            Self::Directory(_) => 1,
672            Self::Protocol(_) => 3,
673            Self::Service(_) => 4,
674            Self::Storage(_) => 5,
675            Self::Runner(_) => 6,
676            Self::Resolver(_) => 7,
677            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
678        }
679    }
680
681    #[inline]
682    pub fn unknown_variant_for_testing() -> Self {
683        Self::__SourceBreaking { unknown_ordinal: 0 }
684    }
685
686    #[inline]
687    pub fn is_unknown(&self) -> bool {
688        match self {
689            Self::__SourceBreaking { .. } => true,
690            _ => false,
691        }
692    }
693}
694
695impl fidl::Persistable for AllowlistedCapability {}
696
697/// Represents the class of capabilities supported to be allowlisted.
698#[derive(Clone, Debug)]
699pub enum AllowlistedDebugRegistration {
700    Protocol(AllowlistedProtocol),
701    #[doc(hidden)]
702    __SourceBreaking {
703        unknown_ordinal: u64,
704    },
705}
706
707/// Pattern that matches an unknown `AllowlistedDebugRegistration` member.
708#[macro_export]
709macro_rules! AllowlistedDebugRegistrationUnknown {
710    () => {
711        _
712    };
713}
714
715// Custom PartialEq so that unknown variants are not equal to themselves.
716impl PartialEq for AllowlistedDebugRegistration {
717    fn eq(&self, other: &Self) -> bool {
718        match (self, other) {
719            (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
720            _ => false,
721        }
722    }
723}
724
725impl AllowlistedDebugRegistration {
726    #[inline]
727    pub fn ordinal(&self) -> u64 {
728        match *self {
729            Self::Protocol(_) => 1,
730            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
731        }
732    }
733
734    #[inline]
735    pub fn unknown_variant_for_testing() -> Self {
736        Self::__SourceBreaking { unknown_ordinal: 0 }
737    }
738
739    #[inline]
740    pub fn is_unknown(&self) -> bool {
741        match self {
742            Self::__SourceBreaking { .. } => true,
743            _ => false,
744        }
745    }
746}
747
748impl fidl::Persistable for AllowlistedDebugRegistration {}
749
750#[derive(Clone, Debug, PartialEq)]
751pub enum CapabilitySource {
752    Component(Component),
753    Framework(Framework),
754    Builtin(Builtin),
755    Namespace(Namespace),
756    Capability(Capability),
757    AnonymizedAggregate(AnonymizedAggregate),
758    FilteredProvider(FilteredProvider),
759    FilteredAggregateProvider(FilteredAggregateProvider),
760    Environment(Environment),
761    Void(Void),
762}
763
764impl CapabilitySource {
765    #[inline]
766    pub fn ordinal(&self) -> u64 {
767        match *self {
768            Self::Component(_) => 1,
769            Self::Framework(_) => 2,
770            Self::Builtin(_) => 3,
771            Self::Namespace(_) => 4,
772            Self::Capability(_) => 5,
773            Self::AnonymizedAggregate(_) => 6,
774            Self::FilteredProvider(_) => 7,
775            Self::FilteredAggregateProvider(_) => 8,
776            Self::Environment(_) => 9,
777            Self::Void(_) => 10,
778        }
779    }
780}
781
782impl fidl::Persistable for CapabilitySource {}
783
784#[derive(Clone, Debug, PartialEq)]
785pub enum ComponentCapability {
786    Use_(fidl_fuchsia_component_decl__common::Use),
787    Offer(fidl_fuchsia_component_decl__common::Offer),
788    Expose(fidl_fuchsia_component_decl__common::Expose),
789    Config(fidl_fuchsia_component_decl__common::Configuration),
790    Dictionary(fidl_fuchsia_component_decl__common::Dictionary),
791    Directory(fidl_fuchsia_component_decl__common::Directory),
792    Environment(EnvironmentCapability),
793    EventStream(fidl_fuchsia_component_decl__common::EventStream),
794    Protocol(fidl_fuchsia_component_decl__common::Protocol),
795    Resolver(fidl_fuchsia_component_decl__common::Resolver),
796    Runner(fidl_fuchsia_component_decl__common::Runner),
797    Service(fidl_fuchsia_component_decl__common::Service),
798    Storage(fidl_fuchsia_component_decl__common::Storage),
799}
800
801impl ComponentCapability {
802    #[inline]
803    pub fn ordinal(&self) -> u64 {
804        match *self {
805            Self::Use_(_) => 1,
806            Self::Offer(_) => 2,
807            Self::Expose(_) => 3,
808            Self::Config(_) => 4,
809            Self::Dictionary(_) => 5,
810            Self::Directory(_) => 6,
811            Self::Environment(_) => 7,
812            Self::EventStream(_) => 8,
813            Self::Protocol(_) => 9,
814            Self::Resolver(_) => 10,
815            Self::Runner(_) => 11,
816            Self::Service(_) => 12,
817            Self::Storage(_) => 13,
818        }
819    }
820}
821
822impl fidl::Persistable for ComponentCapability {}
823
824#[derive(Clone, Debug, PartialEq)]
825pub enum EnvironmentCapability {
826    Runner(EnvironmentSource),
827    Resolver(EnvironmentSource),
828    Debug(EnvironmentSource),
829}
830
831impl EnvironmentCapability {
832    #[inline]
833    pub fn ordinal(&self) -> u64 {
834        match *self {
835            Self::Runner(_) => 1,
836            Self::Resolver(_) => 2,
837            Self::Debug(_) => 3,
838        }
839    }
840}
841
842impl fidl::Persistable for EnvironmentCapability {}
843
844#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
845pub enum InternalCapability {
846    Config(String),
847    Dictionary(String),
848    Directory(String),
849    EventStream(String),
850    Protocol(String),
851    Resolver(String),
852    Runner(String),
853    Service(String),
854    Storage(String),
855}
856
857impl InternalCapability {
858    #[inline]
859    pub fn ordinal(&self) -> u64 {
860        match *self {
861            Self::Config(_) => 1,
862            Self::Dictionary(_) => 2,
863            Self::Directory(_) => 3,
864            Self::EventStream(_) => 4,
865            Self::Protocol(_) => 5,
866            Self::Resolver(_) => 6,
867            Self::Runner(_) => 7,
868            Self::Service(_) => 8,
869            Self::Storage(_) => 9,
870        }
871    }
872}
873
874impl fidl::Persistable for InternalCapability {}
875
876pub mod component_sandbox_retriever_ordinals {
877    pub const GET_MY_SANDBOX: u64 = 0x61ca075fb9860e84;
878}
879
880mod internal {
881    use super::*;
882    unsafe impl fidl::encoding::TypeMarker for BuiltinBootResolver {
883        type Owned = Self;
884
885        #[inline(always)]
886        fn inline_align(_context: fidl::encoding::Context) -> usize {
887            std::mem::align_of::<u8>()
888        }
889
890        #[inline(always)]
891        fn inline_size(_context: fidl::encoding::Context) -> usize {
892            std::mem::size_of::<u8>()
893        }
894
895        #[inline(always)]
896        fn encode_is_copy() -> bool {
897            true
898        }
899
900        #[inline(always)]
901        fn decode_is_copy() -> bool {
902            false
903        }
904    }
905
906    impl fidl::encoding::ValueTypeMarker for BuiltinBootResolver {
907        type Borrowed<'a> = Self;
908        #[inline(always)]
909        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
910            *value
911        }
912    }
913
914    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
915        for BuiltinBootResolver
916    {
917        #[inline]
918        unsafe fn encode(
919            self,
920            encoder: &mut fidl::encoding::Encoder<'_, D>,
921            offset: usize,
922            _depth: fidl::encoding::Depth,
923        ) -> fidl::Result<()> {
924            encoder.debug_check_bounds::<Self>(offset);
925            encoder.write_num(self.into_primitive(), offset);
926            Ok(())
927        }
928    }
929
930    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BuiltinBootResolver {
931        #[inline(always)]
932        fn new_empty() -> Self {
933            Self::None
934        }
935
936        #[inline]
937        unsafe fn decode(
938            &mut self,
939            decoder: &mut fidl::encoding::Decoder<'_, D>,
940            offset: usize,
941            _depth: fidl::encoding::Depth,
942        ) -> fidl::Result<()> {
943            decoder.debug_check_bounds::<Self>(offset);
944            let prim = decoder.read_num::<u8>(offset);
945
946            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
947            Ok(())
948        }
949    }
950    unsafe impl fidl::encoding::TypeMarker for LogDestination {
951        type Owned = Self;
952
953        #[inline(always)]
954        fn inline_align(_context: fidl::encoding::Context) -> usize {
955            std::mem::align_of::<u8>()
956        }
957
958        #[inline(always)]
959        fn inline_size(_context: fidl::encoding::Context) -> usize {
960            std::mem::size_of::<u8>()
961        }
962
963        #[inline(always)]
964        fn encode_is_copy() -> bool {
965            true
966        }
967
968        #[inline(always)]
969        fn decode_is_copy() -> bool {
970            false
971        }
972    }
973
974    impl fidl::encoding::ValueTypeMarker for LogDestination {
975        type Borrowed<'a> = Self;
976        #[inline(always)]
977        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
978            *value
979        }
980    }
981
982    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for LogDestination {
983        #[inline]
984        unsafe fn encode(
985            self,
986            encoder: &mut fidl::encoding::Encoder<'_, D>,
987            offset: usize,
988            _depth: fidl::encoding::Depth,
989        ) -> fidl::Result<()> {
990            encoder.debug_check_bounds::<Self>(offset);
991            encoder.write_num(self.into_primitive(), offset);
992            Ok(())
993        }
994    }
995
996    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LogDestination {
997        #[inline(always)]
998        fn new_empty() -> Self {
999            Self::Syslog
1000        }
1001
1002        #[inline]
1003        unsafe fn decode(
1004            &mut self,
1005            decoder: &mut fidl::encoding::Decoder<'_, D>,
1006            offset: usize,
1007            _depth: fidl::encoding::Depth,
1008        ) -> fidl::Result<()> {
1009            decoder.debug_check_bounds::<Self>(offset);
1010            let prim = decoder.read_num::<u8>(offset);
1011
1012            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1013            Ok(())
1014        }
1015    }
1016    unsafe impl fidl::encoding::TypeMarker for RealmBuilderResolverAndRunner {
1017        type Owned = Self;
1018
1019        #[inline(always)]
1020        fn inline_align(_context: fidl::encoding::Context) -> usize {
1021            std::mem::align_of::<u8>()
1022        }
1023
1024        #[inline(always)]
1025        fn inline_size(_context: fidl::encoding::Context) -> usize {
1026            std::mem::size_of::<u8>()
1027        }
1028
1029        #[inline(always)]
1030        fn encode_is_copy() -> bool {
1031            true
1032        }
1033
1034        #[inline(always)]
1035        fn decode_is_copy() -> bool {
1036            false
1037        }
1038    }
1039
1040    impl fidl::encoding::ValueTypeMarker for RealmBuilderResolverAndRunner {
1041        type Borrowed<'a> = Self;
1042        #[inline(always)]
1043        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1044            *value
1045        }
1046    }
1047
1048    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1049        for RealmBuilderResolverAndRunner
1050    {
1051        #[inline]
1052        unsafe fn encode(
1053            self,
1054            encoder: &mut fidl::encoding::Encoder<'_, D>,
1055            offset: usize,
1056            _depth: fidl::encoding::Depth,
1057        ) -> fidl::Result<()> {
1058            encoder.debug_check_bounds::<Self>(offset);
1059            encoder.write_num(self.into_primitive(), offset);
1060            Ok(())
1061        }
1062    }
1063
1064    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1065        for RealmBuilderResolverAndRunner
1066    {
1067        #[inline(always)]
1068        fn new_empty() -> Self {
1069            Self::None
1070        }
1071
1072        #[inline]
1073        unsafe fn decode(
1074            &mut self,
1075            decoder: &mut fidl::encoding::Decoder<'_, D>,
1076            offset: usize,
1077            _depth: fidl::encoding::Depth,
1078        ) -> fidl::Result<()> {
1079            decoder.debug_check_bounds::<Self>(offset);
1080            let prim = decoder.read_num::<u8>(offset);
1081
1082            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1083            Ok(())
1084        }
1085    }
1086    unsafe impl fidl::encoding::TypeMarker for TraceProvider {
1087        type Owned = Self;
1088
1089        #[inline(always)]
1090        fn inline_align(_context: fidl::encoding::Context) -> usize {
1091            std::mem::align_of::<u8>()
1092        }
1093
1094        #[inline(always)]
1095        fn inline_size(_context: fidl::encoding::Context) -> usize {
1096            std::mem::size_of::<u8>()
1097        }
1098
1099        #[inline(always)]
1100        fn encode_is_copy() -> bool {
1101            true
1102        }
1103
1104        #[inline(always)]
1105        fn decode_is_copy() -> bool {
1106            false
1107        }
1108    }
1109
1110    impl fidl::encoding::ValueTypeMarker for TraceProvider {
1111        type Borrowed<'a> = Self;
1112        #[inline(always)]
1113        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1114            *value
1115        }
1116    }
1117
1118    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for TraceProvider {
1119        #[inline]
1120        unsafe fn encode(
1121            self,
1122            encoder: &mut fidl::encoding::Encoder<'_, D>,
1123            offset: usize,
1124            _depth: fidl::encoding::Depth,
1125        ) -> fidl::Result<()> {
1126            encoder.debug_check_bounds::<Self>(offset);
1127            encoder.write_num(self.into_primitive(), offset);
1128            Ok(())
1129        }
1130    }
1131
1132    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TraceProvider {
1133        #[inline(always)]
1134        fn new_empty() -> Self {
1135            Self::Namespace
1136        }
1137
1138        #[inline]
1139        unsafe fn decode(
1140            &mut self,
1141            decoder: &mut fidl::encoding::Decoder<'_, D>,
1142            offset: usize,
1143            _depth: fidl::encoding::Depth,
1144        ) -> fidl::Result<()> {
1145            decoder.debug_check_bounds::<Self>(offset);
1146            let prim = decoder.read_num::<u8>(offset);
1147
1148            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1149            Ok(())
1150        }
1151    }
1152    unsafe impl fidl::encoding::TypeMarker for VmexSource {
1153        type Owned = Self;
1154
1155        #[inline(always)]
1156        fn inline_align(_context: fidl::encoding::Context) -> usize {
1157            std::mem::align_of::<u8>()
1158        }
1159
1160        #[inline(always)]
1161        fn inline_size(_context: fidl::encoding::Context) -> usize {
1162            std::mem::size_of::<u8>()
1163        }
1164
1165        #[inline(always)]
1166        fn encode_is_copy() -> bool {
1167            true
1168        }
1169
1170        #[inline(always)]
1171        fn decode_is_copy() -> bool {
1172            false
1173        }
1174    }
1175
1176    impl fidl::encoding::ValueTypeMarker for VmexSource {
1177        type Borrowed<'a> = Self;
1178        #[inline(always)]
1179        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1180            *value
1181        }
1182    }
1183
1184    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for VmexSource {
1185        #[inline]
1186        unsafe fn encode(
1187            self,
1188            encoder: &mut fidl::encoding::Encoder<'_, D>,
1189            offset: usize,
1190            _depth: fidl::encoding::Depth,
1191        ) -> fidl::Result<()> {
1192            encoder.debug_check_bounds::<Self>(offset);
1193            encoder.write_num(self.into_primitive(), offset);
1194            Ok(())
1195        }
1196    }
1197
1198    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VmexSource {
1199        #[inline(always)]
1200        fn new_empty() -> Self {
1201            Self::SystemResource
1202        }
1203
1204        #[inline]
1205        unsafe fn decode(
1206            &mut self,
1207            decoder: &mut fidl::encoding::Decoder<'_, D>,
1208            offset: usize,
1209            _depth: fidl::encoding::Depth,
1210        ) -> fidl::Result<()> {
1211            decoder.debug_check_bounds::<Self>(offset);
1212            let prim = decoder.read_num::<u8>(offset);
1213
1214            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1215            Ok(())
1216        }
1217    }
1218
1219    impl AbiRevisionPolicy {
1220        #[inline(always)]
1221        fn max_ordinal_present(&self) -> u64 {
1222            if let Some(_) = self.allowlist {
1223                return 1;
1224            }
1225            0
1226        }
1227    }
1228
1229    impl fidl::encoding::ValueTypeMarker for AbiRevisionPolicy {
1230        type Borrowed<'a> = &'a Self;
1231        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1232            value
1233        }
1234    }
1235
1236    unsafe impl fidl::encoding::TypeMarker for AbiRevisionPolicy {
1237        type Owned = Self;
1238
1239        #[inline(always)]
1240        fn inline_align(_context: fidl::encoding::Context) -> usize {
1241            8
1242        }
1243
1244        #[inline(always)]
1245        fn inline_size(_context: fidl::encoding::Context) -> usize {
1246            16
1247        }
1248    }
1249
1250    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AbiRevisionPolicy, D>
1251        for &AbiRevisionPolicy
1252    {
1253        unsafe fn encode(
1254            self,
1255            encoder: &mut fidl::encoding::Encoder<'_, D>,
1256            offset: usize,
1257            mut depth: fidl::encoding::Depth,
1258        ) -> fidl::Result<()> {
1259            encoder.debug_check_bounds::<AbiRevisionPolicy>(offset);
1260            // Vector header
1261            let max_ordinal: u64 = self.max_ordinal_present();
1262            encoder.write_num(max_ordinal, offset);
1263            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1264            // Calling encoder.out_of_line_offset(0) is not allowed.
1265            if max_ordinal == 0 {
1266                return Ok(());
1267            }
1268            depth.increment()?;
1269            let envelope_size = 8;
1270            let bytes_len = max_ordinal as usize * envelope_size;
1271            #[allow(unused_variables)]
1272            let offset = encoder.out_of_line_offset(bytes_len);
1273            let mut _prev_end_offset: usize = 0;
1274            if 1 > max_ordinal {
1275                return Ok(());
1276            }
1277
1278            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1279            // are envelope_size bytes.
1280            let cur_offset: usize = (1 - 1) * envelope_size;
1281
1282            // Zero reserved fields.
1283            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1284
1285            // Safety:
1286            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1287            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1288            //   envelope_size bytes, there is always sufficient room.
1289            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
1290            self.allowlist.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
1291            encoder, offset + cur_offset, depth
1292        )?;
1293
1294            _prev_end_offset = cur_offset + envelope_size;
1295
1296            Ok(())
1297        }
1298    }
1299
1300    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AbiRevisionPolicy {
1301        #[inline(always)]
1302        fn new_empty() -> Self {
1303            Self::default()
1304        }
1305
1306        unsafe fn decode(
1307            &mut self,
1308            decoder: &mut fidl::encoding::Decoder<'_, D>,
1309            offset: usize,
1310            mut depth: fidl::encoding::Depth,
1311        ) -> fidl::Result<()> {
1312            decoder.debug_check_bounds::<Self>(offset);
1313            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1314                None => return Err(fidl::Error::NotNullable),
1315                Some(len) => len,
1316            };
1317            // Calling decoder.out_of_line_offset(0) is not allowed.
1318            if len == 0 {
1319                return Ok(());
1320            };
1321            depth.increment()?;
1322            let envelope_size = 8;
1323            let bytes_len = len * envelope_size;
1324            let offset = decoder.out_of_line_offset(bytes_len)?;
1325            // Decode the envelope for each type.
1326            let mut _next_ordinal_to_read = 0;
1327            let mut next_offset = offset;
1328            let end_offset = offset + bytes_len;
1329            _next_ordinal_to_read += 1;
1330            if next_offset >= end_offset {
1331                return Ok(());
1332            }
1333
1334            // Decode unknown envelopes for gaps in ordinals.
1335            while _next_ordinal_to_read < 1 {
1336                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1337                _next_ordinal_to_read += 1;
1338                next_offset += envelope_size;
1339            }
1340
1341            let next_out_of_line = decoder.next_out_of_line();
1342            let handles_before = decoder.remaining_handles();
1343            if let Some((inlined, num_bytes, num_handles)) =
1344                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1345            {
1346                let member_inline_size = <fidl::encoding::Vector<
1347                    fidl::encoding::BoundedString<4096>,
1348                    128,
1349                > as fidl::encoding::TypeMarker>::inline_size(
1350                    decoder.context
1351                );
1352                if inlined != (member_inline_size <= 4) {
1353                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1354                }
1355                let inner_offset;
1356                let mut inner_depth = depth.clone();
1357                if inlined {
1358                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1359                    inner_offset = next_offset;
1360                } else {
1361                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1362                    inner_depth.increment()?;
1363                }
1364                let val_ref = self.allowlist.get_or_insert_with(|| {
1365                    fidl::new_empty!(
1366                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
1367                        D
1368                    )
1369                });
1370                fidl::decode!(
1371                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
1372                    D,
1373                    val_ref,
1374                    decoder,
1375                    inner_offset,
1376                    inner_depth
1377                )?;
1378                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1379                {
1380                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1381                }
1382                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1383                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1384                }
1385            }
1386
1387            next_offset += envelope_size;
1388
1389            // Decode the remaining unknown envelopes.
1390            while next_offset < end_offset {
1391                _next_ordinal_to_read += 1;
1392                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1393                next_offset += envelope_size;
1394            }
1395
1396            Ok(())
1397        }
1398    }
1399
1400    impl AllowlistedDirectory {
1401        #[inline(always)]
1402        fn max_ordinal_present(&self) -> u64 {
1403            0
1404        }
1405    }
1406
1407    impl fidl::encoding::ValueTypeMarker for AllowlistedDirectory {
1408        type Borrowed<'a> = &'a Self;
1409        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1410            value
1411        }
1412    }
1413
1414    unsafe impl fidl::encoding::TypeMarker for AllowlistedDirectory {
1415        type Owned = Self;
1416
1417        #[inline(always)]
1418        fn inline_align(_context: fidl::encoding::Context) -> usize {
1419            8
1420        }
1421
1422        #[inline(always)]
1423        fn inline_size(_context: fidl::encoding::Context) -> usize {
1424            16
1425        }
1426    }
1427
1428    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedDirectory, D>
1429        for &AllowlistedDirectory
1430    {
1431        unsafe fn encode(
1432            self,
1433            encoder: &mut fidl::encoding::Encoder<'_, D>,
1434            offset: usize,
1435            mut depth: fidl::encoding::Depth,
1436        ) -> fidl::Result<()> {
1437            encoder.debug_check_bounds::<AllowlistedDirectory>(offset);
1438            // Vector header
1439            let max_ordinal: u64 = self.max_ordinal_present();
1440            encoder.write_num(max_ordinal, offset);
1441            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1442            // Calling encoder.out_of_line_offset(0) is not allowed.
1443            if max_ordinal == 0 {
1444                return Ok(());
1445            }
1446            depth.increment()?;
1447            let envelope_size = 8;
1448            let bytes_len = max_ordinal as usize * envelope_size;
1449            #[allow(unused_variables)]
1450            let offset = encoder.out_of_line_offset(bytes_len);
1451            let mut _prev_end_offset: usize = 0;
1452
1453            Ok(())
1454        }
1455    }
1456
1457    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedDirectory {
1458        #[inline(always)]
1459        fn new_empty() -> Self {
1460            Self::default()
1461        }
1462
1463        unsafe fn decode(
1464            &mut self,
1465            decoder: &mut fidl::encoding::Decoder<'_, D>,
1466            offset: usize,
1467            mut depth: fidl::encoding::Depth,
1468        ) -> fidl::Result<()> {
1469            decoder.debug_check_bounds::<Self>(offset);
1470            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1471                None => return Err(fidl::Error::NotNullable),
1472                Some(len) => len,
1473            };
1474            // Calling decoder.out_of_line_offset(0) is not allowed.
1475            if len == 0 {
1476                return Ok(());
1477            };
1478            depth.increment()?;
1479            let envelope_size = 8;
1480            let bytes_len = len * envelope_size;
1481            let offset = decoder.out_of_line_offset(bytes_len)?;
1482            // Decode the envelope for each type.
1483            let mut _next_ordinal_to_read = 0;
1484            let mut next_offset = offset;
1485            let end_offset = offset + bytes_len;
1486
1487            // Decode the remaining unknown envelopes.
1488            while next_offset < end_offset {
1489                _next_ordinal_to_read += 1;
1490                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1491                next_offset += envelope_size;
1492            }
1493
1494            Ok(())
1495        }
1496    }
1497
1498    impl AllowlistedProtocol {
1499        #[inline(always)]
1500        fn max_ordinal_present(&self) -> u64 {
1501            0
1502        }
1503    }
1504
1505    impl fidl::encoding::ValueTypeMarker for AllowlistedProtocol {
1506        type Borrowed<'a> = &'a Self;
1507        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1508            value
1509        }
1510    }
1511
1512    unsafe impl fidl::encoding::TypeMarker for AllowlistedProtocol {
1513        type Owned = Self;
1514
1515        #[inline(always)]
1516        fn inline_align(_context: fidl::encoding::Context) -> usize {
1517            8
1518        }
1519
1520        #[inline(always)]
1521        fn inline_size(_context: fidl::encoding::Context) -> usize {
1522            16
1523        }
1524    }
1525
1526    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedProtocol, D>
1527        for &AllowlistedProtocol
1528    {
1529        unsafe fn encode(
1530            self,
1531            encoder: &mut fidl::encoding::Encoder<'_, D>,
1532            offset: usize,
1533            mut depth: fidl::encoding::Depth,
1534        ) -> fidl::Result<()> {
1535            encoder.debug_check_bounds::<AllowlistedProtocol>(offset);
1536            // Vector header
1537            let max_ordinal: u64 = self.max_ordinal_present();
1538            encoder.write_num(max_ordinal, offset);
1539            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1540            // Calling encoder.out_of_line_offset(0) is not allowed.
1541            if max_ordinal == 0 {
1542                return Ok(());
1543            }
1544            depth.increment()?;
1545            let envelope_size = 8;
1546            let bytes_len = max_ordinal as usize * envelope_size;
1547            #[allow(unused_variables)]
1548            let offset = encoder.out_of_line_offset(bytes_len);
1549            let mut _prev_end_offset: usize = 0;
1550
1551            Ok(())
1552        }
1553    }
1554
1555    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedProtocol {
1556        #[inline(always)]
1557        fn new_empty() -> Self {
1558            Self::default()
1559        }
1560
1561        unsafe fn decode(
1562            &mut self,
1563            decoder: &mut fidl::encoding::Decoder<'_, D>,
1564            offset: usize,
1565            mut depth: fidl::encoding::Depth,
1566        ) -> fidl::Result<()> {
1567            decoder.debug_check_bounds::<Self>(offset);
1568            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1569                None => return Err(fidl::Error::NotNullable),
1570                Some(len) => len,
1571            };
1572            // Calling decoder.out_of_line_offset(0) is not allowed.
1573            if len == 0 {
1574                return Ok(());
1575            };
1576            depth.increment()?;
1577            let envelope_size = 8;
1578            let bytes_len = len * envelope_size;
1579            let offset = decoder.out_of_line_offset(bytes_len)?;
1580            // Decode the envelope for each type.
1581            let mut _next_ordinal_to_read = 0;
1582            let mut next_offset = offset;
1583            let end_offset = offset + bytes_len;
1584
1585            // Decode the remaining unknown envelopes.
1586            while next_offset < end_offset {
1587                _next_ordinal_to_read += 1;
1588                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1589                next_offset += envelope_size;
1590            }
1591
1592            Ok(())
1593        }
1594    }
1595
1596    impl AllowlistedResolver {
1597        #[inline(always)]
1598        fn max_ordinal_present(&self) -> u64 {
1599            0
1600        }
1601    }
1602
1603    impl fidl::encoding::ValueTypeMarker for AllowlistedResolver {
1604        type Borrowed<'a> = &'a Self;
1605        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1606            value
1607        }
1608    }
1609
1610    unsafe impl fidl::encoding::TypeMarker for AllowlistedResolver {
1611        type Owned = Self;
1612
1613        #[inline(always)]
1614        fn inline_align(_context: fidl::encoding::Context) -> usize {
1615            8
1616        }
1617
1618        #[inline(always)]
1619        fn inline_size(_context: fidl::encoding::Context) -> usize {
1620            16
1621        }
1622    }
1623
1624    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedResolver, D>
1625        for &AllowlistedResolver
1626    {
1627        unsafe fn encode(
1628            self,
1629            encoder: &mut fidl::encoding::Encoder<'_, D>,
1630            offset: usize,
1631            mut depth: fidl::encoding::Depth,
1632        ) -> fidl::Result<()> {
1633            encoder.debug_check_bounds::<AllowlistedResolver>(offset);
1634            // Vector header
1635            let max_ordinal: u64 = self.max_ordinal_present();
1636            encoder.write_num(max_ordinal, offset);
1637            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1638            // Calling encoder.out_of_line_offset(0) is not allowed.
1639            if max_ordinal == 0 {
1640                return Ok(());
1641            }
1642            depth.increment()?;
1643            let envelope_size = 8;
1644            let bytes_len = max_ordinal as usize * envelope_size;
1645            #[allow(unused_variables)]
1646            let offset = encoder.out_of_line_offset(bytes_len);
1647            let mut _prev_end_offset: usize = 0;
1648
1649            Ok(())
1650        }
1651    }
1652
1653    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedResolver {
1654        #[inline(always)]
1655        fn new_empty() -> Self {
1656            Self::default()
1657        }
1658
1659        unsafe fn decode(
1660            &mut self,
1661            decoder: &mut fidl::encoding::Decoder<'_, D>,
1662            offset: usize,
1663            mut depth: fidl::encoding::Depth,
1664        ) -> fidl::Result<()> {
1665            decoder.debug_check_bounds::<Self>(offset);
1666            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1667                None => return Err(fidl::Error::NotNullable),
1668                Some(len) => len,
1669            };
1670            // Calling decoder.out_of_line_offset(0) is not allowed.
1671            if len == 0 {
1672                return Ok(());
1673            };
1674            depth.increment()?;
1675            let envelope_size = 8;
1676            let bytes_len = len * envelope_size;
1677            let offset = decoder.out_of_line_offset(bytes_len)?;
1678            // Decode the envelope for each type.
1679            let mut _next_ordinal_to_read = 0;
1680            let mut next_offset = offset;
1681            let end_offset = offset + bytes_len;
1682
1683            // Decode the remaining unknown envelopes.
1684            while next_offset < end_offset {
1685                _next_ordinal_to_read += 1;
1686                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1687                next_offset += envelope_size;
1688            }
1689
1690            Ok(())
1691        }
1692    }
1693
1694    impl AllowlistedRunner {
1695        #[inline(always)]
1696        fn max_ordinal_present(&self) -> u64 {
1697            0
1698        }
1699    }
1700
1701    impl fidl::encoding::ValueTypeMarker for AllowlistedRunner {
1702        type Borrowed<'a> = &'a Self;
1703        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1704            value
1705        }
1706    }
1707
1708    unsafe impl fidl::encoding::TypeMarker for AllowlistedRunner {
1709        type Owned = Self;
1710
1711        #[inline(always)]
1712        fn inline_align(_context: fidl::encoding::Context) -> usize {
1713            8
1714        }
1715
1716        #[inline(always)]
1717        fn inline_size(_context: fidl::encoding::Context) -> usize {
1718            16
1719        }
1720    }
1721
1722    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedRunner, D>
1723        for &AllowlistedRunner
1724    {
1725        unsafe fn encode(
1726            self,
1727            encoder: &mut fidl::encoding::Encoder<'_, D>,
1728            offset: usize,
1729            mut depth: fidl::encoding::Depth,
1730        ) -> fidl::Result<()> {
1731            encoder.debug_check_bounds::<AllowlistedRunner>(offset);
1732            // Vector header
1733            let max_ordinal: u64 = self.max_ordinal_present();
1734            encoder.write_num(max_ordinal, offset);
1735            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1736            // Calling encoder.out_of_line_offset(0) is not allowed.
1737            if max_ordinal == 0 {
1738                return Ok(());
1739            }
1740            depth.increment()?;
1741            let envelope_size = 8;
1742            let bytes_len = max_ordinal as usize * envelope_size;
1743            #[allow(unused_variables)]
1744            let offset = encoder.out_of_line_offset(bytes_len);
1745            let mut _prev_end_offset: usize = 0;
1746
1747            Ok(())
1748        }
1749    }
1750
1751    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedRunner {
1752        #[inline(always)]
1753        fn new_empty() -> Self {
1754            Self::default()
1755        }
1756
1757        unsafe fn decode(
1758            &mut self,
1759            decoder: &mut fidl::encoding::Decoder<'_, D>,
1760            offset: usize,
1761            mut depth: fidl::encoding::Depth,
1762        ) -> fidl::Result<()> {
1763            decoder.debug_check_bounds::<Self>(offset);
1764            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1765                None => return Err(fidl::Error::NotNullable),
1766                Some(len) => len,
1767            };
1768            // Calling decoder.out_of_line_offset(0) is not allowed.
1769            if len == 0 {
1770                return Ok(());
1771            };
1772            depth.increment()?;
1773            let envelope_size = 8;
1774            let bytes_len = len * envelope_size;
1775            let offset = decoder.out_of_line_offset(bytes_len)?;
1776            // Decode the envelope for each type.
1777            let mut _next_ordinal_to_read = 0;
1778            let mut next_offset = offset;
1779            let end_offset = offset + bytes_len;
1780
1781            // Decode the remaining unknown envelopes.
1782            while next_offset < end_offset {
1783                _next_ordinal_to_read += 1;
1784                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1785                next_offset += envelope_size;
1786            }
1787
1788            Ok(())
1789        }
1790    }
1791
1792    impl AllowlistedService {
1793        #[inline(always)]
1794        fn max_ordinal_present(&self) -> u64 {
1795            0
1796        }
1797    }
1798
1799    impl fidl::encoding::ValueTypeMarker for AllowlistedService {
1800        type Borrowed<'a> = &'a Self;
1801        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1802            value
1803        }
1804    }
1805
1806    unsafe impl fidl::encoding::TypeMarker for AllowlistedService {
1807        type Owned = Self;
1808
1809        #[inline(always)]
1810        fn inline_align(_context: fidl::encoding::Context) -> usize {
1811            8
1812        }
1813
1814        #[inline(always)]
1815        fn inline_size(_context: fidl::encoding::Context) -> usize {
1816            16
1817        }
1818    }
1819
1820    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedService, D>
1821        for &AllowlistedService
1822    {
1823        unsafe fn encode(
1824            self,
1825            encoder: &mut fidl::encoding::Encoder<'_, D>,
1826            offset: usize,
1827            mut depth: fidl::encoding::Depth,
1828        ) -> fidl::Result<()> {
1829            encoder.debug_check_bounds::<AllowlistedService>(offset);
1830            // Vector header
1831            let max_ordinal: u64 = self.max_ordinal_present();
1832            encoder.write_num(max_ordinal, offset);
1833            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1834            // Calling encoder.out_of_line_offset(0) is not allowed.
1835            if max_ordinal == 0 {
1836                return Ok(());
1837            }
1838            depth.increment()?;
1839            let envelope_size = 8;
1840            let bytes_len = max_ordinal as usize * envelope_size;
1841            #[allow(unused_variables)]
1842            let offset = encoder.out_of_line_offset(bytes_len);
1843            let mut _prev_end_offset: usize = 0;
1844
1845            Ok(())
1846        }
1847    }
1848
1849    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedService {
1850        #[inline(always)]
1851        fn new_empty() -> Self {
1852            Self::default()
1853        }
1854
1855        unsafe fn decode(
1856            &mut self,
1857            decoder: &mut fidl::encoding::Decoder<'_, D>,
1858            offset: usize,
1859            mut depth: fidl::encoding::Depth,
1860        ) -> fidl::Result<()> {
1861            decoder.debug_check_bounds::<Self>(offset);
1862            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1863                None => return Err(fidl::Error::NotNullable),
1864                Some(len) => len,
1865            };
1866            // Calling decoder.out_of_line_offset(0) is not allowed.
1867            if len == 0 {
1868                return Ok(());
1869            };
1870            depth.increment()?;
1871            let envelope_size = 8;
1872            let bytes_len = len * envelope_size;
1873            let offset = decoder.out_of_line_offset(bytes_len)?;
1874            // Decode the envelope for each type.
1875            let mut _next_ordinal_to_read = 0;
1876            let mut next_offset = offset;
1877            let end_offset = offset + bytes_len;
1878
1879            // Decode the remaining unknown envelopes.
1880            while next_offset < end_offset {
1881                _next_ordinal_to_read += 1;
1882                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1883                next_offset += envelope_size;
1884            }
1885
1886            Ok(())
1887        }
1888    }
1889
1890    impl AllowlistedStorage {
1891        #[inline(always)]
1892        fn max_ordinal_present(&self) -> u64 {
1893            0
1894        }
1895    }
1896
1897    impl fidl::encoding::ValueTypeMarker for AllowlistedStorage {
1898        type Borrowed<'a> = &'a Self;
1899        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1900            value
1901        }
1902    }
1903
1904    unsafe impl fidl::encoding::TypeMarker for AllowlistedStorage {
1905        type Owned = Self;
1906
1907        #[inline(always)]
1908        fn inline_align(_context: fidl::encoding::Context) -> usize {
1909            8
1910        }
1911
1912        #[inline(always)]
1913        fn inline_size(_context: fidl::encoding::Context) -> usize {
1914            16
1915        }
1916    }
1917
1918    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedStorage, D>
1919        for &AllowlistedStorage
1920    {
1921        unsafe fn encode(
1922            self,
1923            encoder: &mut fidl::encoding::Encoder<'_, D>,
1924            offset: usize,
1925            mut depth: fidl::encoding::Depth,
1926        ) -> fidl::Result<()> {
1927            encoder.debug_check_bounds::<AllowlistedStorage>(offset);
1928            // Vector header
1929            let max_ordinal: u64 = self.max_ordinal_present();
1930            encoder.write_num(max_ordinal, offset);
1931            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1932            // Calling encoder.out_of_line_offset(0) is not allowed.
1933            if max_ordinal == 0 {
1934                return Ok(());
1935            }
1936            depth.increment()?;
1937            let envelope_size = 8;
1938            let bytes_len = max_ordinal as usize * envelope_size;
1939            #[allow(unused_variables)]
1940            let offset = encoder.out_of_line_offset(bytes_len);
1941            let mut _prev_end_offset: usize = 0;
1942
1943            Ok(())
1944        }
1945    }
1946
1947    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedStorage {
1948        #[inline(always)]
1949        fn new_empty() -> Self {
1950            Self::default()
1951        }
1952
1953        unsafe fn decode(
1954            &mut self,
1955            decoder: &mut fidl::encoding::Decoder<'_, D>,
1956            offset: usize,
1957            mut depth: fidl::encoding::Depth,
1958        ) -> fidl::Result<()> {
1959            decoder.debug_check_bounds::<Self>(offset);
1960            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1961                None => return Err(fidl::Error::NotNullable),
1962                Some(len) => len,
1963            };
1964            // Calling decoder.out_of_line_offset(0) is not allowed.
1965            if len == 0 {
1966                return Ok(());
1967            };
1968            depth.increment()?;
1969            let envelope_size = 8;
1970            let bytes_len = len * envelope_size;
1971            let offset = decoder.out_of_line_offset(bytes_len)?;
1972            // Decode the envelope for each type.
1973            let mut _next_ordinal_to_read = 0;
1974            let mut next_offset = offset;
1975            let end_offset = offset + bytes_len;
1976
1977            // Decode the remaining unknown envelopes.
1978            while next_offset < end_offset {
1979                _next_ordinal_to_read += 1;
1980                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1981                next_offset += envelope_size;
1982            }
1983
1984            Ok(())
1985        }
1986    }
1987
1988    impl AnonymizedAggregate {
1989        #[inline(always)]
1990        fn max_ordinal_present(&self) -> u64 {
1991            if let Some(_) = self.instances {
1992                return 5;
1993            }
1994            if let Some(_) = self.sources {
1995                return 4;
1996            }
1997            if let Some(_) = self.members {
1998                return 3;
1999            }
2000            if let Some(_) = self.moniker {
2001                return 2;
2002            }
2003            if let Some(_) = self.capability {
2004                return 1;
2005            }
2006            0
2007        }
2008    }
2009
2010    impl fidl::encoding::ValueTypeMarker for AnonymizedAggregate {
2011        type Borrowed<'a> = &'a Self;
2012        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2013            value
2014        }
2015    }
2016
2017    unsafe impl fidl::encoding::TypeMarker for AnonymizedAggregate {
2018        type Owned = Self;
2019
2020        #[inline(always)]
2021        fn inline_align(_context: fidl::encoding::Context) -> usize {
2022            8
2023        }
2024
2025        #[inline(always)]
2026        fn inline_size(_context: fidl::encoding::Context) -> usize {
2027            16
2028        }
2029    }
2030
2031    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AnonymizedAggregate, D>
2032        for &AnonymizedAggregate
2033    {
2034        unsafe fn encode(
2035            self,
2036            encoder: &mut fidl::encoding::Encoder<'_, D>,
2037            offset: usize,
2038            mut depth: fidl::encoding::Depth,
2039        ) -> fidl::Result<()> {
2040            encoder.debug_check_bounds::<AnonymizedAggregate>(offset);
2041            // Vector header
2042            let max_ordinal: u64 = self.max_ordinal_present();
2043            encoder.write_num(max_ordinal, offset);
2044            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2045            // Calling encoder.out_of_line_offset(0) is not allowed.
2046            if max_ordinal == 0 {
2047                return Ok(());
2048            }
2049            depth.increment()?;
2050            let envelope_size = 8;
2051            let bytes_len = max_ordinal as usize * envelope_size;
2052            #[allow(unused_variables)]
2053            let offset = encoder.out_of_line_offset(bytes_len);
2054            let mut _prev_end_offset: usize = 0;
2055            if 1 > max_ordinal {
2056                return Ok(());
2057            }
2058
2059            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2060            // are envelope_size bytes.
2061            let cur_offset: usize = (1 - 1) * envelope_size;
2062
2063            // Zero reserved fields.
2064            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2065
2066            // Safety:
2067            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2068            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2069            //   envelope_size bytes, there is always sufficient room.
2070            fidl::encoding::encode_in_envelope_optional::<AggregateCapability, D>(
2071                self.capability
2072                    .as_ref()
2073                    .map(<AggregateCapability as fidl::encoding::ValueTypeMarker>::borrow),
2074                encoder,
2075                offset + cur_offset,
2076                depth,
2077            )?;
2078
2079            _prev_end_offset = cur_offset + envelope_size;
2080            if 2 > max_ordinal {
2081                return Ok(());
2082            }
2083
2084            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2085            // are envelope_size bytes.
2086            let cur_offset: usize = (2 - 1) * envelope_size;
2087
2088            // Zero reserved fields.
2089            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2090
2091            // Safety:
2092            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2093            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2094            //   envelope_size bytes, there is always sufficient room.
2095            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
2096            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
2097            encoder, offset + cur_offset, depth
2098        )?;
2099
2100            _prev_end_offset = cur_offset + envelope_size;
2101            if 3 > max_ordinal {
2102                return Ok(());
2103            }
2104
2105            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2106            // are envelope_size bytes.
2107            let cur_offset: usize = (3 - 1) * envelope_size;
2108
2109            // Zero reserved fields.
2110            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2111
2112            // Safety:
2113            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2114            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2115            //   envelope_size bytes, there is always sufficient room.
2116            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<AggregateMember>, D>(
2117            self.members.as_ref().map(<fidl::encoding::UnboundedVector<AggregateMember> as fidl::encoding::ValueTypeMarker>::borrow),
2118            encoder, offset + cur_offset, depth
2119        )?;
2120
2121            _prev_end_offset = cur_offset + envelope_size;
2122            if 4 > max_ordinal {
2123                return Ok(());
2124            }
2125
2126            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2127            // are envelope_size bytes.
2128            let cur_offset: usize = (4 - 1) * envelope_size;
2129
2130            // Zero reserved fields.
2131            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2132
2133            // Safety:
2134            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2135            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2136            //   envelope_size bytes, there is always sufficient room.
2137            fidl::encoding::encode_in_envelope_optional::<Sources, D>(
2138                self.sources.as_ref().map(<Sources as fidl::encoding::ValueTypeMarker>::borrow),
2139                encoder,
2140                offset + cur_offset,
2141                depth,
2142            )?;
2143
2144            _prev_end_offset = cur_offset + envelope_size;
2145            if 5 > max_ordinal {
2146                return Ok(());
2147            }
2148
2149            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2150            // are envelope_size bytes.
2151            let cur_offset: usize = (5 - 1) * envelope_size;
2152
2153            // Zero reserved fields.
2154            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2155
2156            // Safety:
2157            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2158            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2159            //   envelope_size bytes, there is always sufficient room.
2160            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance>, D>(
2161            self.instances.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance> as fidl::encoding::ValueTypeMarker>::borrow),
2162            encoder, offset + cur_offset, depth
2163        )?;
2164
2165            _prev_end_offset = cur_offset + envelope_size;
2166
2167            Ok(())
2168        }
2169    }
2170
2171    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AnonymizedAggregate {
2172        #[inline(always)]
2173        fn new_empty() -> Self {
2174            Self::default()
2175        }
2176
2177        unsafe fn decode(
2178            &mut self,
2179            decoder: &mut fidl::encoding::Decoder<'_, D>,
2180            offset: usize,
2181            mut depth: fidl::encoding::Depth,
2182        ) -> fidl::Result<()> {
2183            decoder.debug_check_bounds::<Self>(offset);
2184            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2185                None => return Err(fidl::Error::NotNullable),
2186                Some(len) => len,
2187            };
2188            // Calling decoder.out_of_line_offset(0) is not allowed.
2189            if len == 0 {
2190                return Ok(());
2191            };
2192            depth.increment()?;
2193            let envelope_size = 8;
2194            let bytes_len = len * envelope_size;
2195            let offset = decoder.out_of_line_offset(bytes_len)?;
2196            // Decode the envelope for each type.
2197            let mut _next_ordinal_to_read = 0;
2198            let mut next_offset = offset;
2199            let end_offset = offset + bytes_len;
2200            _next_ordinal_to_read += 1;
2201            if next_offset >= end_offset {
2202                return Ok(());
2203            }
2204
2205            // Decode unknown envelopes for gaps in ordinals.
2206            while _next_ordinal_to_read < 1 {
2207                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2208                _next_ordinal_to_read += 1;
2209                next_offset += envelope_size;
2210            }
2211
2212            let next_out_of_line = decoder.next_out_of_line();
2213            let handles_before = decoder.remaining_handles();
2214            if let Some((inlined, num_bytes, num_handles)) =
2215                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2216            {
2217                let member_inline_size =
2218                    <AggregateCapability as fidl::encoding::TypeMarker>::inline_size(
2219                        decoder.context,
2220                    );
2221                if inlined != (member_inline_size <= 4) {
2222                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2223                }
2224                let inner_offset;
2225                let mut inner_depth = depth.clone();
2226                if inlined {
2227                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2228                    inner_offset = next_offset;
2229                } else {
2230                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2231                    inner_depth.increment()?;
2232                }
2233                let val_ref =
2234                    self.capability.get_or_insert_with(|| fidl::new_empty!(AggregateCapability, D));
2235                fidl::decode!(AggregateCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
2236                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2237                {
2238                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2239                }
2240                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2241                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2242                }
2243            }
2244
2245            next_offset += envelope_size;
2246            _next_ordinal_to_read += 1;
2247            if next_offset >= end_offset {
2248                return Ok(());
2249            }
2250
2251            // Decode unknown envelopes for gaps in ordinals.
2252            while _next_ordinal_to_read < 2 {
2253                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2254                _next_ordinal_to_read += 1;
2255                next_offset += envelope_size;
2256            }
2257
2258            let next_out_of_line = decoder.next_out_of_line();
2259            let handles_before = decoder.remaining_handles();
2260            if let Some((inlined, num_bytes, num_handles)) =
2261                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2262            {
2263                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2264                if inlined != (member_inline_size <= 4) {
2265                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2266                }
2267                let inner_offset;
2268                let mut inner_depth = depth.clone();
2269                if inlined {
2270                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2271                    inner_offset = next_offset;
2272                } else {
2273                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2274                    inner_depth.increment()?;
2275                }
2276                let val_ref = self.moniker.get_or_insert_with(|| {
2277                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
2278                });
2279                fidl::decode!(
2280                    fidl::encoding::BoundedString<4096>,
2281                    D,
2282                    val_ref,
2283                    decoder,
2284                    inner_offset,
2285                    inner_depth
2286                )?;
2287                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2288                {
2289                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2290                }
2291                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2292                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2293                }
2294            }
2295
2296            next_offset += envelope_size;
2297            _next_ordinal_to_read += 1;
2298            if next_offset >= end_offset {
2299                return Ok(());
2300            }
2301
2302            // Decode unknown envelopes for gaps in ordinals.
2303            while _next_ordinal_to_read < 3 {
2304                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2305                _next_ordinal_to_read += 1;
2306                next_offset += envelope_size;
2307            }
2308
2309            let next_out_of_line = decoder.next_out_of_line();
2310            let handles_before = decoder.remaining_handles();
2311            if let Some((inlined, num_bytes, num_handles)) =
2312                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2313            {
2314                let member_inline_size = <fidl::encoding::UnboundedVector<AggregateMember> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2315                if inlined != (member_inline_size <= 4) {
2316                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2317                }
2318                let inner_offset;
2319                let mut inner_depth = depth.clone();
2320                if inlined {
2321                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2322                    inner_offset = next_offset;
2323                } else {
2324                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2325                    inner_depth.increment()?;
2326                }
2327                let val_ref = self.members.get_or_insert_with(|| {
2328                    fidl::new_empty!(fidl::encoding::UnboundedVector<AggregateMember>, D)
2329                });
2330                fidl::decode!(
2331                    fidl::encoding::UnboundedVector<AggregateMember>,
2332                    D,
2333                    val_ref,
2334                    decoder,
2335                    inner_offset,
2336                    inner_depth
2337                )?;
2338                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2339                {
2340                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2341                }
2342                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2343                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2344                }
2345            }
2346
2347            next_offset += envelope_size;
2348            _next_ordinal_to_read += 1;
2349            if next_offset >= end_offset {
2350                return Ok(());
2351            }
2352
2353            // Decode unknown envelopes for gaps in ordinals.
2354            while _next_ordinal_to_read < 4 {
2355                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2356                _next_ordinal_to_read += 1;
2357                next_offset += envelope_size;
2358            }
2359
2360            let next_out_of_line = decoder.next_out_of_line();
2361            let handles_before = decoder.remaining_handles();
2362            if let Some((inlined, num_bytes, num_handles)) =
2363                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2364            {
2365                let member_inline_size =
2366                    <Sources as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2367                if inlined != (member_inline_size <= 4) {
2368                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2369                }
2370                let inner_offset;
2371                let mut inner_depth = depth.clone();
2372                if inlined {
2373                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2374                    inner_offset = next_offset;
2375                } else {
2376                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2377                    inner_depth.increment()?;
2378                }
2379                let val_ref = self.sources.get_or_insert_with(|| fidl::new_empty!(Sources, D));
2380                fidl::decode!(Sources, D, val_ref, decoder, inner_offset, inner_depth)?;
2381                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2382                {
2383                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2384                }
2385                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2386                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2387                }
2388            }
2389
2390            next_offset += envelope_size;
2391            _next_ordinal_to_read += 1;
2392            if next_offset >= end_offset {
2393                return Ok(());
2394            }
2395
2396            // Decode unknown envelopes for gaps in ordinals.
2397            while _next_ordinal_to_read < 5 {
2398                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2399                _next_ordinal_to_read += 1;
2400                next_offset += envelope_size;
2401            }
2402
2403            let next_out_of_line = decoder.next_out_of_line();
2404            let handles_before = decoder.remaining_handles();
2405            if let Some((inlined, num_bytes, num_handles)) =
2406                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2407            {
2408                let member_inline_size = <fidl::encoding::UnboundedVector<
2409                    fidl_fuchsia_sys2__common::ServiceInstance,
2410                > as fidl::encoding::TypeMarker>::inline_size(
2411                    decoder.context
2412                );
2413                if inlined != (member_inline_size <= 4) {
2414                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2415                }
2416                let inner_offset;
2417                let mut inner_depth = depth.clone();
2418                if inlined {
2419                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2420                    inner_offset = next_offset;
2421                } else {
2422                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2423                    inner_depth.increment()?;
2424                }
2425                let val_ref = self.instances.get_or_insert_with(|| {
2426                    fidl::new_empty!(
2427                        fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance>,
2428                        D
2429                    )
2430                });
2431                fidl::decode!(
2432                    fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance>,
2433                    D,
2434                    val_ref,
2435                    decoder,
2436                    inner_offset,
2437                    inner_depth
2438                )?;
2439                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2440                {
2441                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2442                }
2443                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2444                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2445                }
2446            }
2447
2448            next_offset += envelope_size;
2449
2450            // Decode the remaining unknown envelopes.
2451            while next_offset < end_offset {
2452                _next_ordinal_to_read += 1;
2453                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2454                next_offset += envelope_size;
2455            }
2456
2457            Ok(())
2458        }
2459    }
2460
2461    impl Builtin {
2462        #[inline(always)]
2463        fn max_ordinal_present(&self) -> u64 {
2464            if let Some(_) = self.capability {
2465                return 1;
2466            }
2467            0
2468        }
2469    }
2470
2471    impl fidl::encoding::ValueTypeMarker for Builtin {
2472        type Borrowed<'a> = &'a Self;
2473        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2474            value
2475        }
2476    }
2477
2478    unsafe impl fidl::encoding::TypeMarker for Builtin {
2479        type Owned = Self;
2480
2481        #[inline(always)]
2482        fn inline_align(_context: fidl::encoding::Context) -> usize {
2483            8
2484        }
2485
2486        #[inline(always)]
2487        fn inline_size(_context: fidl::encoding::Context) -> usize {
2488            16
2489        }
2490    }
2491
2492    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Builtin, D> for &Builtin {
2493        unsafe fn encode(
2494            self,
2495            encoder: &mut fidl::encoding::Encoder<'_, D>,
2496            offset: usize,
2497            mut depth: fidl::encoding::Depth,
2498        ) -> fidl::Result<()> {
2499            encoder.debug_check_bounds::<Builtin>(offset);
2500            // Vector header
2501            let max_ordinal: u64 = self.max_ordinal_present();
2502            encoder.write_num(max_ordinal, offset);
2503            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2504            // Calling encoder.out_of_line_offset(0) is not allowed.
2505            if max_ordinal == 0 {
2506                return Ok(());
2507            }
2508            depth.increment()?;
2509            let envelope_size = 8;
2510            let bytes_len = max_ordinal as usize * envelope_size;
2511            #[allow(unused_variables)]
2512            let offset = encoder.out_of_line_offset(bytes_len);
2513            let mut _prev_end_offset: usize = 0;
2514            if 1 > max_ordinal {
2515                return Ok(());
2516            }
2517
2518            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2519            // are envelope_size bytes.
2520            let cur_offset: usize = (1 - 1) * envelope_size;
2521
2522            // Zero reserved fields.
2523            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2524
2525            // Safety:
2526            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2527            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2528            //   envelope_size bytes, there is always sufficient room.
2529            fidl::encoding::encode_in_envelope_optional::<InternalCapability, D>(
2530                self.capability
2531                    .as_ref()
2532                    .map(<InternalCapability as fidl::encoding::ValueTypeMarker>::borrow),
2533                encoder,
2534                offset + cur_offset,
2535                depth,
2536            )?;
2537
2538            _prev_end_offset = cur_offset + envelope_size;
2539
2540            Ok(())
2541        }
2542    }
2543
2544    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Builtin {
2545        #[inline(always)]
2546        fn new_empty() -> Self {
2547            Self::default()
2548        }
2549
2550        unsafe fn decode(
2551            &mut self,
2552            decoder: &mut fidl::encoding::Decoder<'_, D>,
2553            offset: usize,
2554            mut depth: fidl::encoding::Depth,
2555        ) -> fidl::Result<()> {
2556            decoder.debug_check_bounds::<Self>(offset);
2557            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2558                None => return Err(fidl::Error::NotNullable),
2559                Some(len) => len,
2560            };
2561            // Calling decoder.out_of_line_offset(0) is not allowed.
2562            if len == 0 {
2563                return Ok(());
2564            };
2565            depth.increment()?;
2566            let envelope_size = 8;
2567            let bytes_len = len * envelope_size;
2568            let offset = decoder.out_of_line_offset(bytes_len)?;
2569            // Decode the envelope for each type.
2570            let mut _next_ordinal_to_read = 0;
2571            let mut next_offset = offset;
2572            let end_offset = offset + bytes_len;
2573            _next_ordinal_to_read += 1;
2574            if next_offset >= end_offset {
2575                return Ok(());
2576            }
2577
2578            // Decode unknown envelopes for gaps in ordinals.
2579            while _next_ordinal_to_read < 1 {
2580                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2581                _next_ordinal_to_read += 1;
2582                next_offset += envelope_size;
2583            }
2584
2585            let next_out_of_line = decoder.next_out_of_line();
2586            let handles_before = decoder.remaining_handles();
2587            if let Some((inlined, num_bytes, num_handles)) =
2588                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2589            {
2590                let member_inline_size =
2591                    <InternalCapability as fidl::encoding::TypeMarker>::inline_size(
2592                        decoder.context,
2593                    );
2594                if inlined != (member_inline_size <= 4) {
2595                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2596                }
2597                let inner_offset;
2598                let mut inner_depth = depth.clone();
2599                if inlined {
2600                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2601                    inner_offset = next_offset;
2602                } else {
2603                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2604                    inner_depth.increment()?;
2605                }
2606                let val_ref =
2607                    self.capability.get_or_insert_with(|| fidl::new_empty!(InternalCapability, D));
2608                fidl::decode!(InternalCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
2609                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2610                {
2611                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2612                }
2613                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2614                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2615                }
2616            }
2617
2618            next_offset += envelope_size;
2619
2620            // Decode the remaining unknown envelopes.
2621            while next_offset < end_offset {
2622                _next_ordinal_to_read += 1;
2623                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2624                next_offset += envelope_size;
2625            }
2626
2627            Ok(())
2628        }
2629    }
2630
2631    impl Capability {
2632        #[inline(always)]
2633        fn max_ordinal_present(&self) -> u64 {
2634            if let Some(_) = self.moniker {
2635                return 2;
2636            }
2637            if let Some(_) = self.source_capability {
2638                return 1;
2639            }
2640            0
2641        }
2642    }
2643
2644    impl fidl::encoding::ValueTypeMarker for Capability {
2645        type Borrowed<'a> = &'a Self;
2646        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2647            value
2648        }
2649    }
2650
2651    unsafe impl fidl::encoding::TypeMarker for Capability {
2652        type Owned = Self;
2653
2654        #[inline(always)]
2655        fn inline_align(_context: fidl::encoding::Context) -> usize {
2656            8
2657        }
2658
2659        #[inline(always)]
2660        fn inline_size(_context: fidl::encoding::Context) -> usize {
2661            16
2662        }
2663    }
2664
2665    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Capability, D>
2666        for &Capability
2667    {
2668        unsafe fn encode(
2669            self,
2670            encoder: &mut fidl::encoding::Encoder<'_, D>,
2671            offset: usize,
2672            mut depth: fidl::encoding::Depth,
2673        ) -> fidl::Result<()> {
2674            encoder.debug_check_bounds::<Capability>(offset);
2675            // Vector header
2676            let max_ordinal: u64 = self.max_ordinal_present();
2677            encoder.write_num(max_ordinal, offset);
2678            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2679            // Calling encoder.out_of_line_offset(0) is not allowed.
2680            if max_ordinal == 0 {
2681                return Ok(());
2682            }
2683            depth.increment()?;
2684            let envelope_size = 8;
2685            let bytes_len = max_ordinal as usize * envelope_size;
2686            #[allow(unused_variables)]
2687            let offset = encoder.out_of_line_offset(bytes_len);
2688            let mut _prev_end_offset: usize = 0;
2689            if 1 > max_ordinal {
2690                return Ok(());
2691            }
2692
2693            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2694            // are envelope_size bytes.
2695            let cur_offset: usize = (1 - 1) * envelope_size;
2696
2697            // Zero reserved fields.
2698            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2699
2700            // Safety:
2701            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2702            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2703            //   envelope_size bytes, there is always sufficient room.
2704            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
2705                self.source_capability
2706                    .as_ref()
2707                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
2708                encoder,
2709                offset + cur_offset,
2710                depth,
2711            )?;
2712
2713            _prev_end_offset = cur_offset + envelope_size;
2714            if 2 > max_ordinal {
2715                return Ok(());
2716            }
2717
2718            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2719            // are envelope_size bytes.
2720            let cur_offset: usize = (2 - 1) * envelope_size;
2721
2722            // Zero reserved fields.
2723            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2724
2725            // Safety:
2726            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2727            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2728            //   envelope_size bytes, there is always sufficient room.
2729            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
2730            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
2731            encoder, offset + cur_offset, depth
2732        )?;
2733
2734            _prev_end_offset = cur_offset + envelope_size;
2735
2736            Ok(())
2737        }
2738    }
2739
2740    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Capability {
2741        #[inline(always)]
2742        fn new_empty() -> Self {
2743            Self::default()
2744        }
2745
2746        unsafe fn decode(
2747            &mut self,
2748            decoder: &mut fidl::encoding::Decoder<'_, D>,
2749            offset: usize,
2750            mut depth: fidl::encoding::Depth,
2751        ) -> fidl::Result<()> {
2752            decoder.debug_check_bounds::<Self>(offset);
2753            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2754                None => return Err(fidl::Error::NotNullable),
2755                Some(len) => len,
2756            };
2757            // Calling decoder.out_of_line_offset(0) is not allowed.
2758            if len == 0 {
2759                return Ok(());
2760            };
2761            depth.increment()?;
2762            let envelope_size = 8;
2763            let bytes_len = len * envelope_size;
2764            let offset = decoder.out_of_line_offset(bytes_len)?;
2765            // Decode the envelope for each type.
2766            let mut _next_ordinal_to_read = 0;
2767            let mut next_offset = offset;
2768            let end_offset = offset + bytes_len;
2769            _next_ordinal_to_read += 1;
2770            if next_offset >= end_offset {
2771                return Ok(());
2772            }
2773
2774            // Decode unknown envelopes for gaps in ordinals.
2775            while _next_ordinal_to_read < 1 {
2776                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2777                _next_ordinal_to_read += 1;
2778                next_offset += envelope_size;
2779            }
2780
2781            let next_out_of_line = decoder.next_out_of_line();
2782            let handles_before = decoder.remaining_handles();
2783            if let Some((inlined, num_bytes, num_handles)) =
2784                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2785            {
2786                let member_inline_size =
2787                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
2788                        decoder.context,
2789                    );
2790                if inlined != (member_inline_size <= 4) {
2791                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2792                }
2793                let inner_offset;
2794                let mut inner_depth = depth.clone();
2795                if inlined {
2796                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2797                    inner_offset = next_offset;
2798                } else {
2799                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2800                    inner_depth.increment()?;
2801                }
2802                let val_ref = self
2803                    .source_capability
2804                    .get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
2805                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
2806                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2807                {
2808                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2809                }
2810                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2811                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2812                }
2813            }
2814
2815            next_offset += envelope_size;
2816            _next_ordinal_to_read += 1;
2817            if next_offset >= end_offset {
2818                return Ok(());
2819            }
2820
2821            // Decode unknown envelopes for gaps in ordinals.
2822            while _next_ordinal_to_read < 2 {
2823                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2824                _next_ordinal_to_read += 1;
2825                next_offset += envelope_size;
2826            }
2827
2828            let next_out_of_line = decoder.next_out_of_line();
2829            let handles_before = decoder.remaining_handles();
2830            if let Some((inlined, num_bytes, num_handles)) =
2831                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2832            {
2833                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2834                if inlined != (member_inline_size <= 4) {
2835                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2836                }
2837                let inner_offset;
2838                let mut inner_depth = depth.clone();
2839                if inlined {
2840                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2841                    inner_offset = next_offset;
2842                } else {
2843                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2844                    inner_depth.increment()?;
2845                }
2846                let val_ref = self.moniker.get_or_insert_with(|| {
2847                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
2848                });
2849                fidl::decode!(
2850                    fidl::encoding::BoundedString<4096>,
2851                    D,
2852                    val_ref,
2853                    decoder,
2854                    inner_offset,
2855                    inner_depth
2856                )?;
2857                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2858                {
2859                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2860                }
2861                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2862                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2863                }
2864            }
2865
2866            next_offset += envelope_size;
2867
2868            // Decode the remaining unknown envelopes.
2869            while next_offset < end_offset {
2870                _next_ordinal_to_read += 1;
2871                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2872                next_offset += envelope_size;
2873            }
2874
2875            Ok(())
2876        }
2877    }
2878
2879    impl CapabilityAllowlistEntry {
2880        #[inline(always)]
2881        fn max_ordinal_present(&self) -> u64 {
2882            if let Some(_) = self.source {
2883                return 5;
2884            }
2885            if let Some(_) = self.target_monikers {
2886                return 4;
2887            }
2888            if let Some(_) = self.capability {
2889                return 3;
2890            }
2891            if let Some(_) = self.source_name {
2892                return 2;
2893            }
2894            if let Some(_) = self.source_moniker {
2895                return 1;
2896            }
2897            0
2898        }
2899    }
2900
2901    impl fidl::encoding::ValueTypeMarker for CapabilityAllowlistEntry {
2902        type Borrowed<'a> = &'a Self;
2903        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2904            value
2905        }
2906    }
2907
2908    unsafe impl fidl::encoding::TypeMarker for CapabilityAllowlistEntry {
2909        type Owned = Self;
2910
2911        #[inline(always)]
2912        fn inline_align(_context: fidl::encoding::Context) -> usize {
2913            8
2914        }
2915
2916        #[inline(always)]
2917        fn inline_size(_context: fidl::encoding::Context) -> usize {
2918            16
2919        }
2920    }
2921
2922    unsafe impl<D: fidl::encoding::ResourceDialect>
2923        fidl::encoding::Encode<CapabilityAllowlistEntry, D> for &CapabilityAllowlistEntry
2924    {
2925        unsafe fn encode(
2926            self,
2927            encoder: &mut fidl::encoding::Encoder<'_, D>,
2928            offset: usize,
2929            mut depth: fidl::encoding::Depth,
2930        ) -> fidl::Result<()> {
2931            encoder.debug_check_bounds::<CapabilityAllowlistEntry>(offset);
2932            // Vector header
2933            let max_ordinal: u64 = self.max_ordinal_present();
2934            encoder.write_num(max_ordinal, offset);
2935            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2936            // Calling encoder.out_of_line_offset(0) is not allowed.
2937            if max_ordinal == 0 {
2938                return Ok(());
2939            }
2940            depth.increment()?;
2941            let envelope_size = 8;
2942            let bytes_len = max_ordinal as usize * envelope_size;
2943            #[allow(unused_variables)]
2944            let offset = encoder.out_of_line_offset(bytes_len);
2945            let mut _prev_end_offset: usize = 0;
2946            if 1 > max_ordinal {
2947                return Ok(());
2948            }
2949
2950            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2951            // are envelope_size bytes.
2952            let cur_offset: usize = (1 - 1) * envelope_size;
2953
2954            // Zero reserved fields.
2955            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2956
2957            // Safety:
2958            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2959            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2960            //   envelope_size bytes, there is always sufficient room.
2961            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
2962            self.source_moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
2963            encoder, offset + cur_offset, depth
2964        )?;
2965
2966            _prev_end_offset = cur_offset + envelope_size;
2967            if 2 > max_ordinal {
2968                return Ok(());
2969            }
2970
2971            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2972            // are envelope_size bytes.
2973            let cur_offset: usize = (2 - 1) * envelope_size;
2974
2975            // Zero reserved fields.
2976            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2977
2978            // Safety:
2979            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2980            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2981            //   envelope_size bytes, there is always sufficient room.
2982            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
2983                self.source_name.as_ref().map(
2984                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
2985                ),
2986                encoder,
2987                offset + cur_offset,
2988                depth,
2989            )?;
2990
2991            _prev_end_offset = cur_offset + envelope_size;
2992            if 3 > max_ordinal {
2993                return Ok(());
2994            }
2995
2996            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2997            // are envelope_size bytes.
2998            let cur_offset: usize = (3 - 1) * envelope_size;
2999
3000            // Zero reserved fields.
3001            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3002
3003            // Safety:
3004            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3005            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3006            //   envelope_size bytes, there is always sufficient room.
3007            fidl::encoding::encode_in_envelope_optional::<AllowlistedCapability, D>(
3008                self.capability
3009                    .as_ref()
3010                    .map(<AllowlistedCapability as fidl::encoding::ValueTypeMarker>::borrow),
3011                encoder,
3012                offset + cur_offset,
3013                depth,
3014            )?;
3015
3016            _prev_end_offset = cur_offset + envelope_size;
3017            if 4 > max_ordinal {
3018                return Ok(());
3019            }
3020
3021            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3022            // are envelope_size bytes.
3023            let cur_offset: usize = (4 - 1) * envelope_size;
3024
3025            // Zero reserved fields.
3026            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3027
3028            // Safety:
3029            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3030            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3031            //   envelope_size bytes, there is always sufficient room.
3032            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
3033            self.target_monikers.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
3034            encoder, offset + cur_offset, depth
3035        )?;
3036
3037            _prev_end_offset = cur_offset + envelope_size;
3038            if 5 > max_ordinal {
3039                return Ok(());
3040            }
3041
3042            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3043            // are envelope_size bytes.
3044            let cur_offset: usize = (5 - 1) * envelope_size;
3045
3046            // Zero reserved fields.
3047            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3048
3049            // Safety:
3050            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3051            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3052            //   envelope_size bytes, there is always sufficient room.
3053            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Ref, D>(
3054            self.source.as_ref().map(<fidl_fuchsia_component_decl__common::Ref as fidl::encoding::ValueTypeMarker>::borrow),
3055            encoder, offset + cur_offset, depth
3056        )?;
3057
3058            _prev_end_offset = cur_offset + envelope_size;
3059
3060            Ok(())
3061        }
3062    }
3063
3064    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3065        for CapabilityAllowlistEntry
3066    {
3067        #[inline(always)]
3068        fn new_empty() -> Self {
3069            Self::default()
3070        }
3071
3072        unsafe fn decode(
3073            &mut self,
3074            decoder: &mut fidl::encoding::Decoder<'_, D>,
3075            offset: usize,
3076            mut depth: fidl::encoding::Depth,
3077        ) -> fidl::Result<()> {
3078            decoder.debug_check_bounds::<Self>(offset);
3079            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3080                None => return Err(fidl::Error::NotNullable),
3081                Some(len) => len,
3082            };
3083            // Calling decoder.out_of_line_offset(0) is not allowed.
3084            if len == 0 {
3085                return Ok(());
3086            };
3087            depth.increment()?;
3088            let envelope_size = 8;
3089            let bytes_len = len * envelope_size;
3090            let offset = decoder.out_of_line_offset(bytes_len)?;
3091            // Decode the envelope for each type.
3092            let mut _next_ordinal_to_read = 0;
3093            let mut next_offset = offset;
3094            let end_offset = offset + bytes_len;
3095            _next_ordinal_to_read += 1;
3096            if next_offset >= end_offset {
3097                return Ok(());
3098            }
3099
3100            // Decode unknown envelopes for gaps in ordinals.
3101            while _next_ordinal_to_read < 1 {
3102                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3103                _next_ordinal_to_read += 1;
3104                next_offset += envelope_size;
3105            }
3106
3107            let next_out_of_line = decoder.next_out_of_line();
3108            let handles_before = decoder.remaining_handles();
3109            if let Some((inlined, num_bytes, num_handles)) =
3110                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3111            {
3112                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3113                if inlined != (member_inline_size <= 4) {
3114                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3115                }
3116                let inner_offset;
3117                let mut inner_depth = depth.clone();
3118                if inlined {
3119                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3120                    inner_offset = next_offset;
3121                } else {
3122                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3123                    inner_depth.increment()?;
3124                }
3125                let val_ref = self.source_moniker.get_or_insert_with(|| {
3126                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
3127                });
3128                fidl::decode!(
3129                    fidl::encoding::BoundedString<4096>,
3130                    D,
3131                    val_ref,
3132                    decoder,
3133                    inner_offset,
3134                    inner_depth
3135                )?;
3136                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3137                {
3138                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3139                }
3140                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3141                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3142                }
3143            }
3144
3145            next_offset += envelope_size;
3146            _next_ordinal_to_read += 1;
3147            if next_offset >= end_offset {
3148                return Ok(());
3149            }
3150
3151            // Decode unknown envelopes for gaps in ordinals.
3152            while _next_ordinal_to_read < 2 {
3153                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3154                _next_ordinal_to_read += 1;
3155                next_offset += envelope_size;
3156            }
3157
3158            let next_out_of_line = decoder.next_out_of_line();
3159            let handles_before = decoder.remaining_handles();
3160            if let Some((inlined, num_bytes, num_handles)) =
3161                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3162            {
3163                let member_inline_size =
3164                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
3165                        decoder.context,
3166                    );
3167                if inlined != (member_inline_size <= 4) {
3168                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3169                }
3170                let inner_offset;
3171                let mut inner_depth = depth.clone();
3172                if inlined {
3173                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3174                    inner_offset = next_offset;
3175                } else {
3176                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3177                    inner_depth.increment()?;
3178                }
3179                let val_ref = self
3180                    .source_name
3181                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
3182                fidl::decode!(
3183                    fidl::encoding::BoundedString<255>,
3184                    D,
3185                    val_ref,
3186                    decoder,
3187                    inner_offset,
3188                    inner_depth
3189                )?;
3190                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3191                {
3192                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3193                }
3194                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3195                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3196                }
3197            }
3198
3199            next_offset += envelope_size;
3200            _next_ordinal_to_read += 1;
3201            if next_offset >= end_offset {
3202                return Ok(());
3203            }
3204
3205            // Decode unknown envelopes for gaps in ordinals.
3206            while _next_ordinal_to_read < 3 {
3207                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3208                _next_ordinal_to_read += 1;
3209                next_offset += envelope_size;
3210            }
3211
3212            let next_out_of_line = decoder.next_out_of_line();
3213            let handles_before = decoder.remaining_handles();
3214            if let Some((inlined, num_bytes, num_handles)) =
3215                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3216            {
3217                let member_inline_size =
3218                    <AllowlistedCapability as fidl::encoding::TypeMarker>::inline_size(
3219                        decoder.context,
3220                    );
3221                if inlined != (member_inline_size <= 4) {
3222                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3223                }
3224                let inner_offset;
3225                let mut inner_depth = depth.clone();
3226                if inlined {
3227                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3228                    inner_offset = next_offset;
3229                } else {
3230                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3231                    inner_depth.increment()?;
3232                }
3233                let val_ref = self
3234                    .capability
3235                    .get_or_insert_with(|| fidl::new_empty!(AllowlistedCapability, D));
3236                fidl::decode!(
3237                    AllowlistedCapability,
3238                    D,
3239                    val_ref,
3240                    decoder,
3241                    inner_offset,
3242                    inner_depth
3243                )?;
3244                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3245                {
3246                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3247                }
3248                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3249                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3250                }
3251            }
3252
3253            next_offset += envelope_size;
3254            _next_ordinal_to_read += 1;
3255            if next_offset >= end_offset {
3256                return Ok(());
3257            }
3258
3259            // Decode unknown envelopes for gaps in ordinals.
3260            while _next_ordinal_to_read < 4 {
3261                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3262                _next_ordinal_to_read += 1;
3263                next_offset += envelope_size;
3264            }
3265
3266            let next_out_of_line = decoder.next_out_of_line();
3267            let handles_before = decoder.remaining_handles();
3268            if let Some((inlined, num_bytes, num_handles)) =
3269                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3270            {
3271                let member_inline_size = <fidl::encoding::Vector<
3272                    fidl::encoding::BoundedString<4096>,
3273                    128,
3274                > as fidl::encoding::TypeMarker>::inline_size(
3275                    decoder.context
3276                );
3277                if inlined != (member_inline_size <= 4) {
3278                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3279                }
3280                let inner_offset;
3281                let mut inner_depth = depth.clone();
3282                if inlined {
3283                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3284                    inner_offset = next_offset;
3285                } else {
3286                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3287                    inner_depth.increment()?;
3288                }
3289                let val_ref = self.target_monikers.get_or_insert_with(|| {
3290                    fidl::new_empty!(
3291                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3292                        D
3293                    )
3294                });
3295                fidl::decode!(
3296                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3297                    D,
3298                    val_ref,
3299                    decoder,
3300                    inner_offset,
3301                    inner_depth
3302                )?;
3303                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3304                {
3305                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3306                }
3307                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3308                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3309                }
3310            }
3311
3312            next_offset += envelope_size;
3313            _next_ordinal_to_read += 1;
3314            if next_offset >= end_offset {
3315                return Ok(());
3316            }
3317
3318            // Decode unknown envelopes for gaps in ordinals.
3319            while _next_ordinal_to_read < 5 {
3320                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3321                _next_ordinal_to_read += 1;
3322                next_offset += envelope_size;
3323            }
3324
3325            let next_out_of_line = decoder.next_out_of_line();
3326            let handles_before = decoder.remaining_handles();
3327            if let Some((inlined, num_bytes, num_handles)) =
3328                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3329            {
3330                let member_inline_size = <fidl_fuchsia_component_decl__common::Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3331                if inlined != (member_inline_size <= 4) {
3332                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3333                }
3334                let inner_offset;
3335                let mut inner_depth = depth.clone();
3336                if inlined {
3337                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3338                    inner_offset = next_offset;
3339                } else {
3340                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3341                    inner_depth.increment()?;
3342                }
3343                let val_ref = self.source.get_or_insert_with(|| {
3344                    fidl::new_empty!(fidl_fuchsia_component_decl__common::Ref, D)
3345                });
3346                fidl::decode!(
3347                    fidl_fuchsia_component_decl__common::Ref,
3348                    D,
3349                    val_ref,
3350                    decoder,
3351                    inner_offset,
3352                    inner_depth
3353                )?;
3354                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3355                {
3356                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3357                }
3358                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3359                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3360                }
3361            }
3362
3363            next_offset += envelope_size;
3364
3365            // Decode the remaining unknown envelopes.
3366            while next_offset < end_offset {
3367                _next_ordinal_to_read += 1;
3368                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3369                next_offset += envelope_size;
3370            }
3371
3372            Ok(())
3373        }
3374    }
3375
3376    impl CapabilityPolicyAllowlists {
3377        #[inline(always)]
3378        fn max_ordinal_present(&self) -> u64 {
3379            if let Some(_) = self.allowlist {
3380                return 1;
3381            }
3382            0
3383        }
3384    }
3385
3386    impl fidl::encoding::ValueTypeMarker for CapabilityPolicyAllowlists {
3387        type Borrowed<'a> = &'a Self;
3388        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3389            value
3390        }
3391    }
3392
3393    unsafe impl fidl::encoding::TypeMarker for CapabilityPolicyAllowlists {
3394        type Owned = Self;
3395
3396        #[inline(always)]
3397        fn inline_align(_context: fidl::encoding::Context) -> usize {
3398            8
3399        }
3400
3401        #[inline(always)]
3402        fn inline_size(_context: fidl::encoding::Context) -> usize {
3403            16
3404        }
3405    }
3406
3407    unsafe impl<D: fidl::encoding::ResourceDialect>
3408        fidl::encoding::Encode<CapabilityPolicyAllowlists, D> for &CapabilityPolicyAllowlists
3409    {
3410        unsafe fn encode(
3411            self,
3412            encoder: &mut fidl::encoding::Encoder<'_, D>,
3413            offset: usize,
3414            mut depth: fidl::encoding::Depth,
3415        ) -> fidl::Result<()> {
3416            encoder.debug_check_bounds::<CapabilityPolicyAllowlists>(offset);
3417            // Vector header
3418            let max_ordinal: u64 = self.max_ordinal_present();
3419            encoder.write_num(max_ordinal, offset);
3420            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3421            // Calling encoder.out_of_line_offset(0) is not allowed.
3422            if max_ordinal == 0 {
3423                return Ok(());
3424            }
3425            depth.increment()?;
3426            let envelope_size = 8;
3427            let bytes_len = max_ordinal as usize * envelope_size;
3428            #[allow(unused_variables)]
3429            let offset = encoder.out_of_line_offset(bytes_len);
3430            let mut _prev_end_offset: usize = 0;
3431            if 1 > max_ordinal {
3432                return Ok(());
3433            }
3434
3435            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3436            // are envelope_size bytes.
3437            let cur_offset: usize = (1 - 1) * envelope_size;
3438
3439            // Zero reserved fields.
3440            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3441
3442            // Safety:
3443            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3444            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3445            //   envelope_size bytes, there is always sufficient room.
3446            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CapabilityAllowlistEntry, 128>, D>(
3447            self.allowlist.as_ref().map(<fidl::encoding::Vector<CapabilityAllowlistEntry, 128> as fidl::encoding::ValueTypeMarker>::borrow),
3448            encoder, offset + cur_offset, depth
3449        )?;
3450
3451            _prev_end_offset = cur_offset + envelope_size;
3452
3453            Ok(())
3454        }
3455    }
3456
3457    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3458        for CapabilityPolicyAllowlists
3459    {
3460        #[inline(always)]
3461        fn new_empty() -> Self {
3462            Self::default()
3463        }
3464
3465        unsafe fn decode(
3466            &mut self,
3467            decoder: &mut fidl::encoding::Decoder<'_, D>,
3468            offset: usize,
3469            mut depth: fidl::encoding::Depth,
3470        ) -> fidl::Result<()> {
3471            decoder.debug_check_bounds::<Self>(offset);
3472            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3473                None => return Err(fidl::Error::NotNullable),
3474                Some(len) => len,
3475            };
3476            // Calling decoder.out_of_line_offset(0) is not allowed.
3477            if len == 0 {
3478                return Ok(());
3479            };
3480            depth.increment()?;
3481            let envelope_size = 8;
3482            let bytes_len = len * envelope_size;
3483            let offset = decoder.out_of_line_offset(bytes_len)?;
3484            // Decode the envelope for each type.
3485            let mut _next_ordinal_to_read = 0;
3486            let mut next_offset = offset;
3487            let end_offset = offset + bytes_len;
3488            _next_ordinal_to_read += 1;
3489            if next_offset >= end_offset {
3490                return Ok(());
3491            }
3492
3493            // Decode unknown envelopes for gaps in ordinals.
3494            while _next_ordinal_to_read < 1 {
3495                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3496                _next_ordinal_to_read += 1;
3497                next_offset += envelope_size;
3498            }
3499
3500            let next_out_of_line = decoder.next_out_of_line();
3501            let handles_before = decoder.remaining_handles();
3502            if let Some((inlined, num_bytes, num_handles)) =
3503                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3504            {
3505                let member_inline_size = <fidl::encoding::Vector<CapabilityAllowlistEntry, 128> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3506                if inlined != (member_inline_size <= 4) {
3507                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3508                }
3509                let inner_offset;
3510                let mut inner_depth = depth.clone();
3511                if inlined {
3512                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3513                    inner_offset = next_offset;
3514                } else {
3515                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3516                    inner_depth.increment()?;
3517                }
3518                let val_ref = self.allowlist.get_or_insert_with(
3519                    || fidl::new_empty!(fidl::encoding::Vector<CapabilityAllowlistEntry, 128>, D),
3520                );
3521                fidl::decode!(fidl::encoding::Vector<CapabilityAllowlistEntry, 128>, D, val_ref, decoder, inner_offset, inner_depth)?;
3522                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3523                {
3524                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3525                }
3526                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3527                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3528                }
3529            }
3530
3531            next_offset += envelope_size;
3532
3533            // Decode the remaining unknown envelopes.
3534            while next_offset < end_offset {
3535                _next_ordinal_to_read += 1;
3536                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3537                next_offset += envelope_size;
3538            }
3539
3540            Ok(())
3541        }
3542    }
3543
3544    impl ChildPolicyAllowlists {
3545        #[inline(always)]
3546        fn max_ordinal_present(&self) -> u64 {
3547            if let Some(_) = self.reboot_on_terminate {
3548                return 1;
3549            }
3550            0
3551        }
3552    }
3553
3554    impl fidl::encoding::ValueTypeMarker for ChildPolicyAllowlists {
3555        type Borrowed<'a> = &'a Self;
3556        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3557            value
3558        }
3559    }
3560
3561    unsafe impl fidl::encoding::TypeMarker for ChildPolicyAllowlists {
3562        type Owned = Self;
3563
3564        #[inline(always)]
3565        fn inline_align(_context: fidl::encoding::Context) -> usize {
3566            8
3567        }
3568
3569        #[inline(always)]
3570        fn inline_size(_context: fidl::encoding::Context) -> usize {
3571            16
3572        }
3573    }
3574
3575    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChildPolicyAllowlists, D>
3576        for &ChildPolicyAllowlists
3577    {
3578        unsafe fn encode(
3579            self,
3580            encoder: &mut fidl::encoding::Encoder<'_, D>,
3581            offset: usize,
3582            mut depth: fidl::encoding::Depth,
3583        ) -> fidl::Result<()> {
3584            encoder.debug_check_bounds::<ChildPolicyAllowlists>(offset);
3585            // Vector header
3586            let max_ordinal: u64 = self.max_ordinal_present();
3587            encoder.write_num(max_ordinal, offset);
3588            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3589            // Calling encoder.out_of_line_offset(0) is not allowed.
3590            if max_ordinal == 0 {
3591                return Ok(());
3592            }
3593            depth.increment()?;
3594            let envelope_size = 8;
3595            let bytes_len = max_ordinal as usize * envelope_size;
3596            #[allow(unused_variables)]
3597            let offset = encoder.out_of_line_offset(bytes_len);
3598            let mut _prev_end_offset: usize = 0;
3599            if 1 > max_ordinal {
3600                return Ok(());
3601            }
3602
3603            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3604            // are envelope_size bytes.
3605            let cur_offset: usize = (1 - 1) * envelope_size;
3606
3607            // Zero reserved fields.
3608            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3609
3610            // Safety:
3611            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3612            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3613            //   envelope_size bytes, there is always sufficient room.
3614            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
3615            self.reboot_on_terminate.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
3616            encoder, offset + cur_offset, depth
3617        )?;
3618
3619            _prev_end_offset = cur_offset + envelope_size;
3620
3621            Ok(())
3622        }
3623    }
3624
3625    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChildPolicyAllowlists {
3626        #[inline(always)]
3627        fn new_empty() -> Self {
3628            Self::default()
3629        }
3630
3631        unsafe fn decode(
3632            &mut self,
3633            decoder: &mut fidl::encoding::Decoder<'_, D>,
3634            offset: usize,
3635            mut depth: fidl::encoding::Depth,
3636        ) -> fidl::Result<()> {
3637            decoder.debug_check_bounds::<Self>(offset);
3638            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3639                None => return Err(fidl::Error::NotNullable),
3640                Some(len) => len,
3641            };
3642            // Calling decoder.out_of_line_offset(0) is not allowed.
3643            if len == 0 {
3644                return Ok(());
3645            };
3646            depth.increment()?;
3647            let envelope_size = 8;
3648            let bytes_len = len * envelope_size;
3649            let offset = decoder.out_of_line_offset(bytes_len)?;
3650            // Decode the envelope for each type.
3651            let mut _next_ordinal_to_read = 0;
3652            let mut next_offset = offset;
3653            let end_offset = offset + bytes_len;
3654            _next_ordinal_to_read += 1;
3655            if next_offset >= end_offset {
3656                return Ok(());
3657            }
3658
3659            // Decode unknown envelopes for gaps in ordinals.
3660            while _next_ordinal_to_read < 1 {
3661                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3662                _next_ordinal_to_read += 1;
3663                next_offset += envelope_size;
3664            }
3665
3666            let next_out_of_line = decoder.next_out_of_line();
3667            let handles_before = decoder.remaining_handles();
3668            if let Some((inlined, num_bytes, num_handles)) =
3669                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3670            {
3671                let member_inline_size = <fidl::encoding::Vector<
3672                    fidl::encoding::BoundedString<4096>,
3673                    128,
3674                > as fidl::encoding::TypeMarker>::inline_size(
3675                    decoder.context
3676                );
3677                if inlined != (member_inline_size <= 4) {
3678                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3679                }
3680                let inner_offset;
3681                let mut inner_depth = depth.clone();
3682                if inlined {
3683                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3684                    inner_offset = next_offset;
3685                } else {
3686                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3687                    inner_depth.increment()?;
3688                }
3689                let val_ref = self.reboot_on_terminate.get_or_insert_with(|| {
3690                    fidl::new_empty!(
3691                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3692                        D
3693                    )
3694                });
3695                fidl::decode!(
3696                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3697                    D,
3698                    val_ref,
3699                    decoder,
3700                    inner_offset,
3701                    inner_depth
3702                )?;
3703                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3704                {
3705                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3706                }
3707                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3708                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3709                }
3710            }
3711
3712            next_offset += envelope_size;
3713
3714            // Decode the remaining unknown envelopes.
3715            while next_offset < end_offset {
3716                _next_ordinal_to_read += 1;
3717                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3718                next_offset += envelope_size;
3719            }
3720
3721            Ok(())
3722        }
3723    }
3724
3725    impl Component {
3726        #[inline(always)]
3727        fn max_ordinal_present(&self) -> u64 {
3728            if let Some(_) = self.moniker {
3729                return 2;
3730            }
3731            if let Some(_) = self.capability {
3732                return 1;
3733            }
3734            0
3735        }
3736    }
3737
3738    impl fidl::encoding::ValueTypeMarker for Component {
3739        type Borrowed<'a> = &'a Self;
3740        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3741            value
3742        }
3743    }
3744
3745    unsafe impl fidl::encoding::TypeMarker for Component {
3746        type Owned = Self;
3747
3748        #[inline(always)]
3749        fn inline_align(_context: fidl::encoding::Context) -> usize {
3750            8
3751        }
3752
3753        #[inline(always)]
3754        fn inline_size(_context: fidl::encoding::Context) -> usize {
3755            16
3756        }
3757    }
3758
3759    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Component, D>
3760        for &Component
3761    {
3762        unsafe fn encode(
3763            self,
3764            encoder: &mut fidl::encoding::Encoder<'_, D>,
3765            offset: usize,
3766            mut depth: fidl::encoding::Depth,
3767        ) -> fidl::Result<()> {
3768            encoder.debug_check_bounds::<Component>(offset);
3769            // Vector header
3770            let max_ordinal: u64 = self.max_ordinal_present();
3771            encoder.write_num(max_ordinal, offset);
3772            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3773            // Calling encoder.out_of_line_offset(0) is not allowed.
3774            if max_ordinal == 0 {
3775                return Ok(());
3776            }
3777            depth.increment()?;
3778            let envelope_size = 8;
3779            let bytes_len = max_ordinal as usize * envelope_size;
3780            #[allow(unused_variables)]
3781            let offset = encoder.out_of_line_offset(bytes_len);
3782            let mut _prev_end_offset: usize = 0;
3783            if 1 > max_ordinal {
3784                return Ok(());
3785            }
3786
3787            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3788            // are envelope_size bytes.
3789            let cur_offset: usize = (1 - 1) * envelope_size;
3790
3791            // Zero reserved fields.
3792            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3793
3794            // Safety:
3795            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3796            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3797            //   envelope_size bytes, there is always sufficient room.
3798            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
3799                self.capability
3800                    .as_ref()
3801                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
3802                encoder,
3803                offset + cur_offset,
3804                depth,
3805            )?;
3806
3807            _prev_end_offset = cur_offset + envelope_size;
3808            if 2 > max_ordinal {
3809                return Ok(());
3810            }
3811
3812            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3813            // are envelope_size bytes.
3814            let cur_offset: usize = (2 - 1) * envelope_size;
3815
3816            // Zero reserved fields.
3817            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3818
3819            // Safety:
3820            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3821            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3822            //   envelope_size bytes, there is always sufficient room.
3823            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
3824            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
3825            encoder, offset + cur_offset, depth
3826        )?;
3827
3828            _prev_end_offset = cur_offset + envelope_size;
3829
3830            Ok(())
3831        }
3832    }
3833
3834    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Component {
3835        #[inline(always)]
3836        fn new_empty() -> Self {
3837            Self::default()
3838        }
3839
3840        unsafe fn decode(
3841            &mut self,
3842            decoder: &mut fidl::encoding::Decoder<'_, D>,
3843            offset: usize,
3844            mut depth: fidl::encoding::Depth,
3845        ) -> fidl::Result<()> {
3846            decoder.debug_check_bounds::<Self>(offset);
3847            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3848                None => return Err(fidl::Error::NotNullable),
3849                Some(len) => len,
3850            };
3851            // Calling decoder.out_of_line_offset(0) is not allowed.
3852            if len == 0 {
3853                return Ok(());
3854            };
3855            depth.increment()?;
3856            let envelope_size = 8;
3857            let bytes_len = len * envelope_size;
3858            let offset = decoder.out_of_line_offset(bytes_len)?;
3859            // Decode the envelope for each type.
3860            let mut _next_ordinal_to_read = 0;
3861            let mut next_offset = offset;
3862            let end_offset = offset + bytes_len;
3863            _next_ordinal_to_read += 1;
3864            if next_offset >= end_offset {
3865                return Ok(());
3866            }
3867
3868            // Decode unknown envelopes for gaps in ordinals.
3869            while _next_ordinal_to_read < 1 {
3870                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3871                _next_ordinal_to_read += 1;
3872                next_offset += envelope_size;
3873            }
3874
3875            let next_out_of_line = decoder.next_out_of_line();
3876            let handles_before = decoder.remaining_handles();
3877            if let Some((inlined, num_bytes, num_handles)) =
3878                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3879            {
3880                let member_inline_size =
3881                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
3882                        decoder.context,
3883                    );
3884                if inlined != (member_inline_size <= 4) {
3885                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3886                }
3887                let inner_offset;
3888                let mut inner_depth = depth.clone();
3889                if inlined {
3890                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3891                    inner_offset = next_offset;
3892                } else {
3893                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3894                    inner_depth.increment()?;
3895                }
3896                let val_ref =
3897                    self.capability.get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
3898                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
3899                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3900                {
3901                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3902                }
3903                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3904                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3905                }
3906            }
3907
3908            next_offset += envelope_size;
3909            _next_ordinal_to_read += 1;
3910            if next_offset >= end_offset {
3911                return Ok(());
3912            }
3913
3914            // Decode unknown envelopes for gaps in ordinals.
3915            while _next_ordinal_to_read < 2 {
3916                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3917                _next_ordinal_to_read += 1;
3918                next_offset += envelope_size;
3919            }
3920
3921            let next_out_of_line = decoder.next_out_of_line();
3922            let handles_before = decoder.remaining_handles();
3923            if let Some((inlined, num_bytes, num_handles)) =
3924                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3925            {
3926                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3927                if inlined != (member_inline_size <= 4) {
3928                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3929                }
3930                let inner_offset;
3931                let mut inner_depth = depth.clone();
3932                if inlined {
3933                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3934                    inner_offset = next_offset;
3935                } else {
3936                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3937                    inner_depth.increment()?;
3938                }
3939                let val_ref = self.moniker.get_or_insert_with(|| {
3940                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
3941                });
3942                fidl::decode!(
3943                    fidl::encoding::BoundedString<4096>,
3944                    D,
3945                    val_ref,
3946                    decoder,
3947                    inner_offset,
3948                    inner_depth
3949                )?;
3950                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3951                {
3952                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3953                }
3954                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3955                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3956                }
3957            }
3958
3959            next_offset += envelope_size;
3960
3961            // Decode the remaining unknown envelopes.
3962            while next_offset < end_offset {
3963                _next_ordinal_to_read += 1;
3964                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3965                next_offset += envelope_size;
3966            }
3967
3968            Ok(())
3969        }
3970    }
3971
3972    impl ComponentIdIndex {
3973        #[inline(always)]
3974        fn max_ordinal_present(&self) -> u64 {
3975            if let Some(_) = self.instances {
3976                return 2;
3977            }
3978            0
3979        }
3980    }
3981
3982    impl fidl::encoding::ValueTypeMarker for ComponentIdIndex {
3983        type Borrowed<'a> = &'a Self;
3984        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3985            value
3986        }
3987    }
3988
3989    unsafe impl fidl::encoding::TypeMarker for ComponentIdIndex {
3990        type Owned = Self;
3991
3992        #[inline(always)]
3993        fn inline_align(_context: fidl::encoding::Context) -> usize {
3994            8
3995        }
3996
3997        #[inline(always)]
3998        fn inline_size(_context: fidl::encoding::Context) -> usize {
3999            16
4000        }
4001    }
4002
4003    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ComponentIdIndex, D>
4004        for &ComponentIdIndex
4005    {
4006        unsafe fn encode(
4007            self,
4008            encoder: &mut fidl::encoding::Encoder<'_, D>,
4009            offset: usize,
4010            mut depth: fidl::encoding::Depth,
4011        ) -> fidl::Result<()> {
4012            encoder.debug_check_bounds::<ComponentIdIndex>(offset);
4013            // Vector header
4014            let max_ordinal: u64 = self.max_ordinal_present();
4015            encoder.write_num(max_ordinal, offset);
4016            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4017            // Calling encoder.out_of_line_offset(0) is not allowed.
4018            if max_ordinal == 0 {
4019                return Ok(());
4020            }
4021            depth.increment()?;
4022            let envelope_size = 8;
4023            let bytes_len = max_ordinal as usize * envelope_size;
4024            #[allow(unused_variables)]
4025            let offset = encoder.out_of_line_offset(bytes_len);
4026            let mut _prev_end_offset: usize = 0;
4027            if 2 > max_ordinal {
4028                return Ok(());
4029            }
4030
4031            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4032            // are envelope_size bytes.
4033            let cur_offset: usize = (2 - 1) * envelope_size;
4034
4035            // Zero reserved fields.
4036            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4037
4038            // Safety:
4039            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4040            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4041            //   envelope_size bytes, there is always sufficient room.
4042            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<InstanceIdEntry, 1024>, D>(
4043            self.instances.as_ref().map(<fidl::encoding::Vector<InstanceIdEntry, 1024> as fidl::encoding::ValueTypeMarker>::borrow),
4044            encoder, offset + cur_offset, depth
4045        )?;
4046
4047            _prev_end_offset = cur_offset + envelope_size;
4048
4049            Ok(())
4050        }
4051    }
4052
4053    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ComponentIdIndex {
4054        #[inline(always)]
4055        fn new_empty() -> Self {
4056            Self::default()
4057        }
4058
4059        unsafe fn decode(
4060            &mut self,
4061            decoder: &mut fidl::encoding::Decoder<'_, D>,
4062            offset: usize,
4063            mut depth: fidl::encoding::Depth,
4064        ) -> fidl::Result<()> {
4065            decoder.debug_check_bounds::<Self>(offset);
4066            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4067                None => return Err(fidl::Error::NotNullable),
4068                Some(len) => len,
4069            };
4070            // Calling decoder.out_of_line_offset(0) is not allowed.
4071            if len == 0 {
4072                return Ok(());
4073            };
4074            depth.increment()?;
4075            let envelope_size = 8;
4076            let bytes_len = len * envelope_size;
4077            let offset = decoder.out_of_line_offset(bytes_len)?;
4078            // Decode the envelope for each type.
4079            let mut _next_ordinal_to_read = 0;
4080            let mut next_offset = offset;
4081            let end_offset = offset + bytes_len;
4082            _next_ordinal_to_read += 1;
4083            if next_offset >= end_offset {
4084                return Ok(());
4085            }
4086
4087            // Decode unknown envelopes for gaps in ordinals.
4088            while _next_ordinal_to_read < 2 {
4089                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4090                _next_ordinal_to_read += 1;
4091                next_offset += envelope_size;
4092            }
4093
4094            let next_out_of_line = decoder.next_out_of_line();
4095            let handles_before = decoder.remaining_handles();
4096            if let Some((inlined, num_bytes, num_handles)) =
4097                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4098            {
4099                let member_inline_size = <fidl::encoding::Vector<InstanceIdEntry, 1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4100                if inlined != (member_inline_size <= 4) {
4101                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4102                }
4103                let inner_offset;
4104                let mut inner_depth = depth.clone();
4105                if inlined {
4106                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4107                    inner_offset = next_offset;
4108                } else {
4109                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4110                    inner_depth.increment()?;
4111                }
4112                let val_ref = self.instances.get_or_insert_with(
4113                    || fidl::new_empty!(fidl::encoding::Vector<InstanceIdEntry, 1024>, D),
4114                );
4115                fidl::decode!(fidl::encoding::Vector<InstanceIdEntry, 1024>, D, val_ref, decoder, inner_offset, inner_depth)?;
4116                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4117                {
4118                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4119                }
4120                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4121                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4122                }
4123            }
4124
4125            next_offset += envelope_size;
4126
4127            // Decode the remaining unknown envelopes.
4128            while next_offset < end_offset {
4129                _next_ordinal_to_read += 1;
4130                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4131                next_offset += envelope_size;
4132            }
4133
4134            Ok(())
4135        }
4136    }
4137
4138    impl Config {
4139        #[inline(always)]
4140        fn max_ordinal_present(&self) -> u64 {
4141            if let Some(_) = self.trace_provider {
4142                return 22;
4143            }
4144            if let Some(_) = self.health_check {
4145                return 21;
4146            }
4147            if let Some(_) = self.vmex_source {
4148                return 20;
4149            }
4150            if let Some(_) = self.abi_revision_policy {
4151                return 19;
4152            }
4153            if let Some(_) = self.enable_introspection {
4154                return 18;
4155            }
4156            if let Some(_) = self.builtin_capabilities {
4157                return 17;
4158            }
4159            if let Some(_) = self.realm_builder_resolver_and_runner {
4160                return 16;
4161            }
4162            if let Some(_) = self.builtin_boot_resolver {
4163                return 14;
4164            }
4165            if let Some(_) = self.log_all_events {
4166                return 13;
4167            }
4168            if let Some(_) = self.log_destination {
4169                return 12;
4170            }
4171            if let Some(_) = self.component_id_index_path {
4172                return 11;
4173            }
4174            if let Some(_) = self.root_component_url {
4175                return 10;
4176            }
4177            if let Some(_) = self.num_threads {
4178                return 7;
4179            }
4180            if let Some(_) = self.maintain_utc_clock {
4181                return 6;
4182            }
4183            if let Some(_) = self.use_builtin_process_launcher {
4184                return 5;
4185            }
4186            if let Some(_) = self.namespace_capabilities {
4187                return 4;
4188            }
4189            if let Some(_) = self.security_policy {
4190                return 3;
4191            }
4192            if let Some(_) = self.list_children_batch_size {
4193                return 2;
4194            }
4195            if let Some(_) = self.debug {
4196                return 1;
4197            }
4198            0
4199        }
4200    }
4201
4202    impl fidl::encoding::ValueTypeMarker for Config {
4203        type Borrowed<'a> = &'a Self;
4204        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4205            value
4206        }
4207    }
4208
4209    unsafe impl fidl::encoding::TypeMarker for Config {
4210        type Owned = Self;
4211
4212        #[inline(always)]
4213        fn inline_align(_context: fidl::encoding::Context) -> usize {
4214            8
4215        }
4216
4217        #[inline(always)]
4218        fn inline_size(_context: fidl::encoding::Context) -> usize {
4219            16
4220        }
4221    }
4222
4223    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Config, D> for &Config {
4224        unsafe fn encode(
4225            self,
4226            encoder: &mut fidl::encoding::Encoder<'_, D>,
4227            offset: usize,
4228            mut depth: fidl::encoding::Depth,
4229        ) -> fidl::Result<()> {
4230            encoder.debug_check_bounds::<Config>(offset);
4231            // Vector header
4232            let max_ordinal: u64 = self.max_ordinal_present();
4233            encoder.write_num(max_ordinal, offset);
4234            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4235            // Calling encoder.out_of_line_offset(0) is not allowed.
4236            if max_ordinal == 0 {
4237                return Ok(());
4238            }
4239            depth.increment()?;
4240            let envelope_size = 8;
4241            let bytes_len = max_ordinal as usize * envelope_size;
4242            #[allow(unused_variables)]
4243            let offset = encoder.out_of_line_offset(bytes_len);
4244            let mut _prev_end_offset: usize = 0;
4245            if 1 > max_ordinal {
4246                return Ok(());
4247            }
4248
4249            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4250            // are envelope_size bytes.
4251            let cur_offset: usize = (1 - 1) * envelope_size;
4252
4253            // Zero reserved fields.
4254            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4255
4256            // Safety:
4257            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4258            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4259            //   envelope_size bytes, there is always sufficient room.
4260            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4261                self.debug.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4262                encoder,
4263                offset + cur_offset,
4264                depth,
4265            )?;
4266
4267            _prev_end_offset = cur_offset + envelope_size;
4268            if 2 > max_ordinal {
4269                return Ok(());
4270            }
4271
4272            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4273            // are envelope_size bytes.
4274            let cur_offset: usize = (2 - 1) * envelope_size;
4275
4276            // Zero reserved fields.
4277            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4278
4279            // Safety:
4280            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4281            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4282            //   envelope_size bytes, there is always sufficient room.
4283            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4284                self.list_children_batch_size
4285                    .as_ref()
4286                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4287                encoder,
4288                offset + cur_offset,
4289                depth,
4290            )?;
4291
4292            _prev_end_offset = cur_offset + envelope_size;
4293            if 3 > max_ordinal {
4294                return Ok(());
4295            }
4296
4297            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4298            // are envelope_size bytes.
4299            let cur_offset: usize = (3 - 1) * envelope_size;
4300
4301            // Zero reserved fields.
4302            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4303
4304            // Safety:
4305            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4306            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4307            //   envelope_size bytes, there is always sufficient room.
4308            fidl::encoding::encode_in_envelope_optional::<SecurityPolicy, D>(
4309                self.security_policy
4310                    .as_ref()
4311                    .map(<SecurityPolicy as fidl::encoding::ValueTypeMarker>::borrow),
4312                encoder,
4313                offset + cur_offset,
4314                depth,
4315            )?;
4316
4317            _prev_end_offset = cur_offset + envelope_size;
4318            if 4 > max_ordinal {
4319                return Ok(());
4320            }
4321
4322            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4323            // are envelope_size bytes.
4324            let cur_offset: usize = (4 - 1) * envelope_size;
4325
4326            // Zero reserved fields.
4327            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4328
4329            // Safety:
4330            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4331            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4332            //   envelope_size bytes, there is always sufficient room.
4333            fidl::encoding::encode_in_envelope_optional::<
4334                fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Capability>,
4335                D,
4336            >(
4337                self.namespace_capabilities.as_ref().map(
4338                    <fidl::encoding::UnboundedVector<
4339                        fidl_fuchsia_component_decl__common::Capability,
4340                    > as fidl::encoding::ValueTypeMarker>::borrow,
4341                ),
4342                encoder,
4343                offset + cur_offset,
4344                depth,
4345            )?;
4346
4347            _prev_end_offset = cur_offset + envelope_size;
4348            if 5 > max_ordinal {
4349                return Ok(());
4350            }
4351
4352            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4353            // are envelope_size bytes.
4354            let cur_offset: usize = (5 - 1) * envelope_size;
4355
4356            // Zero reserved fields.
4357            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4358
4359            // Safety:
4360            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4361            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4362            //   envelope_size bytes, there is always sufficient room.
4363            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4364                self.use_builtin_process_launcher
4365                    .as_ref()
4366                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4367                encoder,
4368                offset + cur_offset,
4369                depth,
4370            )?;
4371
4372            _prev_end_offset = cur_offset + envelope_size;
4373            if 6 > max_ordinal {
4374                return Ok(());
4375            }
4376
4377            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4378            // are envelope_size bytes.
4379            let cur_offset: usize = (6 - 1) * envelope_size;
4380
4381            // Zero reserved fields.
4382            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4383
4384            // Safety:
4385            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4386            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4387            //   envelope_size bytes, there is always sufficient room.
4388            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4389                self.maintain_utc_clock
4390                    .as_ref()
4391                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4392                encoder,
4393                offset + cur_offset,
4394                depth,
4395            )?;
4396
4397            _prev_end_offset = cur_offset + envelope_size;
4398            if 7 > max_ordinal {
4399                return Ok(());
4400            }
4401
4402            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4403            // are envelope_size bytes.
4404            let cur_offset: usize = (7 - 1) * envelope_size;
4405
4406            // Zero reserved fields.
4407            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4408
4409            // Safety:
4410            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4411            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4412            //   envelope_size bytes, there is always sufficient room.
4413            fidl::encoding::encode_in_envelope_optional::<u8, D>(
4414                self.num_threads.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
4415                encoder,
4416                offset + cur_offset,
4417                depth,
4418            )?;
4419
4420            _prev_end_offset = cur_offset + envelope_size;
4421            if 10 > max_ordinal {
4422                return Ok(());
4423            }
4424
4425            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4426            // are envelope_size bytes.
4427            let cur_offset: usize = (10 - 1) * envelope_size;
4428
4429            // Zero reserved fields.
4430            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4431
4432            // Safety:
4433            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4434            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4435            //   envelope_size bytes, there is always sufficient room.
4436            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
4437            self.root_component_url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
4438            encoder, offset + cur_offset, depth
4439        )?;
4440
4441            _prev_end_offset = cur_offset + envelope_size;
4442            if 11 > max_ordinal {
4443                return Ok(());
4444            }
4445
4446            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4447            // are envelope_size bytes.
4448            let cur_offset: usize = (11 - 1) * envelope_size;
4449
4450            // Zero reserved fields.
4451            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4452
4453            // Safety:
4454            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4455            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4456            //   envelope_size bytes, there is always sufficient room.
4457            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
4458            self.component_id_index_path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
4459            encoder, offset + cur_offset, depth
4460        )?;
4461
4462            _prev_end_offset = cur_offset + envelope_size;
4463            if 12 > max_ordinal {
4464                return Ok(());
4465            }
4466
4467            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4468            // are envelope_size bytes.
4469            let cur_offset: usize = (12 - 1) * envelope_size;
4470
4471            // Zero reserved fields.
4472            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4473
4474            // Safety:
4475            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4476            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4477            //   envelope_size bytes, there is always sufficient room.
4478            fidl::encoding::encode_in_envelope_optional::<LogDestination, D>(
4479                self.log_destination
4480                    .as_ref()
4481                    .map(<LogDestination as fidl::encoding::ValueTypeMarker>::borrow),
4482                encoder,
4483                offset + cur_offset,
4484                depth,
4485            )?;
4486
4487            _prev_end_offset = cur_offset + envelope_size;
4488            if 13 > max_ordinal {
4489                return Ok(());
4490            }
4491
4492            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4493            // are envelope_size bytes.
4494            let cur_offset: usize = (13 - 1) * envelope_size;
4495
4496            // Zero reserved fields.
4497            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4498
4499            // Safety:
4500            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4501            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4502            //   envelope_size bytes, there is always sufficient room.
4503            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4504                self.log_all_events.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4505                encoder,
4506                offset + cur_offset,
4507                depth,
4508            )?;
4509
4510            _prev_end_offset = cur_offset + envelope_size;
4511            if 14 > max_ordinal {
4512                return Ok(());
4513            }
4514
4515            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4516            // are envelope_size bytes.
4517            let cur_offset: usize = (14 - 1) * envelope_size;
4518
4519            // Zero reserved fields.
4520            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4521
4522            // Safety:
4523            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4524            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4525            //   envelope_size bytes, there is always sufficient room.
4526            fidl::encoding::encode_in_envelope_optional::<BuiltinBootResolver, D>(
4527                self.builtin_boot_resolver
4528                    .as_ref()
4529                    .map(<BuiltinBootResolver as fidl::encoding::ValueTypeMarker>::borrow),
4530                encoder,
4531                offset + cur_offset,
4532                depth,
4533            )?;
4534
4535            _prev_end_offset = cur_offset + envelope_size;
4536            if 16 > max_ordinal {
4537                return Ok(());
4538            }
4539
4540            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4541            // are envelope_size bytes.
4542            let cur_offset: usize = (16 - 1) * envelope_size;
4543
4544            // Zero reserved fields.
4545            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4546
4547            // Safety:
4548            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4549            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4550            //   envelope_size bytes, there is always sufficient room.
4551            fidl::encoding::encode_in_envelope_optional::<RealmBuilderResolverAndRunner, D>(
4552                self.realm_builder_resolver_and_runner.as_ref().map(
4553                    <RealmBuilderResolverAndRunner as fidl::encoding::ValueTypeMarker>::borrow,
4554                ),
4555                encoder,
4556                offset + cur_offset,
4557                depth,
4558            )?;
4559
4560            _prev_end_offset = cur_offset + envelope_size;
4561            if 17 > max_ordinal {
4562                return Ok(());
4563            }
4564
4565            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4566            // are envelope_size bytes.
4567            let cur_offset: usize = (17 - 1) * envelope_size;
4568
4569            // Zero reserved fields.
4570            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4571
4572            // Safety:
4573            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4574            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4575            //   envelope_size bytes, there is always sufficient room.
4576            fidl::encoding::encode_in_envelope_optional::<
4577                fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Capability>,
4578                D,
4579            >(
4580                self.builtin_capabilities.as_ref().map(
4581                    <fidl::encoding::UnboundedVector<
4582                        fidl_fuchsia_component_decl__common::Capability,
4583                    > as fidl::encoding::ValueTypeMarker>::borrow,
4584                ),
4585                encoder,
4586                offset + cur_offset,
4587                depth,
4588            )?;
4589
4590            _prev_end_offset = cur_offset + envelope_size;
4591            if 18 > max_ordinal {
4592                return Ok(());
4593            }
4594
4595            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4596            // are envelope_size bytes.
4597            let cur_offset: usize = (18 - 1) * envelope_size;
4598
4599            // Zero reserved fields.
4600            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4601
4602            // Safety:
4603            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4604            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4605            //   envelope_size bytes, there is always sufficient room.
4606            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4607                self.enable_introspection
4608                    .as_ref()
4609                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4610                encoder,
4611                offset + cur_offset,
4612                depth,
4613            )?;
4614
4615            _prev_end_offset = cur_offset + envelope_size;
4616            if 19 > max_ordinal {
4617                return Ok(());
4618            }
4619
4620            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4621            // are envelope_size bytes.
4622            let cur_offset: usize = (19 - 1) * envelope_size;
4623
4624            // Zero reserved fields.
4625            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4626
4627            // Safety:
4628            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4629            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4630            //   envelope_size bytes, there is always sufficient room.
4631            fidl::encoding::encode_in_envelope_optional::<AbiRevisionPolicy, D>(
4632                self.abi_revision_policy
4633                    .as_ref()
4634                    .map(<AbiRevisionPolicy as fidl::encoding::ValueTypeMarker>::borrow),
4635                encoder,
4636                offset + cur_offset,
4637                depth,
4638            )?;
4639
4640            _prev_end_offset = cur_offset + envelope_size;
4641            if 20 > max_ordinal {
4642                return Ok(());
4643            }
4644
4645            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4646            // are envelope_size bytes.
4647            let cur_offset: usize = (20 - 1) * envelope_size;
4648
4649            // Zero reserved fields.
4650            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4651
4652            // Safety:
4653            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4654            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4655            //   envelope_size bytes, there is always sufficient room.
4656            fidl::encoding::encode_in_envelope_optional::<VmexSource, D>(
4657                self.vmex_source
4658                    .as_ref()
4659                    .map(<VmexSource as fidl::encoding::ValueTypeMarker>::borrow),
4660                encoder,
4661                offset + cur_offset,
4662                depth,
4663            )?;
4664
4665            _prev_end_offset = cur_offset + envelope_size;
4666            if 21 > max_ordinal {
4667                return Ok(());
4668            }
4669
4670            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4671            // are envelope_size bytes.
4672            let cur_offset: usize = (21 - 1) * envelope_size;
4673
4674            // Zero reserved fields.
4675            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4676
4677            // Safety:
4678            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4679            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4680            //   envelope_size bytes, there is always sufficient room.
4681            fidl::encoding::encode_in_envelope_optional::<HealthCheck, D>(
4682                self.health_check
4683                    .as_ref()
4684                    .map(<HealthCheck as fidl::encoding::ValueTypeMarker>::borrow),
4685                encoder,
4686                offset + cur_offset,
4687                depth,
4688            )?;
4689
4690            _prev_end_offset = cur_offset + envelope_size;
4691            if 22 > max_ordinal {
4692                return Ok(());
4693            }
4694
4695            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4696            // are envelope_size bytes.
4697            let cur_offset: usize = (22 - 1) * envelope_size;
4698
4699            // Zero reserved fields.
4700            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4701
4702            // Safety:
4703            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4704            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4705            //   envelope_size bytes, there is always sufficient room.
4706            fidl::encoding::encode_in_envelope_optional::<TraceProvider, D>(
4707                self.trace_provider
4708                    .as_ref()
4709                    .map(<TraceProvider as fidl::encoding::ValueTypeMarker>::borrow),
4710                encoder,
4711                offset + cur_offset,
4712                depth,
4713            )?;
4714
4715            _prev_end_offset = cur_offset + envelope_size;
4716
4717            Ok(())
4718        }
4719    }
4720
4721    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Config {
4722        #[inline(always)]
4723        fn new_empty() -> Self {
4724            Self::default()
4725        }
4726
4727        unsafe fn decode(
4728            &mut self,
4729            decoder: &mut fidl::encoding::Decoder<'_, D>,
4730            offset: usize,
4731            mut depth: fidl::encoding::Depth,
4732        ) -> fidl::Result<()> {
4733            decoder.debug_check_bounds::<Self>(offset);
4734            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4735                None => return Err(fidl::Error::NotNullable),
4736                Some(len) => len,
4737            };
4738            // Calling decoder.out_of_line_offset(0) is not allowed.
4739            if len == 0 {
4740                return Ok(());
4741            };
4742            depth.increment()?;
4743            let envelope_size = 8;
4744            let bytes_len = len * envelope_size;
4745            let offset = decoder.out_of_line_offset(bytes_len)?;
4746            // Decode the envelope for each type.
4747            let mut _next_ordinal_to_read = 0;
4748            let mut next_offset = offset;
4749            let end_offset = offset + bytes_len;
4750            _next_ordinal_to_read += 1;
4751            if next_offset >= end_offset {
4752                return Ok(());
4753            }
4754
4755            // Decode unknown envelopes for gaps in ordinals.
4756            while _next_ordinal_to_read < 1 {
4757                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4758                _next_ordinal_to_read += 1;
4759                next_offset += envelope_size;
4760            }
4761
4762            let next_out_of_line = decoder.next_out_of_line();
4763            let handles_before = decoder.remaining_handles();
4764            if let Some((inlined, num_bytes, num_handles)) =
4765                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4766            {
4767                let member_inline_size =
4768                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4769                if inlined != (member_inline_size <= 4) {
4770                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4771                }
4772                let inner_offset;
4773                let mut inner_depth = depth.clone();
4774                if inlined {
4775                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4776                    inner_offset = next_offset;
4777                } else {
4778                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4779                    inner_depth.increment()?;
4780                }
4781                let val_ref = self.debug.get_or_insert_with(|| fidl::new_empty!(bool, D));
4782                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4783                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4784                {
4785                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4786                }
4787                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4788                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4789                }
4790            }
4791
4792            next_offset += envelope_size;
4793            _next_ordinal_to_read += 1;
4794            if next_offset >= end_offset {
4795                return Ok(());
4796            }
4797
4798            // Decode unknown envelopes for gaps in ordinals.
4799            while _next_ordinal_to_read < 2 {
4800                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4801                _next_ordinal_to_read += 1;
4802                next_offset += envelope_size;
4803            }
4804
4805            let next_out_of_line = decoder.next_out_of_line();
4806            let handles_before = decoder.remaining_handles();
4807            if let Some((inlined, num_bytes, num_handles)) =
4808                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4809            {
4810                let member_inline_size =
4811                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4812                if inlined != (member_inline_size <= 4) {
4813                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4814                }
4815                let inner_offset;
4816                let mut inner_depth = depth.clone();
4817                if inlined {
4818                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4819                    inner_offset = next_offset;
4820                } else {
4821                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4822                    inner_depth.increment()?;
4823                }
4824                let val_ref =
4825                    self.list_children_batch_size.get_or_insert_with(|| fidl::new_empty!(u32, D));
4826                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4827                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4828                {
4829                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4830                }
4831                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4832                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4833                }
4834            }
4835
4836            next_offset += envelope_size;
4837            _next_ordinal_to_read += 1;
4838            if next_offset >= end_offset {
4839                return Ok(());
4840            }
4841
4842            // Decode unknown envelopes for gaps in ordinals.
4843            while _next_ordinal_to_read < 3 {
4844                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4845                _next_ordinal_to_read += 1;
4846                next_offset += envelope_size;
4847            }
4848
4849            let next_out_of_line = decoder.next_out_of_line();
4850            let handles_before = decoder.remaining_handles();
4851            if let Some((inlined, num_bytes, num_handles)) =
4852                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4853            {
4854                let member_inline_size =
4855                    <SecurityPolicy as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4856                if inlined != (member_inline_size <= 4) {
4857                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4858                }
4859                let inner_offset;
4860                let mut inner_depth = depth.clone();
4861                if inlined {
4862                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4863                    inner_offset = next_offset;
4864                } else {
4865                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4866                    inner_depth.increment()?;
4867                }
4868                let val_ref =
4869                    self.security_policy.get_or_insert_with(|| fidl::new_empty!(SecurityPolicy, D));
4870                fidl::decode!(SecurityPolicy, D, val_ref, decoder, inner_offset, inner_depth)?;
4871                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4872                {
4873                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4874                }
4875                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4876                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4877                }
4878            }
4879
4880            next_offset += envelope_size;
4881            _next_ordinal_to_read += 1;
4882            if next_offset >= end_offset {
4883                return Ok(());
4884            }
4885
4886            // Decode unknown envelopes for gaps in ordinals.
4887            while _next_ordinal_to_read < 4 {
4888                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4889                _next_ordinal_to_read += 1;
4890                next_offset += envelope_size;
4891            }
4892
4893            let next_out_of_line = decoder.next_out_of_line();
4894            let handles_before = decoder.remaining_handles();
4895            if let Some((inlined, num_bytes, num_handles)) =
4896                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4897            {
4898                let member_inline_size = <fidl::encoding::UnboundedVector<
4899                    fidl_fuchsia_component_decl__common::Capability,
4900                > as fidl::encoding::TypeMarker>::inline_size(
4901                    decoder.context
4902                );
4903                if inlined != (member_inline_size <= 4) {
4904                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4905                }
4906                let inner_offset;
4907                let mut inner_depth = depth.clone();
4908                if inlined {
4909                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4910                    inner_offset = next_offset;
4911                } else {
4912                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4913                    inner_depth.increment()?;
4914                }
4915                let val_ref = self.namespace_capabilities.get_or_insert_with(|| {
4916                    fidl::new_empty!(
4917                        fidl::encoding::UnboundedVector<
4918                            fidl_fuchsia_component_decl__common::Capability,
4919                        >,
4920                        D
4921                    )
4922                });
4923                fidl::decode!(
4924                    fidl::encoding::UnboundedVector<
4925                        fidl_fuchsia_component_decl__common::Capability,
4926                    >,
4927                    D,
4928                    val_ref,
4929                    decoder,
4930                    inner_offset,
4931                    inner_depth
4932                )?;
4933                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4934                {
4935                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4936                }
4937                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4938                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4939                }
4940            }
4941
4942            next_offset += envelope_size;
4943            _next_ordinal_to_read += 1;
4944            if next_offset >= end_offset {
4945                return Ok(());
4946            }
4947
4948            // Decode unknown envelopes for gaps in ordinals.
4949            while _next_ordinal_to_read < 5 {
4950                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4951                _next_ordinal_to_read += 1;
4952                next_offset += envelope_size;
4953            }
4954
4955            let next_out_of_line = decoder.next_out_of_line();
4956            let handles_before = decoder.remaining_handles();
4957            if let Some((inlined, num_bytes, num_handles)) =
4958                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4959            {
4960                let member_inline_size =
4961                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4962                if inlined != (member_inline_size <= 4) {
4963                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4964                }
4965                let inner_offset;
4966                let mut inner_depth = depth.clone();
4967                if inlined {
4968                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4969                    inner_offset = next_offset;
4970                } else {
4971                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4972                    inner_depth.increment()?;
4973                }
4974                let val_ref = self
4975                    .use_builtin_process_launcher
4976                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
4977                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4978                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4979                {
4980                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4981                }
4982                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4983                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4984                }
4985            }
4986
4987            next_offset += envelope_size;
4988            _next_ordinal_to_read += 1;
4989            if next_offset >= end_offset {
4990                return Ok(());
4991            }
4992
4993            // Decode unknown envelopes for gaps in ordinals.
4994            while _next_ordinal_to_read < 6 {
4995                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4996                _next_ordinal_to_read += 1;
4997                next_offset += envelope_size;
4998            }
4999
5000            let next_out_of_line = decoder.next_out_of_line();
5001            let handles_before = decoder.remaining_handles();
5002            if let Some((inlined, num_bytes, num_handles)) =
5003                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5004            {
5005                let member_inline_size =
5006                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5007                if inlined != (member_inline_size <= 4) {
5008                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5009                }
5010                let inner_offset;
5011                let mut inner_depth = depth.clone();
5012                if inlined {
5013                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5014                    inner_offset = next_offset;
5015                } else {
5016                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5017                    inner_depth.increment()?;
5018                }
5019                let val_ref =
5020                    self.maintain_utc_clock.get_or_insert_with(|| fidl::new_empty!(bool, D));
5021                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5022                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5023                {
5024                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5025                }
5026                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5027                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5028                }
5029            }
5030
5031            next_offset += envelope_size;
5032            _next_ordinal_to_read += 1;
5033            if next_offset >= end_offset {
5034                return Ok(());
5035            }
5036
5037            // Decode unknown envelopes for gaps in ordinals.
5038            while _next_ordinal_to_read < 7 {
5039                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5040                _next_ordinal_to_read += 1;
5041                next_offset += envelope_size;
5042            }
5043
5044            let next_out_of_line = decoder.next_out_of_line();
5045            let handles_before = decoder.remaining_handles();
5046            if let Some((inlined, num_bytes, num_handles)) =
5047                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5048            {
5049                let member_inline_size =
5050                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5051                if inlined != (member_inline_size <= 4) {
5052                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5053                }
5054                let inner_offset;
5055                let mut inner_depth = depth.clone();
5056                if inlined {
5057                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5058                    inner_offset = next_offset;
5059                } else {
5060                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5061                    inner_depth.increment()?;
5062                }
5063                let val_ref = self.num_threads.get_or_insert_with(|| fidl::new_empty!(u8, D));
5064                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
5065                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5066                {
5067                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5068                }
5069                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5070                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5071                }
5072            }
5073
5074            next_offset += envelope_size;
5075            _next_ordinal_to_read += 1;
5076            if next_offset >= end_offset {
5077                return Ok(());
5078            }
5079
5080            // Decode unknown envelopes for gaps in ordinals.
5081            while _next_ordinal_to_read < 10 {
5082                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5083                _next_ordinal_to_read += 1;
5084                next_offset += envelope_size;
5085            }
5086
5087            let next_out_of_line = decoder.next_out_of_line();
5088            let handles_before = decoder.remaining_handles();
5089            if let Some((inlined, num_bytes, num_handles)) =
5090                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5091            {
5092                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5093                if inlined != (member_inline_size <= 4) {
5094                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5095                }
5096                let inner_offset;
5097                let mut inner_depth = depth.clone();
5098                if inlined {
5099                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5100                    inner_offset = next_offset;
5101                } else {
5102                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5103                    inner_depth.increment()?;
5104                }
5105                let val_ref = self.root_component_url.get_or_insert_with(|| {
5106                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
5107                });
5108                fidl::decode!(
5109                    fidl::encoding::BoundedString<4096>,
5110                    D,
5111                    val_ref,
5112                    decoder,
5113                    inner_offset,
5114                    inner_depth
5115                )?;
5116                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5117                {
5118                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5119                }
5120                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5121                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5122                }
5123            }
5124
5125            next_offset += envelope_size;
5126            _next_ordinal_to_read += 1;
5127            if next_offset >= end_offset {
5128                return Ok(());
5129            }
5130
5131            // Decode unknown envelopes for gaps in ordinals.
5132            while _next_ordinal_to_read < 11 {
5133                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5134                _next_ordinal_to_read += 1;
5135                next_offset += envelope_size;
5136            }
5137
5138            let next_out_of_line = decoder.next_out_of_line();
5139            let handles_before = decoder.remaining_handles();
5140            if let Some((inlined, num_bytes, num_handles)) =
5141                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5142            {
5143                let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5144                if inlined != (member_inline_size <= 4) {
5145                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5146                }
5147                let inner_offset;
5148                let mut inner_depth = depth.clone();
5149                if inlined {
5150                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5151                    inner_offset = next_offset;
5152                } else {
5153                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5154                    inner_depth.increment()?;
5155                }
5156                let val_ref = self.component_id_index_path.get_or_insert_with(|| {
5157                    fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
5158                });
5159                fidl::decode!(
5160                    fidl::encoding::BoundedString<4095>,
5161                    D,
5162                    val_ref,
5163                    decoder,
5164                    inner_offset,
5165                    inner_depth
5166                )?;
5167                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5168                {
5169                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5170                }
5171                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5172                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5173                }
5174            }
5175
5176            next_offset += envelope_size;
5177            _next_ordinal_to_read += 1;
5178            if next_offset >= end_offset {
5179                return Ok(());
5180            }
5181
5182            // Decode unknown envelopes for gaps in ordinals.
5183            while _next_ordinal_to_read < 12 {
5184                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5185                _next_ordinal_to_read += 1;
5186                next_offset += envelope_size;
5187            }
5188
5189            let next_out_of_line = decoder.next_out_of_line();
5190            let handles_before = decoder.remaining_handles();
5191            if let Some((inlined, num_bytes, num_handles)) =
5192                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5193            {
5194                let member_inline_size =
5195                    <LogDestination as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5196                if inlined != (member_inline_size <= 4) {
5197                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5198                }
5199                let inner_offset;
5200                let mut inner_depth = depth.clone();
5201                if inlined {
5202                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5203                    inner_offset = next_offset;
5204                } else {
5205                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5206                    inner_depth.increment()?;
5207                }
5208                let val_ref =
5209                    self.log_destination.get_or_insert_with(|| fidl::new_empty!(LogDestination, D));
5210                fidl::decode!(LogDestination, D, val_ref, decoder, inner_offset, inner_depth)?;
5211                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5212                {
5213                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5214                }
5215                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5216                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5217                }
5218            }
5219
5220            next_offset += envelope_size;
5221            _next_ordinal_to_read += 1;
5222            if next_offset >= end_offset {
5223                return Ok(());
5224            }
5225
5226            // Decode unknown envelopes for gaps in ordinals.
5227            while _next_ordinal_to_read < 13 {
5228                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5229                _next_ordinal_to_read += 1;
5230                next_offset += envelope_size;
5231            }
5232
5233            let next_out_of_line = decoder.next_out_of_line();
5234            let handles_before = decoder.remaining_handles();
5235            if let Some((inlined, num_bytes, num_handles)) =
5236                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5237            {
5238                let member_inline_size =
5239                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5240                if inlined != (member_inline_size <= 4) {
5241                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5242                }
5243                let inner_offset;
5244                let mut inner_depth = depth.clone();
5245                if inlined {
5246                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5247                    inner_offset = next_offset;
5248                } else {
5249                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5250                    inner_depth.increment()?;
5251                }
5252                let val_ref = self.log_all_events.get_or_insert_with(|| fidl::new_empty!(bool, D));
5253                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5254                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5255                {
5256                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5257                }
5258                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5259                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5260                }
5261            }
5262
5263            next_offset += envelope_size;
5264            _next_ordinal_to_read += 1;
5265            if next_offset >= end_offset {
5266                return Ok(());
5267            }
5268
5269            // Decode unknown envelopes for gaps in ordinals.
5270            while _next_ordinal_to_read < 14 {
5271                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5272                _next_ordinal_to_read += 1;
5273                next_offset += envelope_size;
5274            }
5275
5276            let next_out_of_line = decoder.next_out_of_line();
5277            let handles_before = decoder.remaining_handles();
5278            if let Some((inlined, num_bytes, num_handles)) =
5279                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5280            {
5281                let member_inline_size =
5282                    <BuiltinBootResolver as fidl::encoding::TypeMarker>::inline_size(
5283                        decoder.context,
5284                    );
5285                if inlined != (member_inline_size <= 4) {
5286                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5287                }
5288                let inner_offset;
5289                let mut inner_depth = depth.clone();
5290                if inlined {
5291                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5292                    inner_offset = next_offset;
5293                } else {
5294                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5295                    inner_depth.increment()?;
5296                }
5297                let val_ref = self
5298                    .builtin_boot_resolver
5299                    .get_or_insert_with(|| fidl::new_empty!(BuiltinBootResolver, D));
5300                fidl::decode!(BuiltinBootResolver, D, val_ref, decoder, inner_offset, inner_depth)?;
5301                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5302                {
5303                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5304                }
5305                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5306                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5307                }
5308            }
5309
5310            next_offset += envelope_size;
5311            _next_ordinal_to_read += 1;
5312            if next_offset >= end_offset {
5313                return Ok(());
5314            }
5315
5316            // Decode unknown envelopes for gaps in ordinals.
5317            while _next_ordinal_to_read < 16 {
5318                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5319                _next_ordinal_to_read += 1;
5320                next_offset += envelope_size;
5321            }
5322
5323            let next_out_of_line = decoder.next_out_of_line();
5324            let handles_before = decoder.remaining_handles();
5325            if let Some((inlined, num_bytes, num_handles)) =
5326                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5327            {
5328                let member_inline_size =
5329                    <RealmBuilderResolverAndRunner as fidl::encoding::TypeMarker>::inline_size(
5330                        decoder.context,
5331                    );
5332                if inlined != (member_inline_size <= 4) {
5333                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5334                }
5335                let inner_offset;
5336                let mut inner_depth = depth.clone();
5337                if inlined {
5338                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5339                    inner_offset = next_offset;
5340                } else {
5341                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5342                    inner_depth.increment()?;
5343                }
5344                let val_ref = self
5345                    .realm_builder_resolver_and_runner
5346                    .get_or_insert_with(|| fidl::new_empty!(RealmBuilderResolverAndRunner, D));
5347                fidl::decode!(
5348                    RealmBuilderResolverAndRunner,
5349                    D,
5350                    val_ref,
5351                    decoder,
5352                    inner_offset,
5353                    inner_depth
5354                )?;
5355                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5356                {
5357                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5358                }
5359                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5360                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5361                }
5362            }
5363
5364            next_offset += envelope_size;
5365            _next_ordinal_to_read += 1;
5366            if next_offset >= end_offset {
5367                return Ok(());
5368            }
5369
5370            // Decode unknown envelopes for gaps in ordinals.
5371            while _next_ordinal_to_read < 17 {
5372                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5373                _next_ordinal_to_read += 1;
5374                next_offset += envelope_size;
5375            }
5376
5377            let next_out_of_line = decoder.next_out_of_line();
5378            let handles_before = decoder.remaining_handles();
5379            if let Some((inlined, num_bytes, num_handles)) =
5380                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5381            {
5382                let member_inline_size = <fidl::encoding::UnboundedVector<
5383                    fidl_fuchsia_component_decl__common::Capability,
5384                > as fidl::encoding::TypeMarker>::inline_size(
5385                    decoder.context
5386                );
5387                if inlined != (member_inline_size <= 4) {
5388                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5389                }
5390                let inner_offset;
5391                let mut inner_depth = depth.clone();
5392                if inlined {
5393                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5394                    inner_offset = next_offset;
5395                } else {
5396                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5397                    inner_depth.increment()?;
5398                }
5399                let val_ref = self.builtin_capabilities.get_or_insert_with(|| {
5400                    fidl::new_empty!(
5401                        fidl::encoding::UnboundedVector<
5402                            fidl_fuchsia_component_decl__common::Capability,
5403                        >,
5404                        D
5405                    )
5406                });
5407                fidl::decode!(
5408                    fidl::encoding::UnboundedVector<
5409                        fidl_fuchsia_component_decl__common::Capability,
5410                    >,
5411                    D,
5412                    val_ref,
5413                    decoder,
5414                    inner_offset,
5415                    inner_depth
5416                )?;
5417                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5418                {
5419                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5420                }
5421                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5422                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5423                }
5424            }
5425
5426            next_offset += envelope_size;
5427            _next_ordinal_to_read += 1;
5428            if next_offset >= end_offset {
5429                return Ok(());
5430            }
5431
5432            // Decode unknown envelopes for gaps in ordinals.
5433            while _next_ordinal_to_read < 18 {
5434                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5435                _next_ordinal_to_read += 1;
5436                next_offset += envelope_size;
5437            }
5438
5439            let next_out_of_line = decoder.next_out_of_line();
5440            let handles_before = decoder.remaining_handles();
5441            if let Some((inlined, num_bytes, num_handles)) =
5442                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5443            {
5444                let member_inline_size =
5445                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5446                if inlined != (member_inline_size <= 4) {
5447                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5448                }
5449                let inner_offset;
5450                let mut inner_depth = depth.clone();
5451                if inlined {
5452                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5453                    inner_offset = next_offset;
5454                } else {
5455                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5456                    inner_depth.increment()?;
5457                }
5458                let val_ref =
5459                    self.enable_introspection.get_or_insert_with(|| fidl::new_empty!(bool, D));
5460                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5461                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5462                {
5463                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5464                }
5465                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5466                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5467                }
5468            }
5469
5470            next_offset += envelope_size;
5471            _next_ordinal_to_read += 1;
5472            if next_offset >= end_offset {
5473                return Ok(());
5474            }
5475
5476            // Decode unknown envelopes for gaps in ordinals.
5477            while _next_ordinal_to_read < 19 {
5478                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5479                _next_ordinal_to_read += 1;
5480                next_offset += envelope_size;
5481            }
5482
5483            let next_out_of_line = decoder.next_out_of_line();
5484            let handles_before = decoder.remaining_handles();
5485            if let Some((inlined, num_bytes, num_handles)) =
5486                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5487            {
5488                let member_inline_size =
5489                    <AbiRevisionPolicy as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5490                if inlined != (member_inline_size <= 4) {
5491                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5492                }
5493                let inner_offset;
5494                let mut inner_depth = depth.clone();
5495                if inlined {
5496                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5497                    inner_offset = next_offset;
5498                } else {
5499                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5500                    inner_depth.increment()?;
5501                }
5502                let val_ref = self
5503                    .abi_revision_policy
5504                    .get_or_insert_with(|| fidl::new_empty!(AbiRevisionPolicy, D));
5505                fidl::decode!(AbiRevisionPolicy, D, val_ref, decoder, inner_offset, inner_depth)?;
5506                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5507                {
5508                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5509                }
5510                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5511                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5512                }
5513            }
5514
5515            next_offset += envelope_size;
5516            _next_ordinal_to_read += 1;
5517            if next_offset >= end_offset {
5518                return Ok(());
5519            }
5520
5521            // Decode unknown envelopes for gaps in ordinals.
5522            while _next_ordinal_to_read < 20 {
5523                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5524                _next_ordinal_to_read += 1;
5525                next_offset += envelope_size;
5526            }
5527
5528            let next_out_of_line = decoder.next_out_of_line();
5529            let handles_before = decoder.remaining_handles();
5530            if let Some((inlined, num_bytes, num_handles)) =
5531                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5532            {
5533                let member_inline_size =
5534                    <VmexSource as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5535                if inlined != (member_inline_size <= 4) {
5536                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5537                }
5538                let inner_offset;
5539                let mut inner_depth = depth.clone();
5540                if inlined {
5541                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5542                    inner_offset = next_offset;
5543                } else {
5544                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5545                    inner_depth.increment()?;
5546                }
5547                let val_ref =
5548                    self.vmex_source.get_or_insert_with(|| fidl::new_empty!(VmexSource, D));
5549                fidl::decode!(VmexSource, D, val_ref, decoder, inner_offset, inner_depth)?;
5550                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5551                {
5552                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5553                }
5554                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5555                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5556                }
5557            }
5558
5559            next_offset += envelope_size;
5560            _next_ordinal_to_read += 1;
5561            if next_offset >= end_offset {
5562                return Ok(());
5563            }
5564
5565            // Decode unknown envelopes for gaps in ordinals.
5566            while _next_ordinal_to_read < 21 {
5567                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5568                _next_ordinal_to_read += 1;
5569                next_offset += envelope_size;
5570            }
5571
5572            let next_out_of_line = decoder.next_out_of_line();
5573            let handles_before = decoder.remaining_handles();
5574            if let Some((inlined, num_bytes, num_handles)) =
5575                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5576            {
5577                let member_inline_size =
5578                    <HealthCheck as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5579                if inlined != (member_inline_size <= 4) {
5580                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5581                }
5582                let inner_offset;
5583                let mut inner_depth = depth.clone();
5584                if inlined {
5585                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5586                    inner_offset = next_offset;
5587                } else {
5588                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5589                    inner_depth.increment()?;
5590                }
5591                let val_ref =
5592                    self.health_check.get_or_insert_with(|| fidl::new_empty!(HealthCheck, D));
5593                fidl::decode!(HealthCheck, D, val_ref, decoder, inner_offset, inner_depth)?;
5594                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5595                {
5596                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5597                }
5598                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5599                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5600                }
5601            }
5602
5603            next_offset += envelope_size;
5604            _next_ordinal_to_read += 1;
5605            if next_offset >= end_offset {
5606                return Ok(());
5607            }
5608
5609            // Decode unknown envelopes for gaps in ordinals.
5610            while _next_ordinal_to_read < 22 {
5611                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5612                _next_ordinal_to_read += 1;
5613                next_offset += envelope_size;
5614            }
5615
5616            let next_out_of_line = decoder.next_out_of_line();
5617            let handles_before = decoder.remaining_handles();
5618            if let Some((inlined, num_bytes, num_handles)) =
5619                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5620            {
5621                let member_inline_size =
5622                    <TraceProvider as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5623                if inlined != (member_inline_size <= 4) {
5624                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5625                }
5626                let inner_offset;
5627                let mut inner_depth = depth.clone();
5628                if inlined {
5629                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5630                    inner_offset = next_offset;
5631                } else {
5632                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5633                    inner_depth.increment()?;
5634                }
5635                let val_ref =
5636                    self.trace_provider.get_or_insert_with(|| fidl::new_empty!(TraceProvider, D));
5637                fidl::decode!(TraceProvider, D, val_ref, decoder, inner_offset, inner_depth)?;
5638                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5639                {
5640                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5641                }
5642                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5643                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5644                }
5645            }
5646
5647            next_offset += envelope_size;
5648
5649            // Decode the remaining unknown envelopes.
5650            while next_offset < end_offset {
5651                _next_ordinal_to_read += 1;
5652                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5653                next_offset += envelope_size;
5654            }
5655
5656            Ok(())
5657        }
5658    }
5659
5660    impl DebugRegistrationAllowlistEntry {
5661        #[inline(always)]
5662        fn max_ordinal_present(&self) -> u64 {
5663            if let Some(_) = self.environment_name {
5664                return 4;
5665            }
5666            if let Some(_) = self.moniker {
5667                return 3;
5668            }
5669            if let Some(_) = self.debug {
5670                return 2;
5671            }
5672            if let Some(_) = self.name {
5673                return 1;
5674            }
5675            0
5676        }
5677    }
5678
5679    impl fidl::encoding::ValueTypeMarker for DebugRegistrationAllowlistEntry {
5680        type Borrowed<'a> = &'a Self;
5681        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5682            value
5683        }
5684    }
5685
5686    unsafe impl fidl::encoding::TypeMarker for DebugRegistrationAllowlistEntry {
5687        type Owned = Self;
5688
5689        #[inline(always)]
5690        fn inline_align(_context: fidl::encoding::Context) -> usize {
5691            8
5692        }
5693
5694        #[inline(always)]
5695        fn inline_size(_context: fidl::encoding::Context) -> usize {
5696            16
5697        }
5698    }
5699
5700    unsafe impl<D: fidl::encoding::ResourceDialect>
5701        fidl::encoding::Encode<DebugRegistrationAllowlistEntry, D>
5702        for &DebugRegistrationAllowlistEntry
5703    {
5704        unsafe fn encode(
5705            self,
5706            encoder: &mut fidl::encoding::Encoder<'_, D>,
5707            offset: usize,
5708            mut depth: fidl::encoding::Depth,
5709        ) -> fidl::Result<()> {
5710            encoder.debug_check_bounds::<DebugRegistrationAllowlistEntry>(offset);
5711            // Vector header
5712            let max_ordinal: u64 = self.max_ordinal_present();
5713            encoder.write_num(max_ordinal, offset);
5714            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5715            // Calling encoder.out_of_line_offset(0) is not allowed.
5716            if max_ordinal == 0 {
5717                return Ok(());
5718            }
5719            depth.increment()?;
5720            let envelope_size = 8;
5721            let bytes_len = max_ordinal as usize * envelope_size;
5722            #[allow(unused_variables)]
5723            let offset = encoder.out_of_line_offset(bytes_len);
5724            let mut _prev_end_offset: usize = 0;
5725            if 1 > max_ordinal {
5726                return Ok(());
5727            }
5728
5729            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5730            // are envelope_size bytes.
5731            let cur_offset: usize = (1 - 1) * envelope_size;
5732
5733            // Zero reserved fields.
5734            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5735
5736            // Safety:
5737            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5738            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5739            //   envelope_size bytes, there is always sufficient room.
5740            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
5741                self.name.as_ref().map(
5742                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
5743                ),
5744                encoder,
5745                offset + cur_offset,
5746                depth,
5747            )?;
5748
5749            _prev_end_offset = cur_offset + envelope_size;
5750            if 2 > max_ordinal {
5751                return Ok(());
5752            }
5753
5754            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5755            // are envelope_size bytes.
5756            let cur_offset: usize = (2 - 1) * envelope_size;
5757
5758            // Zero reserved fields.
5759            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5760
5761            // Safety:
5762            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5763            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5764            //   envelope_size bytes, there is always sufficient room.
5765            fidl::encoding::encode_in_envelope_optional::<AllowlistedDebugRegistration, D>(
5766                self.debug
5767                    .as_ref()
5768                    .map(<AllowlistedDebugRegistration as fidl::encoding::ValueTypeMarker>::borrow),
5769                encoder,
5770                offset + cur_offset,
5771                depth,
5772            )?;
5773
5774            _prev_end_offset = cur_offset + envelope_size;
5775            if 3 > max_ordinal {
5776                return Ok(());
5777            }
5778
5779            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5780            // are envelope_size bytes.
5781            let cur_offset: usize = (3 - 1) * envelope_size;
5782
5783            // Zero reserved fields.
5784            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5785
5786            // Safety:
5787            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5788            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5789            //   envelope_size bytes, there is always sufficient room.
5790            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
5791            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
5792            encoder, offset + cur_offset, depth
5793        )?;
5794
5795            _prev_end_offset = cur_offset + envelope_size;
5796            if 4 > max_ordinal {
5797                return Ok(());
5798            }
5799
5800            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5801            // are envelope_size bytes.
5802            let cur_offset: usize = (4 - 1) * envelope_size;
5803
5804            // Zero reserved fields.
5805            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5806
5807            // Safety:
5808            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5809            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5810            //   envelope_size bytes, there is always sufficient room.
5811            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
5812                self.environment_name.as_ref().map(
5813                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
5814                ),
5815                encoder,
5816                offset + cur_offset,
5817                depth,
5818            )?;
5819
5820            _prev_end_offset = cur_offset + envelope_size;
5821
5822            Ok(())
5823        }
5824    }
5825
5826    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5827        for DebugRegistrationAllowlistEntry
5828    {
5829        #[inline(always)]
5830        fn new_empty() -> Self {
5831            Self::default()
5832        }
5833
5834        unsafe fn decode(
5835            &mut self,
5836            decoder: &mut fidl::encoding::Decoder<'_, D>,
5837            offset: usize,
5838            mut depth: fidl::encoding::Depth,
5839        ) -> fidl::Result<()> {
5840            decoder.debug_check_bounds::<Self>(offset);
5841            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5842                None => return Err(fidl::Error::NotNullable),
5843                Some(len) => len,
5844            };
5845            // Calling decoder.out_of_line_offset(0) is not allowed.
5846            if len == 0 {
5847                return Ok(());
5848            };
5849            depth.increment()?;
5850            let envelope_size = 8;
5851            let bytes_len = len * envelope_size;
5852            let offset = decoder.out_of_line_offset(bytes_len)?;
5853            // Decode the envelope for each type.
5854            let mut _next_ordinal_to_read = 0;
5855            let mut next_offset = offset;
5856            let end_offset = offset + bytes_len;
5857            _next_ordinal_to_read += 1;
5858            if next_offset >= end_offset {
5859                return Ok(());
5860            }
5861
5862            // Decode unknown envelopes for gaps in ordinals.
5863            while _next_ordinal_to_read < 1 {
5864                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5865                _next_ordinal_to_read += 1;
5866                next_offset += envelope_size;
5867            }
5868
5869            let next_out_of_line = decoder.next_out_of_line();
5870            let handles_before = decoder.remaining_handles();
5871            if let Some((inlined, num_bytes, num_handles)) =
5872                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5873            {
5874                let member_inline_size =
5875                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
5876                        decoder.context,
5877                    );
5878                if inlined != (member_inline_size <= 4) {
5879                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5880                }
5881                let inner_offset;
5882                let mut inner_depth = depth.clone();
5883                if inlined {
5884                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5885                    inner_offset = next_offset;
5886                } else {
5887                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5888                    inner_depth.increment()?;
5889                }
5890                let val_ref = self
5891                    .name
5892                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
5893                fidl::decode!(
5894                    fidl::encoding::BoundedString<255>,
5895                    D,
5896                    val_ref,
5897                    decoder,
5898                    inner_offset,
5899                    inner_depth
5900                )?;
5901                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5902                {
5903                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5904                }
5905                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5906                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5907                }
5908            }
5909
5910            next_offset += envelope_size;
5911            _next_ordinal_to_read += 1;
5912            if next_offset >= end_offset {
5913                return Ok(());
5914            }
5915
5916            // Decode unknown envelopes for gaps in ordinals.
5917            while _next_ordinal_to_read < 2 {
5918                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5919                _next_ordinal_to_read += 1;
5920                next_offset += envelope_size;
5921            }
5922
5923            let next_out_of_line = decoder.next_out_of_line();
5924            let handles_before = decoder.remaining_handles();
5925            if let Some((inlined, num_bytes, num_handles)) =
5926                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5927            {
5928                let member_inline_size =
5929                    <AllowlistedDebugRegistration as fidl::encoding::TypeMarker>::inline_size(
5930                        decoder.context,
5931                    );
5932                if inlined != (member_inline_size <= 4) {
5933                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5934                }
5935                let inner_offset;
5936                let mut inner_depth = depth.clone();
5937                if inlined {
5938                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5939                    inner_offset = next_offset;
5940                } else {
5941                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5942                    inner_depth.increment()?;
5943                }
5944                let val_ref = self
5945                    .debug
5946                    .get_or_insert_with(|| fidl::new_empty!(AllowlistedDebugRegistration, D));
5947                fidl::decode!(
5948                    AllowlistedDebugRegistration,
5949                    D,
5950                    val_ref,
5951                    decoder,
5952                    inner_offset,
5953                    inner_depth
5954                )?;
5955                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5956                {
5957                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5958                }
5959                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5960                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5961                }
5962            }
5963
5964            next_offset += envelope_size;
5965            _next_ordinal_to_read += 1;
5966            if next_offset >= end_offset {
5967                return Ok(());
5968            }
5969
5970            // Decode unknown envelopes for gaps in ordinals.
5971            while _next_ordinal_to_read < 3 {
5972                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5973                _next_ordinal_to_read += 1;
5974                next_offset += envelope_size;
5975            }
5976
5977            let next_out_of_line = decoder.next_out_of_line();
5978            let handles_before = decoder.remaining_handles();
5979            if let Some((inlined, num_bytes, num_handles)) =
5980                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5981            {
5982                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5983                if inlined != (member_inline_size <= 4) {
5984                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5985                }
5986                let inner_offset;
5987                let mut inner_depth = depth.clone();
5988                if inlined {
5989                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5990                    inner_offset = next_offset;
5991                } else {
5992                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5993                    inner_depth.increment()?;
5994                }
5995                let val_ref = self.moniker.get_or_insert_with(|| {
5996                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
5997                });
5998                fidl::decode!(
5999                    fidl::encoding::BoundedString<4096>,
6000                    D,
6001                    val_ref,
6002                    decoder,
6003                    inner_offset,
6004                    inner_depth
6005                )?;
6006                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6007                {
6008                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6009                }
6010                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6011                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6012                }
6013            }
6014
6015            next_offset += envelope_size;
6016            _next_ordinal_to_read += 1;
6017            if next_offset >= end_offset {
6018                return Ok(());
6019            }
6020
6021            // Decode unknown envelopes for gaps in ordinals.
6022            while _next_ordinal_to_read < 4 {
6023                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6024                _next_ordinal_to_read += 1;
6025                next_offset += envelope_size;
6026            }
6027
6028            let next_out_of_line = decoder.next_out_of_line();
6029            let handles_before = decoder.remaining_handles();
6030            if let Some((inlined, num_bytes, num_handles)) =
6031                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6032            {
6033                let member_inline_size =
6034                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6035                        decoder.context,
6036                    );
6037                if inlined != (member_inline_size <= 4) {
6038                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6039                }
6040                let inner_offset;
6041                let mut inner_depth = depth.clone();
6042                if inlined {
6043                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6044                    inner_offset = next_offset;
6045                } else {
6046                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6047                    inner_depth.increment()?;
6048                }
6049                let val_ref = self
6050                    .environment_name
6051                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6052                fidl::decode!(
6053                    fidl::encoding::BoundedString<255>,
6054                    D,
6055                    val_ref,
6056                    decoder,
6057                    inner_offset,
6058                    inner_depth
6059                )?;
6060                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6061                {
6062                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6063                }
6064                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6065                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6066                }
6067            }
6068
6069            next_offset += envelope_size;
6070
6071            // Decode the remaining unknown envelopes.
6072            while next_offset < end_offset {
6073                _next_ordinal_to_read += 1;
6074                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6075                next_offset += envelope_size;
6076            }
6077
6078            Ok(())
6079        }
6080    }
6081
6082    impl DebugRegistrationPolicyAllowlists {
6083        #[inline(always)]
6084        fn max_ordinal_present(&self) -> u64 {
6085            if let Some(_) = self.allowlist {
6086                return 1;
6087            }
6088            0
6089        }
6090    }
6091
6092    impl fidl::encoding::ValueTypeMarker for DebugRegistrationPolicyAllowlists {
6093        type Borrowed<'a> = &'a Self;
6094        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6095            value
6096        }
6097    }
6098
6099    unsafe impl fidl::encoding::TypeMarker for DebugRegistrationPolicyAllowlists {
6100        type Owned = Self;
6101
6102        #[inline(always)]
6103        fn inline_align(_context: fidl::encoding::Context) -> usize {
6104            8
6105        }
6106
6107        #[inline(always)]
6108        fn inline_size(_context: fidl::encoding::Context) -> usize {
6109            16
6110        }
6111    }
6112
6113    unsafe impl<D: fidl::encoding::ResourceDialect>
6114        fidl::encoding::Encode<DebugRegistrationPolicyAllowlists, D>
6115        for &DebugRegistrationPolicyAllowlists
6116    {
6117        unsafe fn encode(
6118            self,
6119            encoder: &mut fidl::encoding::Encoder<'_, D>,
6120            offset: usize,
6121            mut depth: fidl::encoding::Depth,
6122        ) -> fidl::Result<()> {
6123            encoder.debug_check_bounds::<DebugRegistrationPolicyAllowlists>(offset);
6124            // Vector header
6125            let max_ordinal: u64 = self.max_ordinal_present();
6126            encoder.write_num(max_ordinal, offset);
6127            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6128            // Calling encoder.out_of_line_offset(0) is not allowed.
6129            if max_ordinal == 0 {
6130                return Ok(());
6131            }
6132            depth.increment()?;
6133            let envelope_size = 8;
6134            let bytes_len = max_ordinal as usize * envelope_size;
6135            #[allow(unused_variables)]
6136            let offset = encoder.out_of_line_offset(bytes_len);
6137            let mut _prev_end_offset: usize = 0;
6138            if 1 > max_ordinal {
6139                return Ok(());
6140            }
6141
6142            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6143            // are envelope_size bytes.
6144            let cur_offset: usize = (1 - 1) * envelope_size;
6145
6146            // Zero reserved fields.
6147            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6148
6149            // Safety:
6150            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6151            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6152            //   envelope_size bytes, there is always sufficient room.
6153            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128>, D>(
6154            self.allowlist.as_ref().map(<fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128> as fidl::encoding::ValueTypeMarker>::borrow),
6155            encoder, offset + cur_offset, depth
6156        )?;
6157
6158            _prev_end_offset = cur_offset + envelope_size;
6159
6160            Ok(())
6161        }
6162    }
6163
6164    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6165        for DebugRegistrationPolicyAllowlists
6166    {
6167        #[inline(always)]
6168        fn new_empty() -> Self {
6169            Self::default()
6170        }
6171
6172        unsafe fn decode(
6173            &mut self,
6174            decoder: &mut fidl::encoding::Decoder<'_, D>,
6175            offset: usize,
6176            mut depth: fidl::encoding::Depth,
6177        ) -> fidl::Result<()> {
6178            decoder.debug_check_bounds::<Self>(offset);
6179            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6180                None => return Err(fidl::Error::NotNullable),
6181                Some(len) => len,
6182            };
6183            // Calling decoder.out_of_line_offset(0) is not allowed.
6184            if len == 0 {
6185                return Ok(());
6186            };
6187            depth.increment()?;
6188            let envelope_size = 8;
6189            let bytes_len = len * envelope_size;
6190            let offset = decoder.out_of_line_offset(bytes_len)?;
6191            // Decode the envelope for each type.
6192            let mut _next_ordinal_to_read = 0;
6193            let mut next_offset = offset;
6194            let end_offset = offset + bytes_len;
6195            _next_ordinal_to_read += 1;
6196            if next_offset >= end_offset {
6197                return Ok(());
6198            }
6199
6200            // Decode unknown envelopes for gaps in ordinals.
6201            while _next_ordinal_to_read < 1 {
6202                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6203                _next_ordinal_to_read += 1;
6204                next_offset += envelope_size;
6205            }
6206
6207            let next_out_of_line = decoder.next_out_of_line();
6208            let handles_before = decoder.remaining_handles();
6209            if let Some((inlined, num_bytes, num_handles)) =
6210                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6211            {
6212                let member_inline_size = <fidl::encoding::Vector<
6213                    DebugRegistrationAllowlistEntry,
6214                    128,
6215                > as fidl::encoding::TypeMarker>::inline_size(
6216                    decoder.context
6217                );
6218                if inlined != (member_inline_size <= 4) {
6219                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6220                }
6221                let inner_offset;
6222                let mut inner_depth = depth.clone();
6223                if inlined {
6224                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6225                    inner_offset = next_offset;
6226                } else {
6227                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6228                    inner_depth.increment()?;
6229                }
6230                let val_ref =
6231                self.allowlist.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128>, D));
6232                fidl::decode!(fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128>, D, val_ref, decoder, inner_offset, inner_depth)?;
6233                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6234                {
6235                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6236                }
6237                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6238                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6239                }
6240            }
6241
6242            next_offset += envelope_size;
6243
6244            // Decode the remaining unknown envelopes.
6245            while next_offset < end_offset {
6246                _next_ordinal_to_read += 1;
6247                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6248                next_offset += envelope_size;
6249            }
6250
6251            Ok(())
6252        }
6253    }
6254
6255    impl Environment {
6256        #[inline(always)]
6257        fn max_ordinal_present(&self) -> u64 {
6258            if let Some(_) = self.moniker {
6259                return 2;
6260            }
6261            if let Some(_) = self.capability {
6262                return 1;
6263            }
6264            0
6265        }
6266    }
6267
6268    impl fidl::encoding::ValueTypeMarker for Environment {
6269        type Borrowed<'a> = &'a Self;
6270        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6271            value
6272        }
6273    }
6274
6275    unsafe impl fidl::encoding::TypeMarker for Environment {
6276        type Owned = Self;
6277
6278        #[inline(always)]
6279        fn inline_align(_context: fidl::encoding::Context) -> usize {
6280            8
6281        }
6282
6283        #[inline(always)]
6284        fn inline_size(_context: fidl::encoding::Context) -> usize {
6285            16
6286        }
6287    }
6288
6289    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Environment, D>
6290        for &Environment
6291    {
6292        unsafe fn encode(
6293            self,
6294            encoder: &mut fidl::encoding::Encoder<'_, D>,
6295            offset: usize,
6296            mut depth: fidl::encoding::Depth,
6297        ) -> fidl::Result<()> {
6298            encoder.debug_check_bounds::<Environment>(offset);
6299            // Vector header
6300            let max_ordinal: u64 = self.max_ordinal_present();
6301            encoder.write_num(max_ordinal, offset);
6302            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6303            // Calling encoder.out_of_line_offset(0) is not allowed.
6304            if max_ordinal == 0 {
6305                return Ok(());
6306            }
6307            depth.increment()?;
6308            let envelope_size = 8;
6309            let bytes_len = max_ordinal as usize * envelope_size;
6310            #[allow(unused_variables)]
6311            let offset = encoder.out_of_line_offset(bytes_len);
6312            let mut _prev_end_offset: usize = 0;
6313            if 1 > max_ordinal {
6314                return Ok(());
6315            }
6316
6317            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6318            // are envelope_size bytes.
6319            let cur_offset: usize = (1 - 1) * envelope_size;
6320
6321            // Zero reserved fields.
6322            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6323
6324            // Safety:
6325            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6326            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6327            //   envelope_size bytes, there is always sufficient room.
6328            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
6329                self.capability
6330                    .as_ref()
6331                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
6332                encoder,
6333                offset + cur_offset,
6334                depth,
6335            )?;
6336
6337            _prev_end_offset = cur_offset + envelope_size;
6338            if 2 > max_ordinal {
6339                return Ok(());
6340            }
6341
6342            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6343            // are envelope_size bytes.
6344            let cur_offset: usize = (2 - 1) * envelope_size;
6345
6346            // Zero reserved fields.
6347            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6348
6349            // Safety:
6350            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6351            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6352            //   envelope_size bytes, there is always sufficient room.
6353            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6354            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6355            encoder, offset + cur_offset, depth
6356        )?;
6357
6358            _prev_end_offset = cur_offset + envelope_size;
6359
6360            Ok(())
6361        }
6362    }
6363
6364    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Environment {
6365        #[inline(always)]
6366        fn new_empty() -> Self {
6367            Self::default()
6368        }
6369
6370        unsafe fn decode(
6371            &mut self,
6372            decoder: &mut fidl::encoding::Decoder<'_, D>,
6373            offset: usize,
6374            mut depth: fidl::encoding::Depth,
6375        ) -> fidl::Result<()> {
6376            decoder.debug_check_bounds::<Self>(offset);
6377            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6378                None => return Err(fidl::Error::NotNullable),
6379                Some(len) => len,
6380            };
6381            // Calling decoder.out_of_line_offset(0) is not allowed.
6382            if len == 0 {
6383                return Ok(());
6384            };
6385            depth.increment()?;
6386            let envelope_size = 8;
6387            let bytes_len = len * envelope_size;
6388            let offset = decoder.out_of_line_offset(bytes_len)?;
6389            // Decode the envelope for each type.
6390            let mut _next_ordinal_to_read = 0;
6391            let mut next_offset = offset;
6392            let end_offset = offset + bytes_len;
6393            _next_ordinal_to_read += 1;
6394            if next_offset >= end_offset {
6395                return Ok(());
6396            }
6397
6398            // Decode unknown envelopes for gaps in ordinals.
6399            while _next_ordinal_to_read < 1 {
6400                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6401                _next_ordinal_to_read += 1;
6402                next_offset += envelope_size;
6403            }
6404
6405            let next_out_of_line = decoder.next_out_of_line();
6406            let handles_before = decoder.remaining_handles();
6407            if let Some((inlined, num_bytes, num_handles)) =
6408                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6409            {
6410                let member_inline_size =
6411                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
6412                        decoder.context,
6413                    );
6414                if inlined != (member_inline_size <= 4) {
6415                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6416                }
6417                let inner_offset;
6418                let mut inner_depth = depth.clone();
6419                if inlined {
6420                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6421                    inner_offset = next_offset;
6422                } else {
6423                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6424                    inner_depth.increment()?;
6425                }
6426                let val_ref =
6427                    self.capability.get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
6428                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
6429                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6430                {
6431                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6432                }
6433                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6434                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6435                }
6436            }
6437
6438            next_offset += envelope_size;
6439            _next_ordinal_to_read += 1;
6440            if next_offset >= end_offset {
6441                return Ok(());
6442            }
6443
6444            // Decode unknown envelopes for gaps in ordinals.
6445            while _next_ordinal_to_read < 2 {
6446                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6447                _next_ordinal_to_read += 1;
6448                next_offset += envelope_size;
6449            }
6450
6451            let next_out_of_line = decoder.next_out_of_line();
6452            let handles_before = decoder.remaining_handles();
6453            if let Some((inlined, num_bytes, num_handles)) =
6454                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6455            {
6456                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6457                if inlined != (member_inline_size <= 4) {
6458                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6459                }
6460                let inner_offset;
6461                let mut inner_depth = depth.clone();
6462                if inlined {
6463                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6464                    inner_offset = next_offset;
6465                } else {
6466                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6467                    inner_depth.increment()?;
6468                }
6469                let val_ref = self.moniker.get_or_insert_with(|| {
6470                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
6471                });
6472                fidl::decode!(
6473                    fidl::encoding::BoundedString<4096>,
6474                    D,
6475                    val_ref,
6476                    decoder,
6477                    inner_offset,
6478                    inner_depth
6479                )?;
6480                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6481                {
6482                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6483                }
6484                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6485                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6486                }
6487            }
6488
6489            next_offset += envelope_size;
6490
6491            // Decode the remaining unknown envelopes.
6492            while next_offset < end_offset {
6493                _next_ordinal_to_read += 1;
6494                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6495                next_offset += envelope_size;
6496            }
6497
6498            Ok(())
6499        }
6500    }
6501
6502    impl EnvironmentSource {
6503        #[inline(always)]
6504        fn max_ordinal_present(&self) -> u64 {
6505            if let Some(_) = self.source {
6506                return 2;
6507            }
6508            if let Some(_) = self.source_name {
6509                return 1;
6510            }
6511            0
6512        }
6513    }
6514
6515    impl fidl::encoding::ValueTypeMarker for EnvironmentSource {
6516        type Borrowed<'a> = &'a Self;
6517        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6518            value
6519        }
6520    }
6521
6522    unsafe impl fidl::encoding::TypeMarker for EnvironmentSource {
6523        type Owned = Self;
6524
6525        #[inline(always)]
6526        fn inline_align(_context: fidl::encoding::Context) -> usize {
6527            8
6528        }
6529
6530        #[inline(always)]
6531        fn inline_size(_context: fidl::encoding::Context) -> usize {
6532            16
6533        }
6534    }
6535
6536    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnvironmentSource, D>
6537        for &EnvironmentSource
6538    {
6539        unsafe fn encode(
6540            self,
6541            encoder: &mut fidl::encoding::Encoder<'_, D>,
6542            offset: usize,
6543            mut depth: fidl::encoding::Depth,
6544        ) -> fidl::Result<()> {
6545            encoder.debug_check_bounds::<EnvironmentSource>(offset);
6546            // Vector header
6547            let max_ordinal: u64 = self.max_ordinal_present();
6548            encoder.write_num(max_ordinal, offset);
6549            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6550            // Calling encoder.out_of_line_offset(0) is not allowed.
6551            if max_ordinal == 0 {
6552                return Ok(());
6553            }
6554            depth.increment()?;
6555            let envelope_size = 8;
6556            let bytes_len = max_ordinal as usize * envelope_size;
6557            #[allow(unused_variables)]
6558            let offset = encoder.out_of_line_offset(bytes_len);
6559            let mut _prev_end_offset: usize = 0;
6560            if 1 > max_ordinal {
6561                return Ok(());
6562            }
6563
6564            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6565            // are envelope_size bytes.
6566            let cur_offset: usize = (1 - 1) * envelope_size;
6567
6568            // Zero reserved fields.
6569            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6570
6571            // Safety:
6572            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6573            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6574            //   envelope_size bytes, there is always sufficient room.
6575            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
6576            self.source_name.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
6577            encoder, offset + cur_offset, depth
6578        )?;
6579
6580            _prev_end_offset = cur_offset + envelope_size;
6581            if 2 > max_ordinal {
6582                return Ok(());
6583            }
6584
6585            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6586            // are envelope_size bytes.
6587            let cur_offset: usize = (2 - 1) * envelope_size;
6588
6589            // Zero reserved fields.
6590            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6591
6592            // Safety:
6593            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6594            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6595            //   envelope_size bytes, there is always sufficient room.
6596            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Ref, D>(
6597            self.source.as_ref().map(<fidl_fuchsia_component_decl__common::Ref as fidl::encoding::ValueTypeMarker>::borrow),
6598            encoder, offset + cur_offset, depth
6599        )?;
6600
6601            _prev_end_offset = cur_offset + envelope_size;
6602
6603            Ok(())
6604        }
6605    }
6606
6607    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnvironmentSource {
6608        #[inline(always)]
6609        fn new_empty() -> Self {
6610            Self::default()
6611        }
6612
6613        unsafe fn decode(
6614            &mut self,
6615            decoder: &mut fidl::encoding::Decoder<'_, D>,
6616            offset: usize,
6617            mut depth: fidl::encoding::Depth,
6618        ) -> fidl::Result<()> {
6619            decoder.debug_check_bounds::<Self>(offset);
6620            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6621                None => return Err(fidl::Error::NotNullable),
6622                Some(len) => len,
6623            };
6624            // Calling decoder.out_of_line_offset(0) is not allowed.
6625            if len == 0 {
6626                return Ok(());
6627            };
6628            depth.increment()?;
6629            let envelope_size = 8;
6630            let bytes_len = len * envelope_size;
6631            let offset = decoder.out_of_line_offset(bytes_len)?;
6632            // Decode the envelope for each type.
6633            let mut _next_ordinal_to_read = 0;
6634            let mut next_offset = offset;
6635            let end_offset = offset + bytes_len;
6636            _next_ordinal_to_read += 1;
6637            if next_offset >= end_offset {
6638                return Ok(());
6639            }
6640
6641            // Decode unknown envelopes for gaps in ordinals.
6642            while _next_ordinal_to_read < 1 {
6643                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6644                _next_ordinal_to_read += 1;
6645                next_offset += envelope_size;
6646            }
6647
6648            let next_out_of_line = decoder.next_out_of_line();
6649            let handles_before = decoder.remaining_handles();
6650            if let Some((inlined, num_bytes, num_handles)) =
6651                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6652            {
6653                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6654                if inlined != (member_inline_size <= 4) {
6655                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6656                }
6657                let inner_offset;
6658                let mut inner_depth = depth.clone();
6659                if inlined {
6660                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6661                    inner_offset = next_offset;
6662                } else {
6663                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6664                    inner_depth.increment()?;
6665                }
6666                let val_ref = self.source_name.get_or_insert_with(|| {
6667                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
6668                });
6669                fidl::decode!(
6670                    fidl::encoding::BoundedString<1024>,
6671                    D,
6672                    val_ref,
6673                    decoder,
6674                    inner_offset,
6675                    inner_depth
6676                )?;
6677                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6678                {
6679                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6680                }
6681                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6682                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6683                }
6684            }
6685
6686            next_offset += envelope_size;
6687            _next_ordinal_to_read += 1;
6688            if next_offset >= end_offset {
6689                return Ok(());
6690            }
6691
6692            // Decode unknown envelopes for gaps in ordinals.
6693            while _next_ordinal_to_read < 2 {
6694                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6695                _next_ordinal_to_read += 1;
6696                next_offset += envelope_size;
6697            }
6698
6699            let next_out_of_line = decoder.next_out_of_line();
6700            let handles_before = decoder.remaining_handles();
6701            if let Some((inlined, num_bytes, num_handles)) =
6702                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6703            {
6704                let member_inline_size = <fidl_fuchsia_component_decl__common::Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6705                if inlined != (member_inline_size <= 4) {
6706                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6707                }
6708                let inner_offset;
6709                let mut inner_depth = depth.clone();
6710                if inlined {
6711                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6712                    inner_offset = next_offset;
6713                } else {
6714                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6715                    inner_depth.increment()?;
6716                }
6717                let val_ref = self.source.get_or_insert_with(|| {
6718                    fidl::new_empty!(fidl_fuchsia_component_decl__common::Ref, D)
6719                });
6720                fidl::decode!(
6721                    fidl_fuchsia_component_decl__common::Ref,
6722                    D,
6723                    val_ref,
6724                    decoder,
6725                    inner_offset,
6726                    inner_depth
6727                )?;
6728                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6729                {
6730                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6731                }
6732                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6733                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6734                }
6735            }
6736
6737            next_offset += envelope_size;
6738
6739            // Decode the remaining unknown envelopes.
6740            while next_offset < end_offset {
6741                _next_ordinal_to_read += 1;
6742                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6743                next_offset += envelope_size;
6744            }
6745
6746            Ok(())
6747        }
6748    }
6749
6750    impl FilteredAggregateProvider {
6751        #[inline(always)]
6752        fn max_ordinal_present(&self) -> u64 {
6753            if let Some(_) = self.sources {
6754                return 4;
6755            }
6756            if let Some(_) = self.offer_service_decls {
6757                return 3;
6758            }
6759            if let Some(_) = self.moniker {
6760                return 2;
6761            }
6762            if let Some(_) = self.capability {
6763                return 1;
6764            }
6765            0
6766        }
6767    }
6768
6769    impl fidl::encoding::ValueTypeMarker for FilteredAggregateProvider {
6770        type Borrowed<'a> = &'a Self;
6771        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6772            value
6773        }
6774    }
6775
6776    unsafe impl fidl::encoding::TypeMarker for FilteredAggregateProvider {
6777        type Owned = Self;
6778
6779        #[inline(always)]
6780        fn inline_align(_context: fidl::encoding::Context) -> usize {
6781            8
6782        }
6783
6784        #[inline(always)]
6785        fn inline_size(_context: fidl::encoding::Context) -> usize {
6786            16
6787        }
6788    }
6789
6790    unsafe impl<D: fidl::encoding::ResourceDialect>
6791        fidl::encoding::Encode<FilteredAggregateProvider, D> for &FilteredAggregateProvider
6792    {
6793        unsafe fn encode(
6794            self,
6795            encoder: &mut fidl::encoding::Encoder<'_, D>,
6796            offset: usize,
6797            mut depth: fidl::encoding::Depth,
6798        ) -> fidl::Result<()> {
6799            encoder.debug_check_bounds::<FilteredAggregateProvider>(offset);
6800            // Vector header
6801            let max_ordinal: u64 = self.max_ordinal_present();
6802            encoder.write_num(max_ordinal, offset);
6803            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6804            // Calling encoder.out_of_line_offset(0) is not allowed.
6805            if max_ordinal == 0 {
6806                return Ok(());
6807            }
6808            depth.increment()?;
6809            let envelope_size = 8;
6810            let bytes_len = max_ordinal as usize * envelope_size;
6811            #[allow(unused_variables)]
6812            let offset = encoder.out_of_line_offset(bytes_len);
6813            let mut _prev_end_offset: usize = 0;
6814            if 1 > max_ordinal {
6815                return Ok(());
6816            }
6817
6818            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6819            // are envelope_size bytes.
6820            let cur_offset: usize = (1 - 1) * envelope_size;
6821
6822            // Zero reserved fields.
6823            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6824
6825            // Safety:
6826            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6827            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6828            //   envelope_size bytes, there is always sufficient room.
6829            fidl::encoding::encode_in_envelope_optional::<AggregateCapability, D>(
6830                self.capability
6831                    .as_ref()
6832                    .map(<AggregateCapability as fidl::encoding::ValueTypeMarker>::borrow),
6833                encoder,
6834                offset + cur_offset,
6835                depth,
6836            )?;
6837
6838            _prev_end_offset = cur_offset + envelope_size;
6839            if 2 > max_ordinal {
6840                return Ok(());
6841            }
6842
6843            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6844            // are envelope_size bytes.
6845            let cur_offset: usize = (2 - 1) * envelope_size;
6846
6847            // Zero reserved fields.
6848            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6849
6850            // Safety:
6851            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6852            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6853            //   envelope_size bytes, there is always sufficient room.
6854            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6855            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6856            encoder, offset + cur_offset, depth
6857        )?;
6858
6859            _prev_end_offset = cur_offset + envelope_size;
6860            if 3 > max_ordinal {
6861                return Ok(());
6862            }
6863
6864            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6865            // are envelope_size bytes.
6866            let cur_offset: usize = (3 - 1) * envelope_size;
6867
6868            // Zero reserved fields.
6869            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6870
6871            // Safety:
6872            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6873            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6874            //   envelope_size bytes, there is always sufficient room.
6875            fidl::encoding::encode_in_envelope_optional::<
6876                fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::OfferService>,
6877                D,
6878            >(
6879                self.offer_service_decls.as_ref().map(
6880                    <fidl::encoding::UnboundedVector<
6881                        fidl_fuchsia_component_decl__common::OfferService,
6882                    > as fidl::encoding::ValueTypeMarker>::borrow,
6883                ),
6884                encoder,
6885                offset + cur_offset,
6886                depth,
6887            )?;
6888
6889            _prev_end_offset = cur_offset + envelope_size;
6890            if 4 > max_ordinal {
6891                return Ok(());
6892            }
6893
6894            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6895            // are envelope_size bytes.
6896            let cur_offset: usize = (4 - 1) * envelope_size;
6897
6898            // Zero reserved fields.
6899            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6900
6901            // Safety:
6902            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6903            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6904            //   envelope_size bytes, there is always sufficient room.
6905            fidl::encoding::encode_in_envelope_optional::<Sources, D>(
6906                self.sources.as_ref().map(<Sources as fidl::encoding::ValueTypeMarker>::borrow),
6907                encoder,
6908                offset + cur_offset,
6909                depth,
6910            )?;
6911
6912            _prev_end_offset = cur_offset + envelope_size;
6913
6914            Ok(())
6915        }
6916    }
6917
6918    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6919        for FilteredAggregateProvider
6920    {
6921        #[inline(always)]
6922        fn new_empty() -> Self {
6923            Self::default()
6924        }
6925
6926        unsafe fn decode(
6927            &mut self,
6928            decoder: &mut fidl::encoding::Decoder<'_, D>,
6929            offset: usize,
6930            mut depth: fidl::encoding::Depth,
6931        ) -> fidl::Result<()> {
6932            decoder.debug_check_bounds::<Self>(offset);
6933            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6934                None => return Err(fidl::Error::NotNullable),
6935                Some(len) => len,
6936            };
6937            // Calling decoder.out_of_line_offset(0) is not allowed.
6938            if len == 0 {
6939                return Ok(());
6940            };
6941            depth.increment()?;
6942            let envelope_size = 8;
6943            let bytes_len = len * envelope_size;
6944            let offset = decoder.out_of_line_offset(bytes_len)?;
6945            // Decode the envelope for each type.
6946            let mut _next_ordinal_to_read = 0;
6947            let mut next_offset = offset;
6948            let end_offset = offset + bytes_len;
6949            _next_ordinal_to_read += 1;
6950            if next_offset >= end_offset {
6951                return Ok(());
6952            }
6953
6954            // Decode unknown envelopes for gaps in ordinals.
6955            while _next_ordinal_to_read < 1 {
6956                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6957                _next_ordinal_to_read += 1;
6958                next_offset += envelope_size;
6959            }
6960
6961            let next_out_of_line = decoder.next_out_of_line();
6962            let handles_before = decoder.remaining_handles();
6963            if let Some((inlined, num_bytes, num_handles)) =
6964                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6965            {
6966                let member_inline_size =
6967                    <AggregateCapability as fidl::encoding::TypeMarker>::inline_size(
6968                        decoder.context,
6969                    );
6970                if inlined != (member_inline_size <= 4) {
6971                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6972                }
6973                let inner_offset;
6974                let mut inner_depth = depth.clone();
6975                if inlined {
6976                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6977                    inner_offset = next_offset;
6978                } else {
6979                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6980                    inner_depth.increment()?;
6981                }
6982                let val_ref =
6983                    self.capability.get_or_insert_with(|| fidl::new_empty!(AggregateCapability, D));
6984                fidl::decode!(AggregateCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
6985                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6986                {
6987                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6988                }
6989                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6990                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6991                }
6992            }
6993
6994            next_offset += envelope_size;
6995            _next_ordinal_to_read += 1;
6996            if next_offset >= end_offset {
6997                return Ok(());
6998            }
6999
7000            // Decode unknown envelopes for gaps in ordinals.
7001            while _next_ordinal_to_read < 2 {
7002                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7003                _next_ordinal_to_read += 1;
7004                next_offset += envelope_size;
7005            }
7006
7007            let next_out_of_line = decoder.next_out_of_line();
7008            let handles_before = decoder.remaining_handles();
7009            if let Some((inlined, num_bytes, num_handles)) =
7010                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7011            {
7012                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7013                if inlined != (member_inline_size <= 4) {
7014                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7015                }
7016                let inner_offset;
7017                let mut inner_depth = depth.clone();
7018                if inlined {
7019                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7020                    inner_offset = next_offset;
7021                } else {
7022                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7023                    inner_depth.increment()?;
7024                }
7025                let val_ref = self.moniker.get_or_insert_with(|| {
7026                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
7027                });
7028                fidl::decode!(
7029                    fidl::encoding::BoundedString<4096>,
7030                    D,
7031                    val_ref,
7032                    decoder,
7033                    inner_offset,
7034                    inner_depth
7035                )?;
7036                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7037                {
7038                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7039                }
7040                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7041                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7042                }
7043            }
7044
7045            next_offset += envelope_size;
7046            _next_ordinal_to_read += 1;
7047            if next_offset >= end_offset {
7048                return Ok(());
7049            }
7050
7051            // Decode unknown envelopes for gaps in ordinals.
7052            while _next_ordinal_to_read < 3 {
7053                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7054                _next_ordinal_to_read += 1;
7055                next_offset += envelope_size;
7056            }
7057
7058            let next_out_of_line = decoder.next_out_of_line();
7059            let handles_before = decoder.remaining_handles();
7060            if let Some((inlined, num_bytes, num_handles)) =
7061                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7062            {
7063                let member_inline_size = <fidl::encoding::UnboundedVector<
7064                    fidl_fuchsia_component_decl__common::OfferService,
7065                > as fidl::encoding::TypeMarker>::inline_size(
7066                    decoder.context
7067                );
7068                if inlined != (member_inline_size <= 4) {
7069                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7070                }
7071                let inner_offset;
7072                let mut inner_depth = depth.clone();
7073                if inlined {
7074                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7075                    inner_offset = next_offset;
7076                } else {
7077                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7078                    inner_depth.increment()?;
7079                }
7080                let val_ref = self.offer_service_decls.get_or_insert_with(|| {
7081                    fidl::new_empty!(
7082                        fidl::encoding::UnboundedVector<
7083                            fidl_fuchsia_component_decl__common::OfferService,
7084                        >,
7085                        D
7086                    )
7087                });
7088                fidl::decode!(
7089                    fidl::encoding::UnboundedVector<
7090                        fidl_fuchsia_component_decl__common::OfferService,
7091                    >,
7092                    D,
7093                    val_ref,
7094                    decoder,
7095                    inner_offset,
7096                    inner_depth
7097                )?;
7098                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7099                {
7100                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7101                }
7102                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7103                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7104                }
7105            }
7106
7107            next_offset += envelope_size;
7108            _next_ordinal_to_read += 1;
7109            if next_offset >= end_offset {
7110                return Ok(());
7111            }
7112
7113            // Decode unknown envelopes for gaps in ordinals.
7114            while _next_ordinal_to_read < 4 {
7115                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7116                _next_ordinal_to_read += 1;
7117                next_offset += envelope_size;
7118            }
7119
7120            let next_out_of_line = decoder.next_out_of_line();
7121            let handles_before = decoder.remaining_handles();
7122            if let Some((inlined, num_bytes, num_handles)) =
7123                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7124            {
7125                let member_inline_size =
7126                    <Sources as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7127                if inlined != (member_inline_size <= 4) {
7128                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7129                }
7130                let inner_offset;
7131                let mut inner_depth = depth.clone();
7132                if inlined {
7133                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7134                    inner_offset = next_offset;
7135                } else {
7136                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7137                    inner_depth.increment()?;
7138                }
7139                let val_ref = self.sources.get_or_insert_with(|| fidl::new_empty!(Sources, D));
7140                fidl::decode!(Sources, D, val_ref, decoder, inner_offset, inner_depth)?;
7141                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7142                {
7143                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7144                }
7145                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7146                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7147                }
7148            }
7149
7150            next_offset += envelope_size;
7151
7152            // Decode the remaining unknown envelopes.
7153            while next_offset < end_offset {
7154                _next_ordinal_to_read += 1;
7155                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7156                next_offset += envelope_size;
7157            }
7158
7159            Ok(())
7160        }
7161    }
7162
7163    impl FilteredProvider {
7164        #[inline(always)]
7165        fn max_ordinal_present(&self) -> u64 {
7166            if let Some(_) = self.offer_service_decl {
7167                return 4;
7168            }
7169            if let Some(_) = self.service_capability {
7170                return 3;
7171            }
7172            if let Some(_) = self.moniker {
7173                return 2;
7174            }
7175            if let Some(_) = self.capability {
7176                return 1;
7177            }
7178            0
7179        }
7180    }
7181
7182    impl fidl::encoding::ValueTypeMarker for FilteredProvider {
7183        type Borrowed<'a> = &'a Self;
7184        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7185            value
7186        }
7187    }
7188
7189    unsafe impl fidl::encoding::TypeMarker for FilteredProvider {
7190        type Owned = Self;
7191
7192        #[inline(always)]
7193        fn inline_align(_context: fidl::encoding::Context) -> usize {
7194            8
7195        }
7196
7197        #[inline(always)]
7198        fn inline_size(_context: fidl::encoding::Context) -> usize {
7199            16
7200        }
7201    }
7202
7203    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FilteredProvider, D>
7204        for &FilteredProvider
7205    {
7206        unsafe fn encode(
7207            self,
7208            encoder: &mut fidl::encoding::Encoder<'_, D>,
7209            offset: usize,
7210            mut depth: fidl::encoding::Depth,
7211        ) -> fidl::Result<()> {
7212            encoder.debug_check_bounds::<FilteredProvider>(offset);
7213            // Vector header
7214            let max_ordinal: u64 = self.max_ordinal_present();
7215            encoder.write_num(max_ordinal, offset);
7216            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7217            // Calling encoder.out_of_line_offset(0) is not allowed.
7218            if max_ordinal == 0 {
7219                return Ok(());
7220            }
7221            depth.increment()?;
7222            let envelope_size = 8;
7223            let bytes_len = max_ordinal as usize * envelope_size;
7224            #[allow(unused_variables)]
7225            let offset = encoder.out_of_line_offset(bytes_len);
7226            let mut _prev_end_offset: usize = 0;
7227            if 1 > max_ordinal {
7228                return Ok(());
7229            }
7230
7231            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7232            // are envelope_size bytes.
7233            let cur_offset: usize = (1 - 1) * envelope_size;
7234
7235            // Zero reserved fields.
7236            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7237
7238            // Safety:
7239            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7240            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7241            //   envelope_size bytes, there is always sufficient room.
7242            fidl::encoding::encode_in_envelope_optional::<AggregateCapability, D>(
7243                self.capability
7244                    .as_ref()
7245                    .map(<AggregateCapability as fidl::encoding::ValueTypeMarker>::borrow),
7246                encoder,
7247                offset + cur_offset,
7248                depth,
7249            )?;
7250
7251            _prev_end_offset = cur_offset + envelope_size;
7252            if 2 > max_ordinal {
7253                return Ok(());
7254            }
7255
7256            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7257            // are envelope_size bytes.
7258            let cur_offset: usize = (2 - 1) * envelope_size;
7259
7260            // Zero reserved fields.
7261            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7262
7263            // Safety:
7264            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7265            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7266            //   envelope_size bytes, there is always sufficient room.
7267            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
7268            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
7269            encoder, offset + cur_offset, depth
7270        )?;
7271
7272            _prev_end_offset = cur_offset + envelope_size;
7273            if 3 > max_ordinal {
7274                return Ok(());
7275            }
7276
7277            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7278            // are envelope_size bytes.
7279            let cur_offset: usize = (3 - 1) * envelope_size;
7280
7281            // Zero reserved fields.
7282            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7283
7284            // Safety:
7285            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7286            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7287            //   envelope_size bytes, there is always sufficient room.
7288            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
7289                self.service_capability
7290                    .as_ref()
7291                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
7292                encoder,
7293                offset + cur_offset,
7294                depth,
7295            )?;
7296
7297            _prev_end_offset = cur_offset + envelope_size;
7298            if 4 > max_ordinal {
7299                return Ok(());
7300            }
7301
7302            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7303            // are envelope_size bytes.
7304            let cur_offset: usize = (4 - 1) * envelope_size;
7305
7306            // Zero reserved fields.
7307            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7308
7309            // Safety:
7310            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7311            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7312            //   envelope_size bytes, there is always sufficient room.
7313            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::OfferService, D>(
7314            self.offer_service_decl.as_ref().map(<fidl_fuchsia_component_decl__common::OfferService as fidl::encoding::ValueTypeMarker>::borrow),
7315            encoder, offset + cur_offset, depth
7316        )?;
7317
7318            _prev_end_offset = cur_offset + envelope_size;
7319
7320            Ok(())
7321        }
7322    }
7323
7324    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FilteredProvider {
7325        #[inline(always)]
7326        fn new_empty() -> Self {
7327            Self::default()
7328        }
7329
7330        unsafe fn decode(
7331            &mut self,
7332            decoder: &mut fidl::encoding::Decoder<'_, D>,
7333            offset: usize,
7334            mut depth: fidl::encoding::Depth,
7335        ) -> fidl::Result<()> {
7336            decoder.debug_check_bounds::<Self>(offset);
7337            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7338                None => return Err(fidl::Error::NotNullable),
7339                Some(len) => len,
7340            };
7341            // Calling decoder.out_of_line_offset(0) is not allowed.
7342            if len == 0 {
7343                return Ok(());
7344            };
7345            depth.increment()?;
7346            let envelope_size = 8;
7347            let bytes_len = len * envelope_size;
7348            let offset = decoder.out_of_line_offset(bytes_len)?;
7349            // Decode the envelope for each type.
7350            let mut _next_ordinal_to_read = 0;
7351            let mut next_offset = offset;
7352            let end_offset = offset + bytes_len;
7353            _next_ordinal_to_read += 1;
7354            if next_offset >= end_offset {
7355                return Ok(());
7356            }
7357
7358            // Decode unknown envelopes for gaps in ordinals.
7359            while _next_ordinal_to_read < 1 {
7360                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7361                _next_ordinal_to_read += 1;
7362                next_offset += envelope_size;
7363            }
7364
7365            let next_out_of_line = decoder.next_out_of_line();
7366            let handles_before = decoder.remaining_handles();
7367            if let Some((inlined, num_bytes, num_handles)) =
7368                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7369            {
7370                let member_inline_size =
7371                    <AggregateCapability as fidl::encoding::TypeMarker>::inline_size(
7372                        decoder.context,
7373                    );
7374                if inlined != (member_inline_size <= 4) {
7375                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7376                }
7377                let inner_offset;
7378                let mut inner_depth = depth.clone();
7379                if inlined {
7380                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7381                    inner_offset = next_offset;
7382                } else {
7383                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7384                    inner_depth.increment()?;
7385                }
7386                let val_ref =
7387                    self.capability.get_or_insert_with(|| fidl::new_empty!(AggregateCapability, D));
7388                fidl::decode!(AggregateCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
7389                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7390                {
7391                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7392                }
7393                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7394                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7395                }
7396            }
7397
7398            next_offset += envelope_size;
7399            _next_ordinal_to_read += 1;
7400            if next_offset >= end_offset {
7401                return Ok(());
7402            }
7403
7404            // Decode unknown envelopes for gaps in ordinals.
7405            while _next_ordinal_to_read < 2 {
7406                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7407                _next_ordinal_to_read += 1;
7408                next_offset += envelope_size;
7409            }
7410
7411            let next_out_of_line = decoder.next_out_of_line();
7412            let handles_before = decoder.remaining_handles();
7413            if let Some((inlined, num_bytes, num_handles)) =
7414                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7415            {
7416                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7417                if inlined != (member_inline_size <= 4) {
7418                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7419                }
7420                let inner_offset;
7421                let mut inner_depth = depth.clone();
7422                if inlined {
7423                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7424                    inner_offset = next_offset;
7425                } else {
7426                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7427                    inner_depth.increment()?;
7428                }
7429                let val_ref = self.moniker.get_or_insert_with(|| {
7430                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
7431                });
7432                fidl::decode!(
7433                    fidl::encoding::BoundedString<4096>,
7434                    D,
7435                    val_ref,
7436                    decoder,
7437                    inner_offset,
7438                    inner_depth
7439                )?;
7440                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7441                {
7442                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7443                }
7444                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7445                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7446                }
7447            }
7448
7449            next_offset += envelope_size;
7450            _next_ordinal_to_read += 1;
7451            if next_offset >= end_offset {
7452                return Ok(());
7453            }
7454
7455            // Decode unknown envelopes for gaps in ordinals.
7456            while _next_ordinal_to_read < 3 {
7457                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7458                _next_ordinal_to_read += 1;
7459                next_offset += envelope_size;
7460            }
7461
7462            let next_out_of_line = decoder.next_out_of_line();
7463            let handles_before = decoder.remaining_handles();
7464            if let Some((inlined, num_bytes, num_handles)) =
7465                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7466            {
7467                let member_inline_size =
7468                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
7469                        decoder.context,
7470                    );
7471                if inlined != (member_inline_size <= 4) {
7472                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7473                }
7474                let inner_offset;
7475                let mut inner_depth = depth.clone();
7476                if inlined {
7477                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7478                    inner_offset = next_offset;
7479                } else {
7480                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7481                    inner_depth.increment()?;
7482                }
7483                let val_ref = self
7484                    .service_capability
7485                    .get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
7486                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
7487                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7488                {
7489                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7490                }
7491                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7492                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7493                }
7494            }
7495
7496            next_offset += envelope_size;
7497            _next_ordinal_to_read += 1;
7498            if next_offset >= end_offset {
7499                return Ok(());
7500            }
7501
7502            // Decode unknown envelopes for gaps in ordinals.
7503            while _next_ordinal_to_read < 4 {
7504                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7505                _next_ordinal_to_read += 1;
7506                next_offset += envelope_size;
7507            }
7508
7509            let next_out_of_line = decoder.next_out_of_line();
7510            let handles_before = decoder.remaining_handles();
7511            if let Some((inlined, num_bytes, num_handles)) =
7512                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7513            {
7514                let member_inline_size = <fidl_fuchsia_component_decl__common::OfferService as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7515                if inlined != (member_inline_size <= 4) {
7516                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7517                }
7518                let inner_offset;
7519                let mut inner_depth = depth.clone();
7520                if inlined {
7521                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7522                    inner_offset = next_offset;
7523                } else {
7524                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7525                    inner_depth.increment()?;
7526                }
7527                let val_ref = self.offer_service_decl.get_or_insert_with(|| {
7528                    fidl::new_empty!(fidl_fuchsia_component_decl__common::OfferService, D)
7529                });
7530                fidl::decode!(
7531                    fidl_fuchsia_component_decl__common::OfferService,
7532                    D,
7533                    val_ref,
7534                    decoder,
7535                    inner_offset,
7536                    inner_depth
7537                )?;
7538                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7539                {
7540                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7541                }
7542                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7543                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7544                }
7545            }
7546
7547            next_offset += envelope_size;
7548
7549            // Decode the remaining unknown envelopes.
7550            while next_offset < end_offset {
7551                _next_ordinal_to_read += 1;
7552                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7553                next_offset += envelope_size;
7554            }
7555
7556            Ok(())
7557        }
7558    }
7559
7560    impl Framework {
7561        #[inline(always)]
7562        fn max_ordinal_present(&self) -> u64 {
7563            if let Some(_) = self.moniker {
7564                return 2;
7565            }
7566            if let Some(_) = self.capability {
7567                return 1;
7568            }
7569            0
7570        }
7571    }
7572
7573    impl fidl::encoding::ValueTypeMarker for Framework {
7574        type Borrowed<'a> = &'a Self;
7575        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7576            value
7577        }
7578    }
7579
7580    unsafe impl fidl::encoding::TypeMarker for Framework {
7581        type Owned = Self;
7582
7583        #[inline(always)]
7584        fn inline_align(_context: fidl::encoding::Context) -> usize {
7585            8
7586        }
7587
7588        #[inline(always)]
7589        fn inline_size(_context: fidl::encoding::Context) -> usize {
7590            16
7591        }
7592    }
7593
7594    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Framework, D>
7595        for &Framework
7596    {
7597        unsafe fn encode(
7598            self,
7599            encoder: &mut fidl::encoding::Encoder<'_, D>,
7600            offset: usize,
7601            mut depth: fidl::encoding::Depth,
7602        ) -> fidl::Result<()> {
7603            encoder.debug_check_bounds::<Framework>(offset);
7604            // Vector header
7605            let max_ordinal: u64 = self.max_ordinal_present();
7606            encoder.write_num(max_ordinal, offset);
7607            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7608            // Calling encoder.out_of_line_offset(0) is not allowed.
7609            if max_ordinal == 0 {
7610                return Ok(());
7611            }
7612            depth.increment()?;
7613            let envelope_size = 8;
7614            let bytes_len = max_ordinal as usize * envelope_size;
7615            #[allow(unused_variables)]
7616            let offset = encoder.out_of_line_offset(bytes_len);
7617            let mut _prev_end_offset: usize = 0;
7618            if 1 > max_ordinal {
7619                return Ok(());
7620            }
7621
7622            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7623            // are envelope_size bytes.
7624            let cur_offset: usize = (1 - 1) * envelope_size;
7625
7626            // Zero reserved fields.
7627            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7628
7629            // Safety:
7630            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7631            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7632            //   envelope_size bytes, there is always sufficient room.
7633            fidl::encoding::encode_in_envelope_optional::<InternalCapability, D>(
7634                self.capability
7635                    .as_ref()
7636                    .map(<InternalCapability as fidl::encoding::ValueTypeMarker>::borrow),
7637                encoder,
7638                offset + cur_offset,
7639                depth,
7640            )?;
7641
7642            _prev_end_offset = cur_offset + envelope_size;
7643            if 2 > max_ordinal {
7644                return Ok(());
7645            }
7646
7647            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7648            // are envelope_size bytes.
7649            let cur_offset: usize = (2 - 1) * envelope_size;
7650
7651            // Zero reserved fields.
7652            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7653
7654            // Safety:
7655            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7656            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7657            //   envelope_size bytes, there is always sufficient room.
7658            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
7659            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
7660            encoder, offset + cur_offset, depth
7661        )?;
7662
7663            _prev_end_offset = cur_offset + envelope_size;
7664
7665            Ok(())
7666        }
7667    }
7668
7669    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Framework {
7670        #[inline(always)]
7671        fn new_empty() -> Self {
7672            Self::default()
7673        }
7674
7675        unsafe fn decode(
7676            &mut self,
7677            decoder: &mut fidl::encoding::Decoder<'_, D>,
7678            offset: usize,
7679            mut depth: fidl::encoding::Depth,
7680        ) -> fidl::Result<()> {
7681            decoder.debug_check_bounds::<Self>(offset);
7682            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7683                None => return Err(fidl::Error::NotNullable),
7684                Some(len) => len,
7685            };
7686            // Calling decoder.out_of_line_offset(0) is not allowed.
7687            if len == 0 {
7688                return Ok(());
7689            };
7690            depth.increment()?;
7691            let envelope_size = 8;
7692            let bytes_len = len * envelope_size;
7693            let offset = decoder.out_of_line_offset(bytes_len)?;
7694            // Decode the envelope for each type.
7695            let mut _next_ordinal_to_read = 0;
7696            let mut next_offset = offset;
7697            let end_offset = offset + bytes_len;
7698            _next_ordinal_to_read += 1;
7699            if next_offset >= end_offset {
7700                return Ok(());
7701            }
7702
7703            // Decode unknown envelopes for gaps in ordinals.
7704            while _next_ordinal_to_read < 1 {
7705                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7706                _next_ordinal_to_read += 1;
7707                next_offset += envelope_size;
7708            }
7709
7710            let next_out_of_line = decoder.next_out_of_line();
7711            let handles_before = decoder.remaining_handles();
7712            if let Some((inlined, num_bytes, num_handles)) =
7713                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7714            {
7715                let member_inline_size =
7716                    <InternalCapability as fidl::encoding::TypeMarker>::inline_size(
7717                        decoder.context,
7718                    );
7719                if inlined != (member_inline_size <= 4) {
7720                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7721                }
7722                let inner_offset;
7723                let mut inner_depth = depth.clone();
7724                if inlined {
7725                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7726                    inner_offset = next_offset;
7727                } else {
7728                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7729                    inner_depth.increment()?;
7730                }
7731                let val_ref =
7732                    self.capability.get_or_insert_with(|| fidl::new_empty!(InternalCapability, D));
7733                fidl::decode!(InternalCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
7734                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7735                {
7736                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7737                }
7738                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7739                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7740                }
7741            }
7742
7743            next_offset += envelope_size;
7744            _next_ordinal_to_read += 1;
7745            if next_offset >= end_offset {
7746                return Ok(());
7747            }
7748
7749            // Decode unknown envelopes for gaps in ordinals.
7750            while _next_ordinal_to_read < 2 {
7751                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7752                _next_ordinal_to_read += 1;
7753                next_offset += envelope_size;
7754            }
7755
7756            let next_out_of_line = decoder.next_out_of_line();
7757            let handles_before = decoder.remaining_handles();
7758            if let Some((inlined, num_bytes, num_handles)) =
7759                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7760            {
7761                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7762                if inlined != (member_inline_size <= 4) {
7763                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7764                }
7765                let inner_offset;
7766                let mut inner_depth = depth.clone();
7767                if inlined {
7768                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7769                    inner_offset = next_offset;
7770                } else {
7771                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7772                    inner_depth.increment()?;
7773                }
7774                let val_ref = self.moniker.get_or_insert_with(|| {
7775                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
7776                });
7777                fidl::decode!(
7778                    fidl::encoding::BoundedString<4096>,
7779                    D,
7780                    val_ref,
7781                    decoder,
7782                    inner_offset,
7783                    inner_depth
7784                )?;
7785                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7786                {
7787                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7788                }
7789                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7790                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7791                }
7792            }
7793
7794            next_offset += envelope_size;
7795
7796            // Decode the remaining unknown envelopes.
7797            while next_offset < end_offset {
7798                _next_ordinal_to_read += 1;
7799                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7800                next_offset += envelope_size;
7801            }
7802
7803            Ok(())
7804        }
7805    }
7806
7807    impl HealthCheck {
7808        #[inline(always)]
7809        fn max_ordinal_present(&self) -> u64 {
7810            if let Some(_) = self.monikers {
7811                return 1;
7812            }
7813            0
7814        }
7815    }
7816
7817    impl fidl::encoding::ValueTypeMarker for HealthCheck {
7818        type Borrowed<'a> = &'a Self;
7819        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7820            value
7821        }
7822    }
7823
7824    unsafe impl fidl::encoding::TypeMarker for HealthCheck {
7825        type Owned = Self;
7826
7827        #[inline(always)]
7828        fn inline_align(_context: fidl::encoding::Context) -> usize {
7829            8
7830        }
7831
7832        #[inline(always)]
7833        fn inline_size(_context: fidl::encoding::Context) -> usize {
7834            16
7835        }
7836    }
7837
7838    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HealthCheck, D>
7839        for &HealthCheck
7840    {
7841        unsafe fn encode(
7842            self,
7843            encoder: &mut fidl::encoding::Encoder<'_, D>,
7844            offset: usize,
7845            mut depth: fidl::encoding::Depth,
7846        ) -> fidl::Result<()> {
7847            encoder.debug_check_bounds::<HealthCheck>(offset);
7848            // Vector header
7849            let max_ordinal: u64 = self.max_ordinal_present();
7850            encoder.write_num(max_ordinal, offset);
7851            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7852            // Calling encoder.out_of_line_offset(0) is not allowed.
7853            if max_ordinal == 0 {
7854                return Ok(());
7855            }
7856            depth.increment()?;
7857            let envelope_size = 8;
7858            let bytes_len = max_ordinal as usize * envelope_size;
7859            #[allow(unused_variables)]
7860            let offset = encoder.out_of_line_offset(bytes_len);
7861            let mut _prev_end_offset: usize = 0;
7862            if 1 > max_ordinal {
7863                return Ok(());
7864            }
7865
7866            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7867            // are envelope_size bytes.
7868            let cur_offset: usize = (1 - 1) * envelope_size;
7869
7870            // Zero reserved fields.
7871            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7872
7873            // Safety:
7874            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7875            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7876            //   envelope_size bytes, there is always sufficient room.
7877            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>>, D>(
7878            self.monikers.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>> as fidl::encoding::ValueTypeMarker>::borrow),
7879            encoder, offset + cur_offset, depth
7880        )?;
7881
7882            _prev_end_offset = cur_offset + envelope_size;
7883
7884            Ok(())
7885        }
7886    }
7887
7888    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HealthCheck {
7889        #[inline(always)]
7890        fn new_empty() -> Self {
7891            Self::default()
7892        }
7893
7894        unsafe fn decode(
7895            &mut self,
7896            decoder: &mut fidl::encoding::Decoder<'_, D>,
7897            offset: usize,
7898            mut depth: fidl::encoding::Depth,
7899        ) -> fidl::Result<()> {
7900            decoder.debug_check_bounds::<Self>(offset);
7901            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7902                None => return Err(fidl::Error::NotNullable),
7903                Some(len) => len,
7904            };
7905            // Calling decoder.out_of_line_offset(0) is not allowed.
7906            if len == 0 {
7907                return Ok(());
7908            };
7909            depth.increment()?;
7910            let envelope_size = 8;
7911            let bytes_len = len * envelope_size;
7912            let offset = decoder.out_of_line_offset(bytes_len)?;
7913            // Decode the envelope for each type.
7914            let mut _next_ordinal_to_read = 0;
7915            let mut next_offset = offset;
7916            let end_offset = offset + bytes_len;
7917            _next_ordinal_to_read += 1;
7918            if next_offset >= end_offset {
7919                return Ok(());
7920            }
7921
7922            // Decode unknown envelopes for gaps in ordinals.
7923            while _next_ordinal_to_read < 1 {
7924                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7925                _next_ordinal_to_read += 1;
7926                next_offset += envelope_size;
7927            }
7928
7929            let next_out_of_line = decoder.next_out_of_line();
7930            let handles_before = decoder.remaining_handles();
7931            if let Some((inlined, num_bytes, num_handles)) =
7932                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7933            {
7934                let member_inline_size = <fidl::encoding::UnboundedVector<
7935                    fidl::encoding::BoundedString<255>,
7936                > as fidl::encoding::TypeMarker>::inline_size(
7937                    decoder.context
7938                );
7939                if inlined != (member_inline_size <= 4) {
7940                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7941                }
7942                let inner_offset;
7943                let mut inner_depth = depth.clone();
7944                if inlined {
7945                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7946                    inner_offset = next_offset;
7947                } else {
7948                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7949                    inner_depth.increment()?;
7950                }
7951                let val_ref = self.monikers.get_or_insert_with(|| {
7952                    fidl::new_empty!(
7953                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>>,
7954                        D
7955                    )
7956                });
7957                fidl::decode!(
7958                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>>,
7959                    D,
7960                    val_ref,
7961                    decoder,
7962                    inner_offset,
7963                    inner_depth
7964                )?;
7965                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7966                {
7967                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7968                }
7969                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7970                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7971                }
7972            }
7973
7974            next_offset += envelope_size;
7975
7976            // Decode the remaining unknown envelopes.
7977            while next_offset < end_offset {
7978                _next_ordinal_to_read += 1;
7979                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7980                next_offset += envelope_size;
7981            }
7982
7983            Ok(())
7984        }
7985    }
7986
7987    impl InstanceIdEntry {
7988        #[inline(always)]
7989        fn max_ordinal_present(&self) -> u64 {
7990            if let Some(_) = self.moniker {
7991                return 3;
7992            }
7993            if let Some(_) = self.instance_id {
7994                return 1;
7995            }
7996            0
7997        }
7998    }
7999
8000    impl fidl::encoding::ValueTypeMarker for InstanceIdEntry {
8001        type Borrowed<'a> = &'a Self;
8002        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8003            value
8004        }
8005    }
8006
8007    unsafe impl fidl::encoding::TypeMarker for InstanceIdEntry {
8008        type Owned = Self;
8009
8010        #[inline(always)]
8011        fn inline_align(_context: fidl::encoding::Context) -> usize {
8012            8
8013        }
8014
8015        #[inline(always)]
8016        fn inline_size(_context: fidl::encoding::Context) -> usize {
8017            16
8018        }
8019    }
8020
8021    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InstanceIdEntry, D>
8022        for &InstanceIdEntry
8023    {
8024        unsafe fn encode(
8025            self,
8026            encoder: &mut fidl::encoding::Encoder<'_, D>,
8027            offset: usize,
8028            mut depth: fidl::encoding::Depth,
8029        ) -> fidl::Result<()> {
8030            encoder.debug_check_bounds::<InstanceIdEntry>(offset);
8031            // Vector header
8032            let max_ordinal: u64 = self.max_ordinal_present();
8033            encoder.write_num(max_ordinal, offset);
8034            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8035            // Calling encoder.out_of_line_offset(0) is not allowed.
8036            if max_ordinal == 0 {
8037                return Ok(());
8038            }
8039            depth.increment()?;
8040            let envelope_size = 8;
8041            let bytes_len = max_ordinal as usize * envelope_size;
8042            #[allow(unused_variables)]
8043            let offset = encoder.out_of_line_offset(bytes_len);
8044            let mut _prev_end_offset: usize = 0;
8045            if 1 > max_ordinal {
8046                return Ok(());
8047            }
8048
8049            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8050            // are envelope_size bytes.
8051            let cur_offset: usize = (1 - 1) * envelope_size;
8052
8053            // Zero reserved fields.
8054            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8055
8056            // Safety:
8057            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8058            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8059            //   envelope_size bytes, there is always sufficient room.
8060            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
8061                self.instance_id.as_ref().map(
8062                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
8063                ),
8064                encoder,
8065                offset + cur_offset,
8066                depth,
8067            )?;
8068
8069            _prev_end_offset = cur_offset + envelope_size;
8070            if 3 > max_ordinal {
8071                return Ok(());
8072            }
8073
8074            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8075            // are envelope_size bytes.
8076            let cur_offset: usize = (3 - 1) * envelope_size;
8077
8078            // Zero reserved fields.
8079            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8080
8081            // Safety:
8082            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8083            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8084            //   envelope_size bytes, there is always sufficient room.
8085            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
8086            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
8087            encoder, offset + cur_offset, depth
8088        )?;
8089
8090            _prev_end_offset = cur_offset + envelope_size;
8091
8092            Ok(())
8093        }
8094    }
8095
8096    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InstanceIdEntry {
8097        #[inline(always)]
8098        fn new_empty() -> Self {
8099            Self::default()
8100        }
8101
8102        unsafe fn decode(
8103            &mut self,
8104            decoder: &mut fidl::encoding::Decoder<'_, D>,
8105            offset: usize,
8106            mut depth: fidl::encoding::Depth,
8107        ) -> fidl::Result<()> {
8108            decoder.debug_check_bounds::<Self>(offset);
8109            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8110                None => return Err(fidl::Error::NotNullable),
8111                Some(len) => len,
8112            };
8113            // Calling decoder.out_of_line_offset(0) is not allowed.
8114            if len == 0 {
8115                return Ok(());
8116            };
8117            depth.increment()?;
8118            let envelope_size = 8;
8119            let bytes_len = len * envelope_size;
8120            let offset = decoder.out_of_line_offset(bytes_len)?;
8121            // Decode the envelope for each type.
8122            let mut _next_ordinal_to_read = 0;
8123            let mut next_offset = offset;
8124            let end_offset = offset + bytes_len;
8125            _next_ordinal_to_read += 1;
8126            if next_offset >= end_offset {
8127                return Ok(());
8128            }
8129
8130            // Decode unknown envelopes for gaps in ordinals.
8131            while _next_ordinal_to_read < 1 {
8132                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8133                _next_ordinal_to_read += 1;
8134                next_offset += envelope_size;
8135            }
8136
8137            let next_out_of_line = decoder.next_out_of_line();
8138            let handles_before = decoder.remaining_handles();
8139            if let Some((inlined, num_bytes, num_handles)) =
8140                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8141            {
8142                let member_inline_size =
8143                    <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
8144                        decoder.context,
8145                    );
8146                if inlined != (member_inline_size <= 4) {
8147                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8148                }
8149                let inner_offset;
8150                let mut inner_depth = depth.clone();
8151                if inlined {
8152                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8153                    inner_offset = next_offset;
8154                } else {
8155                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8156                    inner_depth.increment()?;
8157                }
8158                let val_ref = self
8159                    .instance_id
8160                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
8161                fidl::decode!(
8162                    fidl::encoding::BoundedString<64>,
8163                    D,
8164                    val_ref,
8165                    decoder,
8166                    inner_offset,
8167                    inner_depth
8168                )?;
8169                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8170                {
8171                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8172                }
8173                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8174                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8175                }
8176            }
8177
8178            next_offset += envelope_size;
8179            _next_ordinal_to_read += 1;
8180            if next_offset >= end_offset {
8181                return Ok(());
8182            }
8183
8184            // Decode unknown envelopes for gaps in ordinals.
8185            while _next_ordinal_to_read < 3 {
8186                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8187                _next_ordinal_to_read += 1;
8188                next_offset += envelope_size;
8189            }
8190
8191            let next_out_of_line = decoder.next_out_of_line();
8192            let handles_before = decoder.remaining_handles();
8193            if let Some((inlined, num_bytes, num_handles)) =
8194                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8195            {
8196                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8197                if inlined != (member_inline_size <= 4) {
8198                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8199                }
8200                let inner_offset;
8201                let mut inner_depth = depth.clone();
8202                if inlined {
8203                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8204                    inner_offset = next_offset;
8205                } else {
8206                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8207                    inner_depth.increment()?;
8208                }
8209                let val_ref = self.moniker.get_or_insert_with(|| {
8210                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
8211                });
8212                fidl::decode!(
8213                    fidl::encoding::BoundedString<4096>,
8214                    D,
8215                    val_ref,
8216                    decoder,
8217                    inner_offset,
8218                    inner_depth
8219                )?;
8220                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8221                {
8222                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8223                }
8224                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8225                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8226                }
8227            }
8228
8229            next_offset += envelope_size;
8230
8231            // Decode the remaining unknown envelopes.
8232            while next_offset < end_offset {
8233                _next_ordinal_to_read += 1;
8234                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8235                next_offset += envelope_size;
8236            }
8237
8238            Ok(())
8239        }
8240    }
8241
8242    impl JobPolicyAllowlists {
8243        #[inline(always)]
8244        fn max_ordinal_present(&self) -> u64 {
8245            if let Some(_) = self.create_raw_processes {
8246                return 3;
8247            }
8248            if let Some(_) = self.main_process_critical {
8249                return 2;
8250            }
8251            if let Some(_) = self.ambient_mark_vmo_exec {
8252                return 1;
8253            }
8254            0
8255        }
8256    }
8257
8258    impl fidl::encoding::ValueTypeMarker for JobPolicyAllowlists {
8259        type Borrowed<'a> = &'a Self;
8260        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8261            value
8262        }
8263    }
8264
8265    unsafe impl fidl::encoding::TypeMarker for JobPolicyAllowlists {
8266        type Owned = Self;
8267
8268        #[inline(always)]
8269        fn inline_align(_context: fidl::encoding::Context) -> usize {
8270            8
8271        }
8272
8273        #[inline(always)]
8274        fn inline_size(_context: fidl::encoding::Context) -> usize {
8275            16
8276        }
8277    }
8278
8279    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<JobPolicyAllowlists, D>
8280        for &JobPolicyAllowlists
8281    {
8282        unsafe fn encode(
8283            self,
8284            encoder: &mut fidl::encoding::Encoder<'_, D>,
8285            offset: usize,
8286            mut depth: fidl::encoding::Depth,
8287        ) -> fidl::Result<()> {
8288            encoder.debug_check_bounds::<JobPolicyAllowlists>(offset);
8289            // Vector header
8290            let max_ordinal: u64 = self.max_ordinal_present();
8291            encoder.write_num(max_ordinal, offset);
8292            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8293            // Calling encoder.out_of_line_offset(0) is not allowed.
8294            if max_ordinal == 0 {
8295                return Ok(());
8296            }
8297            depth.increment()?;
8298            let envelope_size = 8;
8299            let bytes_len = max_ordinal as usize * envelope_size;
8300            #[allow(unused_variables)]
8301            let offset = encoder.out_of_line_offset(bytes_len);
8302            let mut _prev_end_offset: usize = 0;
8303            if 1 > max_ordinal {
8304                return Ok(());
8305            }
8306
8307            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8308            // are envelope_size bytes.
8309            let cur_offset: usize = (1 - 1) * envelope_size;
8310
8311            // Zero reserved fields.
8312            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8313
8314            // Safety:
8315            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8316            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8317            //   envelope_size bytes, there is always sufficient room.
8318            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
8319            self.ambient_mark_vmo_exec.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
8320            encoder, offset + cur_offset, depth
8321        )?;
8322
8323            _prev_end_offset = cur_offset + envelope_size;
8324            if 2 > max_ordinal {
8325                return Ok(());
8326            }
8327
8328            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8329            // are envelope_size bytes.
8330            let cur_offset: usize = (2 - 1) * envelope_size;
8331
8332            // Zero reserved fields.
8333            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8334
8335            // Safety:
8336            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8337            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8338            //   envelope_size bytes, there is always sufficient room.
8339            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
8340            self.main_process_critical.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
8341            encoder, offset + cur_offset, depth
8342        )?;
8343
8344            _prev_end_offset = cur_offset + envelope_size;
8345            if 3 > max_ordinal {
8346                return Ok(());
8347            }
8348
8349            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8350            // are envelope_size bytes.
8351            let cur_offset: usize = (3 - 1) * envelope_size;
8352
8353            // Zero reserved fields.
8354            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8355
8356            // Safety:
8357            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8358            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8359            //   envelope_size bytes, there is always sufficient room.
8360            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
8361            self.create_raw_processes.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
8362            encoder, offset + cur_offset, depth
8363        )?;
8364
8365            _prev_end_offset = cur_offset + envelope_size;
8366
8367            Ok(())
8368        }
8369    }
8370
8371    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for JobPolicyAllowlists {
8372        #[inline(always)]
8373        fn new_empty() -> Self {
8374            Self::default()
8375        }
8376
8377        unsafe fn decode(
8378            &mut self,
8379            decoder: &mut fidl::encoding::Decoder<'_, D>,
8380            offset: usize,
8381            mut depth: fidl::encoding::Depth,
8382        ) -> fidl::Result<()> {
8383            decoder.debug_check_bounds::<Self>(offset);
8384            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8385                None => return Err(fidl::Error::NotNullable),
8386                Some(len) => len,
8387            };
8388            // Calling decoder.out_of_line_offset(0) is not allowed.
8389            if len == 0 {
8390                return Ok(());
8391            };
8392            depth.increment()?;
8393            let envelope_size = 8;
8394            let bytes_len = len * envelope_size;
8395            let offset = decoder.out_of_line_offset(bytes_len)?;
8396            // Decode the envelope for each type.
8397            let mut _next_ordinal_to_read = 0;
8398            let mut next_offset = offset;
8399            let end_offset = offset + bytes_len;
8400            _next_ordinal_to_read += 1;
8401            if next_offset >= end_offset {
8402                return Ok(());
8403            }
8404
8405            // Decode unknown envelopes for gaps in ordinals.
8406            while _next_ordinal_to_read < 1 {
8407                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8408                _next_ordinal_to_read += 1;
8409                next_offset += envelope_size;
8410            }
8411
8412            let next_out_of_line = decoder.next_out_of_line();
8413            let handles_before = decoder.remaining_handles();
8414            if let Some((inlined, num_bytes, num_handles)) =
8415                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8416            {
8417                let member_inline_size = <fidl::encoding::Vector<
8418                    fidl::encoding::BoundedString<4096>,
8419                    128,
8420                > as fidl::encoding::TypeMarker>::inline_size(
8421                    decoder.context
8422                );
8423                if inlined != (member_inline_size <= 4) {
8424                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8425                }
8426                let inner_offset;
8427                let mut inner_depth = depth.clone();
8428                if inlined {
8429                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8430                    inner_offset = next_offset;
8431                } else {
8432                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8433                    inner_depth.increment()?;
8434                }
8435                let val_ref = self.ambient_mark_vmo_exec.get_or_insert_with(|| {
8436                    fidl::new_empty!(
8437                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8438                        D
8439                    )
8440                });
8441                fidl::decode!(
8442                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8443                    D,
8444                    val_ref,
8445                    decoder,
8446                    inner_offset,
8447                    inner_depth
8448                )?;
8449                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8450                {
8451                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8452                }
8453                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8454                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8455                }
8456            }
8457
8458            next_offset += envelope_size;
8459            _next_ordinal_to_read += 1;
8460            if next_offset >= end_offset {
8461                return Ok(());
8462            }
8463
8464            // Decode unknown envelopes for gaps in ordinals.
8465            while _next_ordinal_to_read < 2 {
8466                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8467                _next_ordinal_to_read += 1;
8468                next_offset += envelope_size;
8469            }
8470
8471            let next_out_of_line = decoder.next_out_of_line();
8472            let handles_before = decoder.remaining_handles();
8473            if let Some((inlined, num_bytes, num_handles)) =
8474                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8475            {
8476                let member_inline_size = <fidl::encoding::Vector<
8477                    fidl::encoding::BoundedString<4096>,
8478                    128,
8479                > as fidl::encoding::TypeMarker>::inline_size(
8480                    decoder.context
8481                );
8482                if inlined != (member_inline_size <= 4) {
8483                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8484                }
8485                let inner_offset;
8486                let mut inner_depth = depth.clone();
8487                if inlined {
8488                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8489                    inner_offset = next_offset;
8490                } else {
8491                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8492                    inner_depth.increment()?;
8493                }
8494                let val_ref = self.main_process_critical.get_or_insert_with(|| {
8495                    fidl::new_empty!(
8496                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8497                        D
8498                    )
8499                });
8500                fidl::decode!(
8501                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8502                    D,
8503                    val_ref,
8504                    decoder,
8505                    inner_offset,
8506                    inner_depth
8507                )?;
8508                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8509                {
8510                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8511                }
8512                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8513                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8514                }
8515            }
8516
8517            next_offset += envelope_size;
8518            _next_ordinal_to_read += 1;
8519            if next_offset >= end_offset {
8520                return Ok(());
8521            }
8522
8523            // Decode unknown envelopes for gaps in ordinals.
8524            while _next_ordinal_to_read < 3 {
8525                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8526                _next_ordinal_to_read += 1;
8527                next_offset += envelope_size;
8528            }
8529
8530            let next_out_of_line = decoder.next_out_of_line();
8531            let handles_before = decoder.remaining_handles();
8532            if let Some((inlined, num_bytes, num_handles)) =
8533                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8534            {
8535                let member_inline_size = <fidl::encoding::Vector<
8536                    fidl::encoding::BoundedString<4096>,
8537                    128,
8538                > as fidl::encoding::TypeMarker>::inline_size(
8539                    decoder.context
8540                );
8541                if inlined != (member_inline_size <= 4) {
8542                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8543                }
8544                let inner_offset;
8545                let mut inner_depth = depth.clone();
8546                if inlined {
8547                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8548                    inner_offset = next_offset;
8549                } else {
8550                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8551                    inner_depth.increment()?;
8552                }
8553                let val_ref = self.create_raw_processes.get_or_insert_with(|| {
8554                    fidl::new_empty!(
8555                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8556                        D
8557                    )
8558                });
8559                fidl::decode!(
8560                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8561                    D,
8562                    val_ref,
8563                    decoder,
8564                    inner_offset,
8565                    inner_depth
8566                )?;
8567                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8568                {
8569                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8570                }
8571                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8572                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8573                }
8574            }
8575
8576            next_offset += envelope_size;
8577
8578            // Decode the remaining unknown envelopes.
8579            while next_offset < end_offset {
8580                _next_ordinal_to_read += 1;
8581                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8582                next_offset += envelope_size;
8583            }
8584
8585            Ok(())
8586        }
8587    }
8588
8589    impl Namespace {
8590        #[inline(always)]
8591        fn max_ordinal_present(&self) -> u64 {
8592            if let Some(_) = self.capability {
8593                return 1;
8594            }
8595            0
8596        }
8597    }
8598
8599    impl fidl::encoding::ValueTypeMarker for Namespace {
8600        type Borrowed<'a> = &'a Self;
8601        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8602            value
8603        }
8604    }
8605
8606    unsafe impl fidl::encoding::TypeMarker for Namespace {
8607        type Owned = Self;
8608
8609        #[inline(always)]
8610        fn inline_align(_context: fidl::encoding::Context) -> usize {
8611            8
8612        }
8613
8614        #[inline(always)]
8615        fn inline_size(_context: fidl::encoding::Context) -> usize {
8616            16
8617        }
8618    }
8619
8620    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Namespace, D>
8621        for &Namespace
8622    {
8623        unsafe fn encode(
8624            self,
8625            encoder: &mut fidl::encoding::Encoder<'_, D>,
8626            offset: usize,
8627            mut depth: fidl::encoding::Depth,
8628        ) -> fidl::Result<()> {
8629            encoder.debug_check_bounds::<Namespace>(offset);
8630            // Vector header
8631            let max_ordinal: u64 = self.max_ordinal_present();
8632            encoder.write_num(max_ordinal, offset);
8633            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8634            // Calling encoder.out_of_line_offset(0) is not allowed.
8635            if max_ordinal == 0 {
8636                return Ok(());
8637            }
8638            depth.increment()?;
8639            let envelope_size = 8;
8640            let bytes_len = max_ordinal as usize * envelope_size;
8641            #[allow(unused_variables)]
8642            let offset = encoder.out_of_line_offset(bytes_len);
8643            let mut _prev_end_offset: usize = 0;
8644            if 1 > max_ordinal {
8645                return Ok(());
8646            }
8647
8648            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8649            // are envelope_size bytes.
8650            let cur_offset: usize = (1 - 1) * envelope_size;
8651
8652            // Zero reserved fields.
8653            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8654
8655            // Safety:
8656            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8657            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8658            //   envelope_size bytes, there is always sufficient room.
8659            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
8660                self.capability
8661                    .as_ref()
8662                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
8663                encoder,
8664                offset + cur_offset,
8665                depth,
8666            )?;
8667
8668            _prev_end_offset = cur_offset + envelope_size;
8669
8670            Ok(())
8671        }
8672    }
8673
8674    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Namespace {
8675        #[inline(always)]
8676        fn new_empty() -> Self {
8677            Self::default()
8678        }
8679
8680        unsafe fn decode(
8681            &mut self,
8682            decoder: &mut fidl::encoding::Decoder<'_, D>,
8683            offset: usize,
8684            mut depth: fidl::encoding::Depth,
8685        ) -> fidl::Result<()> {
8686            decoder.debug_check_bounds::<Self>(offset);
8687            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8688                None => return Err(fidl::Error::NotNullable),
8689                Some(len) => len,
8690            };
8691            // Calling decoder.out_of_line_offset(0) is not allowed.
8692            if len == 0 {
8693                return Ok(());
8694            };
8695            depth.increment()?;
8696            let envelope_size = 8;
8697            let bytes_len = len * envelope_size;
8698            let offset = decoder.out_of_line_offset(bytes_len)?;
8699            // Decode the envelope for each type.
8700            let mut _next_ordinal_to_read = 0;
8701            let mut next_offset = offset;
8702            let end_offset = offset + bytes_len;
8703            _next_ordinal_to_read += 1;
8704            if next_offset >= end_offset {
8705                return Ok(());
8706            }
8707
8708            // Decode unknown envelopes for gaps in ordinals.
8709            while _next_ordinal_to_read < 1 {
8710                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8711                _next_ordinal_to_read += 1;
8712                next_offset += envelope_size;
8713            }
8714
8715            let next_out_of_line = decoder.next_out_of_line();
8716            let handles_before = decoder.remaining_handles();
8717            if let Some((inlined, num_bytes, num_handles)) =
8718                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8719            {
8720                let member_inline_size =
8721                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
8722                        decoder.context,
8723                    );
8724                if inlined != (member_inline_size <= 4) {
8725                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8726                }
8727                let inner_offset;
8728                let mut inner_depth = depth.clone();
8729                if inlined {
8730                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8731                    inner_offset = next_offset;
8732                } else {
8733                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8734                    inner_depth.increment()?;
8735                }
8736                let val_ref =
8737                    self.capability.get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
8738                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
8739                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8740                {
8741                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8742                }
8743                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8744                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8745                }
8746            }
8747
8748            next_offset += envelope_size;
8749
8750            // Decode the remaining unknown envelopes.
8751            while next_offset < end_offset {
8752                _next_ordinal_to_read += 1;
8753                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8754                next_offset += envelope_size;
8755            }
8756
8757            Ok(())
8758        }
8759    }
8760
8761    impl SecurityPolicy {
8762        #[inline(always)]
8763        fn max_ordinal_present(&self) -> u64 {
8764            if let Some(_) = self.child_policy {
8765                return 4;
8766            }
8767            if let Some(_) = self.debug_registration_policy {
8768                return 3;
8769            }
8770            if let Some(_) = self.capability_policy {
8771                return 2;
8772            }
8773            if let Some(_) = self.job_policy {
8774                return 1;
8775            }
8776            0
8777        }
8778    }
8779
8780    impl fidl::encoding::ValueTypeMarker for SecurityPolicy {
8781        type Borrowed<'a> = &'a Self;
8782        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8783            value
8784        }
8785    }
8786
8787    unsafe impl fidl::encoding::TypeMarker for SecurityPolicy {
8788        type Owned = Self;
8789
8790        #[inline(always)]
8791        fn inline_align(_context: fidl::encoding::Context) -> usize {
8792            8
8793        }
8794
8795        #[inline(always)]
8796        fn inline_size(_context: fidl::encoding::Context) -> usize {
8797            16
8798        }
8799    }
8800
8801    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SecurityPolicy, D>
8802        for &SecurityPolicy
8803    {
8804        unsafe fn encode(
8805            self,
8806            encoder: &mut fidl::encoding::Encoder<'_, D>,
8807            offset: usize,
8808            mut depth: fidl::encoding::Depth,
8809        ) -> fidl::Result<()> {
8810            encoder.debug_check_bounds::<SecurityPolicy>(offset);
8811            // Vector header
8812            let max_ordinal: u64 = self.max_ordinal_present();
8813            encoder.write_num(max_ordinal, offset);
8814            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8815            // Calling encoder.out_of_line_offset(0) is not allowed.
8816            if max_ordinal == 0 {
8817                return Ok(());
8818            }
8819            depth.increment()?;
8820            let envelope_size = 8;
8821            let bytes_len = max_ordinal as usize * envelope_size;
8822            #[allow(unused_variables)]
8823            let offset = encoder.out_of_line_offset(bytes_len);
8824            let mut _prev_end_offset: usize = 0;
8825            if 1 > max_ordinal {
8826                return Ok(());
8827            }
8828
8829            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8830            // are envelope_size bytes.
8831            let cur_offset: usize = (1 - 1) * envelope_size;
8832
8833            // Zero reserved fields.
8834            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8835
8836            // Safety:
8837            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8838            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8839            //   envelope_size bytes, there is always sufficient room.
8840            fidl::encoding::encode_in_envelope_optional::<JobPolicyAllowlists, D>(
8841                self.job_policy
8842                    .as_ref()
8843                    .map(<JobPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow),
8844                encoder,
8845                offset + cur_offset,
8846                depth,
8847            )?;
8848
8849            _prev_end_offset = cur_offset + envelope_size;
8850            if 2 > max_ordinal {
8851                return Ok(());
8852            }
8853
8854            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8855            // are envelope_size bytes.
8856            let cur_offset: usize = (2 - 1) * envelope_size;
8857
8858            // Zero reserved fields.
8859            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8860
8861            // Safety:
8862            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8863            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8864            //   envelope_size bytes, there is always sufficient room.
8865            fidl::encoding::encode_in_envelope_optional::<CapabilityPolicyAllowlists, D>(
8866                self.capability_policy
8867                    .as_ref()
8868                    .map(<CapabilityPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow),
8869                encoder,
8870                offset + cur_offset,
8871                depth,
8872            )?;
8873
8874            _prev_end_offset = cur_offset + envelope_size;
8875            if 3 > max_ordinal {
8876                return Ok(());
8877            }
8878
8879            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8880            // are envelope_size bytes.
8881            let cur_offset: usize = (3 - 1) * envelope_size;
8882
8883            // Zero reserved fields.
8884            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8885
8886            // Safety:
8887            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8888            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8889            //   envelope_size bytes, there is always sufficient room.
8890            fidl::encoding::encode_in_envelope_optional::<DebugRegistrationPolicyAllowlists, D>(
8891                self.debug_registration_policy.as_ref().map(
8892                    <DebugRegistrationPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow,
8893                ),
8894                encoder,
8895                offset + cur_offset,
8896                depth,
8897            )?;
8898
8899            _prev_end_offset = cur_offset + envelope_size;
8900            if 4 > max_ordinal {
8901                return Ok(());
8902            }
8903
8904            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8905            // are envelope_size bytes.
8906            let cur_offset: usize = (4 - 1) * envelope_size;
8907
8908            // Zero reserved fields.
8909            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8910
8911            // Safety:
8912            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8913            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8914            //   envelope_size bytes, there is always sufficient room.
8915            fidl::encoding::encode_in_envelope_optional::<ChildPolicyAllowlists, D>(
8916                self.child_policy
8917                    .as_ref()
8918                    .map(<ChildPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow),
8919                encoder,
8920                offset + cur_offset,
8921                depth,
8922            )?;
8923
8924            _prev_end_offset = cur_offset + envelope_size;
8925
8926            Ok(())
8927        }
8928    }
8929
8930    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SecurityPolicy {
8931        #[inline(always)]
8932        fn new_empty() -> Self {
8933            Self::default()
8934        }
8935
8936        unsafe fn decode(
8937            &mut self,
8938            decoder: &mut fidl::encoding::Decoder<'_, D>,
8939            offset: usize,
8940            mut depth: fidl::encoding::Depth,
8941        ) -> fidl::Result<()> {
8942            decoder.debug_check_bounds::<Self>(offset);
8943            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8944                None => return Err(fidl::Error::NotNullable),
8945                Some(len) => len,
8946            };
8947            // Calling decoder.out_of_line_offset(0) is not allowed.
8948            if len == 0 {
8949                return Ok(());
8950            };
8951            depth.increment()?;
8952            let envelope_size = 8;
8953            let bytes_len = len * envelope_size;
8954            let offset = decoder.out_of_line_offset(bytes_len)?;
8955            // Decode the envelope for each type.
8956            let mut _next_ordinal_to_read = 0;
8957            let mut next_offset = offset;
8958            let end_offset = offset + bytes_len;
8959            _next_ordinal_to_read += 1;
8960            if next_offset >= end_offset {
8961                return Ok(());
8962            }
8963
8964            // Decode unknown envelopes for gaps in ordinals.
8965            while _next_ordinal_to_read < 1 {
8966                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8967                _next_ordinal_to_read += 1;
8968                next_offset += envelope_size;
8969            }
8970
8971            let next_out_of_line = decoder.next_out_of_line();
8972            let handles_before = decoder.remaining_handles();
8973            if let Some((inlined, num_bytes, num_handles)) =
8974                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8975            {
8976                let member_inline_size =
8977                    <JobPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
8978                        decoder.context,
8979                    );
8980                if inlined != (member_inline_size <= 4) {
8981                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8982                }
8983                let inner_offset;
8984                let mut inner_depth = depth.clone();
8985                if inlined {
8986                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8987                    inner_offset = next_offset;
8988                } else {
8989                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8990                    inner_depth.increment()?;
8991                }
8992                let val_ref =
8993                    self.job_policy.get_or_insert_with(|| fidl::new_empty!(JobPolicyAllowlists, D));
8994                fidl::decode!(JobPolicyAllowlists, D, val_ref, decoder, inner_offset, inner_depth)?;
8995                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8996                {
8997                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8998                }
8999                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9000                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9001                }
9002            }
9003
9004            next_offset += envelope_size;
9005            _next_ordinal_to_read += 1;
9006            if next_offset >= end_offset {
9007                return Ok(());
9008            }
9009
9010            // Decode unknown envelopes for gaps in ordinals.
9011            while _next_ordinal_to_read < 2 {
9012                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9013                _next_ordinal_to_read += 1;
9014                next_offset += envelope_size;
9015            }
9016
9017            let next_out_of_line = decoder.next_out_of_line();
9018            let handles_before = decoder.remaining_handles();
9019            if let Some((inlined, num_bytes, num_handles)) =
9020                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9021            {
9022                let member_inline_size =
9023                    <CapabilityPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
9024                        decoder.context,
9025                    );
9026                if inlined != (member_inline_size <= 4) {
9027                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9028                }
9029                let inner_offset;
9030                let mut inner_depth = depth.clone();
9031                if inlined {
9032                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9033                    inner_offset = next_offset;
9034                } else {
9035                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9036                    inner_depth.increment()?;
9037                }
9038                let val_ref = self
9039                    .capability_policy
9040                    .get_or_insert_with(|| fidl::new_empty!(CapabilityPolicyAllowlists, D));
9041                fidl::decode!(
9042                    CapabilityPolicyAllowlists,
9043                    D,
9044                    val_ref,
9045                    decoder,
9046                    inner_offset,
9047                    inner_depth
9048                )?;
9049                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9050                {
9051                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9052                }
9053                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9054                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9055                }
9056            }
9057
9058            next_offset += envelope_size;
9059            _next_ordinal_to_read += 1;
9060            if next_offset >= end_offset {
9061                return Ok(());
9062            }
9063
9064            // Decode unknown envelopes for gaps in ordinals.
9065            while _next_ordinal_to_read < 3 {
9066                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9067                _next_ordinal_to_read += 1;
9068                next_offset += envelope_size;
9069            }
9070
9071            let next_out_of_line = decoder.next_out_of_line();
9072            let handles_before = decoder.remaining_handles();
9073            if let Some((inlined, num_bytes, num_handles)) =
9074                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9075            {
9076                let member_inline_size =
9077                    <DebugRegistrationPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
9078                        decoder.context,
9079                    );
9080                if inlined != (member_inline_size <= 4) {
9081                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9082                }
9083                let inner_offset;
9084                let mut inner_depth = depth.clone();
9085                if inlined {
9086                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9087                    inner_offset = next_offset;
9088                } else {
9089                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9090                    inner_depth.increment()?;
9091                }
9092                let val_ref = self
9093                    .debug_registration_policy
9094                    .get_or_insert_with(|| fidl::new_empty!(DebugRegistrationPolicyAllowlists, D));
9095                fidl::decode!(
9096                    DebugRegistrationPolicyAllowlists,
9097                    D,
9098                    val_ref,
9099                    decoder,
9100                    inner_offset,
9101                    inner_depth
9102                )?;
9103                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9104                {
9105                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9106                }
9107                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9108                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9109                }
9110            }
9111
9112            next_offset += envelope_size;
9113            _next_ordinal_to_read += 1;
9114            if next_offset >= end_offset {
9115                return Ok(());
9116            }
9117
9118            // Decode unknown envelopes for gaps in ordinals.
9119            while _next_ordinal_to_read < 4 {
9120                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9121                _next_ordinal_to_read += 1;
9122                next_offset += envelope_size;
9123            }
9124
9125            let next_out_of_line = decoder.next_out_of_line();
9126            let handles_before = decoder.remaining_handles();
9127            if let Some((inlined, num_bytes, num_handles)) =
9128                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9129            {
9130                let member_inline_size =
9131                    <ChildPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
9132                        decoder.context,
9133                    );
9134                if inlined != (member_inline_size <= 4) {
9135                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9136                }
9137                let inner_offset;
9138                let mut inner_depth = depth.clone();
9139                if inlined {
9140                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9141                    inner_offset = next_offset;
9142                } else {
9143                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9144                    inner_depth.increment()?;
9145                }
9146                let val_ref = self
9147                    .child_policy
9148                    .get_or_insert_with(|| fidl::new_empty!(ChildPolicyAllowlists, D));
9149                fidl::decode!(
9150                    ChildPolicyAllowlists,
9151                    D,
9152                    val_ref,
9153                    decoder,
9154                    inner_offset,
9155                    inner_depth
9156                )?;
9157                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9158                {
9159                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9160                }
9161                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9162                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9163                }
9164            }
9165
9166            next_offset += envelope_size;
9167
9168            // Decode the remaining unknown envelopes.
9169            while next_offset < end_offset {
9170                _next_ordinal_to_read += 1;
9171                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9172                next_offset += envelope_size;
9173            }
9174
9175            Ok(())
9176        }
9177    }
9178
9179    impl Sources {
9180        #[inline(always)]
9181        fn max_ordinal_present(&self) -> u64 {
9182            if let Some(_) = self.capability_type {
9183                return 7;
9184            }
9185            if let Some(_) = self.component {
9186                return 6;
9187            }
9188            if let Some(_) = self.namespace {
9189                return 5;
9190            }
9191            if let Some(_) = self.collection {
9192                return 4;
9193            }
9194            if let Some(_) = self.capability {
9195                return 3;
9196            }
9197            if let Some(_) = self.builtin {
9198                return 2;
9199            }
9200            if let Some(_) = self.framework {
9201                return 1;
9202            }
9203            0
9204        }
9205    }
9206
9207    impl fidl::encoding::ValueTypeMarker for Sources {
9208        type Borrowed<'a> = &'a Self;
9209        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9210            value
9211        }
9212    }
9213
9214    unsafe impl fidl::encoding::TypeMarker for Sources {
9215        type Owned = Self;
9216
9217        #[inline(always)]
9218        fn inline_align(_context: fidl::encoding::Context) -> usize {
9219            8
9220        }
9221
9222        #[inline(always)]
9223        fn inline_size(_context: fidl::encoding::Context) -> usize {
9224            16
9225        }
9226    }
9227
9228    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Sources, D> for &Sources {
9229        unsafe fn encode(
9230            self,
9231            encoder: &mut fidl::encoding::Encoder<'_, D>,
9232            offset: usize,
9233            mut depth: fidl::encoding::Depth,
9234        ) -> fidl::Result<()> {
9235            encoder.debug_check_bounds::<Sources>(offset);
9236            // Vector header
9237            let max_ordinal: u64 = self.max_ordinal_present();
9238            encoder.write_num(max_ordinal, offset);
9239            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9240            // Calling encoder.out_of_line_offset(0) is not allowed.
9241            if max_ordinal == 0 {
9242                return Ok(());
9243            }
9244            depth.increment()?;
9245            let envelope_size = 8;
9246            let bytes_len = max_ordinal as usize * envelope_size;
9247            #[allow(unused_variables)]
9248            let offset = encoder.out_of_line_offset(bytes_len);
9249            let mut _prev_end_offset: usize = 0;
9250            if 1 > max_ordinal {
9251                return Ok(());
9252            }
9253
9254            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9255            // are envelope_size bytes.
9256            let cur_offset: usize = (1 - 1) * envelope_size;
9257
9258            // Zero reserved fields.
9259            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9260
9261            // Safety:
9262            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9263            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9264            //   envelope_size bytes, there is always sufficient room.
9265            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9266                self.framework.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9267                encoder,
9268                offset + cur_offset,
9269                depth,
9270            )?;
9271
9272            _prev_end_offset = cur_offset + envelope_size;
9273            if 2 > max_ordinal {
9274                return Ok(());
9275            }
9276
9277            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9278            // are envelope_size bytes.
9279            let cur_offset: usize = (2 - 1) * envelope_size;
9280
9281            // Zero reserved fields.
9282            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9283
9284            // Safety:
9285            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9286            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9287            //   envelope_size bytes, there is always sufficient room.
9288            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9289                self.builtin.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9290                encoder,
9291                offset + cur_offset,
9292                depth,
9293            )?;
9294
9295            _prev_end_offset = cur_offset + envelope_size;
9296            if 3 > max_ordinal {
9297                return Ok(());
9298            }
9299
9300            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9301            // are envelope_size bytes.
9302            let cur_offset: usize = (3 - 1) * envelope_size;
9303
9304            // Zero reserved fields.
9305            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9306
9307            // Safety:
9308            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9309            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9310            //   envelope_size bytes, there is always sufficient room.
9311            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9312                self.capability.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9313                encoder,
9314                offset + cur_offset,
9315                depth,
9316            )?;
9317
9318            _prev_end_offset = cur_offset + envelope_size;
9319            if 4 > max_ordinal {
9320                return Ok(());
9321            }
9322
9323            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9324            // are envelope_size bytes.
9325            let cur_offset: usize = (4 - 1) * envelope_size;
9326
9327            // Zero reserved fields.
9328            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9329
9330            // Safety:
9331            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9332            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9333            //   envelope_size bytes, there is always sufficient room.
9334            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9335                self.collection.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9336                encoder,
9337                offset + cur_offset,
9338                depth,
9339            )?;
9340
9341            _prev_end_offset = cur_offset + envelope_size;
9342            if 5 > max_ordinal {
9343                return Ok(());
9344            }
9345
9346            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9347            // are envelope_size bytes.
9348            let cur_offset: usize = (5 - 1) * envelope_size;
9349
9350            // Zero reserved fields.
9351            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9352
9353            // Safety:
9354            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9355            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9356            //   envelope_size bytes, there is always sufficient room.
9357            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9358                self.namespace.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9359                encoder,
9360                offset + cur_offset,
9361                depth,
9362            )?;
9363
9364            _prev_end_offset = cur_offset + envelope_size;
9365            if 6 > max_ordinal {
9366                return Ok(());
9367            }
9368
9369            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9370            // are envelope_size bytes.
9371            let cur_offset: usize = (6 - 1) * envelope_size;
9372
9373            // Zero reserved fields.
9374            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9375
9376            // Safety:
9377            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9378            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9379            //   envelope_size bytes, there is always sufficient room.
9380            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9381                self.component.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9382                encoder,
9383                offset + cur_offset,
9384                depth,
9385            )?;
9386
9387            _prev_end_offset = cur_offset + envelope_size;
9388            if 7 > max_ordinal {
9389                return Ok(());
9390            }
9391
9392            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9393            // are envelope_size bytes.
9394            let cur_offset: usize = (7 - 1) * envelope_size;
9395
9396            // Zero reserved fields.
9397            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9398
9399            // Safety:
9400            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9401            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9402            //   envelope_size bytes, there is always sufficient room.
9403            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
9404                self.capability_type.as_ref().map(
9405                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
9406                ),
9407                encoder,
9408                offset + cur_offset,
9409                depth,
9410            )?;
9411
9412            _prev_end_offset = cur_offset + envelope_size;
9413
9414            Ok(())
9415        }
9416    }
9417
9418    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Sources {
9419        #[inline(always)]
9420        fn new_empty() -> Self {
9421            Self::default()
9422        }
9423
9424        unsafe fn decode(
9425            &mut self,
9426            decoder: &mut fidl::encoding::Decoder<'_, D>,
9427            offset: usize,
9428            mut depth: fidl::encoding::Depth,
9429        ) -> fidl::Result<()> {
9430            decoder.debug_check_bounds::<Self>(offset);
9431            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9432                None => return Err(fidl::Error::NotNullable),
9433                Some(len) => len,
9434            };
9435            // Calling decoder.out_of_line_offset(0) is not allowed.
9436            if len == 0 {
9437                return Ok(());
9438            };
9439            depth.increment()?;
9440            let envelope_size = 8;
9441            let bytes_len = len * envelope_size;
9442            let offset = decoder.out_of_line_offset(bytes_len)?;
9443            // Decode the envelope for each type.
9444            let mut _next_ordinal_to_read = 0;
9445            let mut next_offset = offset;
9446            let end_offset = offset + bytes_len;
9447            _next_ordinal_to_read += 1;
9448            if next_offset >= end_offset {
9449                return Ok(());
9450            }
9451
9452            // Decode unknown envelopes for gaps in ordinals.
9453            while _next_ordinal_to_read < 1 {
9454                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9455                _next_ordinal_to_read += 1;
9456                next_offset += envelope_size;
9457            }
9458
9459            let next_out_of_line = decoder.next_out_of_line();
9460            let handles_before = decoder.remaining_handles();
9461            if let Some((inlined, num_bytes, num_handles)) =
9462                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9463            {
9464                let member_inline_size =
9465                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9466                if inlined != (member_inline_size <= 4) {
9467                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9468                }
9469                let inner_offset;
9470                let mut inner_depth = depth.clone();
9471                if inlined {
9472                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9473                    inner_offset = next_offset;
9474                } else {
9475                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9476                    inner_depth.increment()?;
9477                }
9478                let val_ref = self.framework.get_or_insert_with(|| fidl::new_empty!(bool, D));
9479                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9480                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9481                {
9482                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9483                }
9484                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9485                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9486                }
9487            }
9488
9489            next_offset += envelope_size;
9490            _next_ordinal_to_read += 1;
9491            if next_offset >= end_offset {
9492                return Ok(());
9493            }
9494
9495            // Decode unknown envelopes for gaps in ordinals.
9496            while _next_ordinal_to_read < 2 {
9497                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9498                _next_ordinal_to_read += 1;
9499                next_offset += envelope_size;
9500            }
9501
9502            let next_out_of_line = decoder.next_out_of_line();
9503            let handles_before = decoder.remaining_handles();
9504            if let Some((inlined, num_bytes, num_handles)) =
9505                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9506            {
9507                let member_inline_size =
9508                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9509                if inlined != (member_inline_size <= 4) {
9510                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9511                }
9512                let inner_offset;
9513                let mut inner_depth = depth.clone();
9514                if inlined {
9515                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9516                    inner_offset = next_offset;
9517                } else {
9518                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9519                    inner_depth.increment()?;
9520                }
9521                let val_ref = self.builtin.get_or_insert_with(|| fidl::new_empty!(bool, D));
9522                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9523                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9524                {
9525                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9526                }
9527                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9528                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9529                }
9530            }
9531
9532            next_offset += envelope_size;
9533            _next_ordinal_to_read += 1;
9534            if next_offset >= end_offset {
9535                return Ok(());
9536            }
9537
9538            // Decode unknown envelopes for gaps in ordinals.
9539            while _next_ordinal_to_read < 3 {
9540                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9541                _next_ordinal_to_read += 1;
9542                next_offset += envelope_size;
9543            }
9544
9545            let next_out_of_line = decoder.next_out_of_line();
9546            let handles_before = decoder.remaining_handles();
9547            if let Some((inlined, num_bytes, num_handles)) =
9548                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9549            {
9550                let member_inline_size =
9551                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9552                if inlined != (member_inline_size <= 4) {
9553                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9554                }
9555                let inner_offset;
9556                let mut inner_depth = depth.clone();
9557                if inlined {
9558                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9559                    inner_offset = next_offset;
9560                } else {
9561                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9562                    inner_depth.increment()?;
9563                }
9564                let val_ref = self.capability.get_or_insert_with(|| fidl::new_empty!(bool, D));
9565                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9566                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9567                {
9568                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9569                }
9570                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9571                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9572                }
9573            }
9574
9575            next_offset += envelope_size;
9576            _next_ordinal_to_read += 1;
9577            if next_offset >= end_offset {
9578                return Ok(());
9579            }
9580
9581            // Decode unknown envelopes for gaps in ordinals.
9582            while _next_ordinal_to_read < 4 {
9583                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9584                _next_ordinal_to_read += 1;
9585                next_offset += envelope_size;
9586            }
9587
9588            let next_out_of_line = decoder.next_out_of_line();
9589            let handles_before = decoder.remaining_handles();
9590            if let Some((inlined, num_bytes, num_handles)) =
9591                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9592            {
9593                let member_inline_size =
9594                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9595                if inlined != (member_inline_size <= 4) {
9596                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9597                }
9598                let inner_offset;
9599                let mut inner_depth = depth.clone();
9600                if inlined {
9601                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9602                    inner_offset = next_offset;
9603                } else {
9604                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9605                    inner_depth.increment()?;
9606                }
9607                let val_ref = self.collection.get_or_insert_with(|| fidl::new_empty!(bool, D));
9608                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9609                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9610                {
9611                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9612                }
9613                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9614                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9615                }
9616            }
9617
9618            next_offset += envelope_size;
9619            _next_ordinal_to_read += 1;
9620            if next_offset >= end_offset {
9621                return Ok(());
9622            }
9623
9624            // Decode unknown envelopes for gaps in ordinals.
9625            while _next_ordinal_to_read < 5 {
9626                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9627                _next_ordinal_to_read += 1;
9628                next_offset += envelope_size;
9629            }
9630
9631            let next_out_of_line = decoder.next_out_of_line();
9632            let handles_before = decoder.remaining_handles();
9633            if let Some((inlined, num_bytes, num_handles)) =
9634                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9635            {
9636                let member_inline_size =
9637                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9638                if inlined != (member_inline_size <= 4) {
9639                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9640                }
9641                let inner_offset;
9642                let mut inner_depth = depth.clone();
9643                if inlined {
9644                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9645                    inner_offset = next_offset;
9646                } else {
9647                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9648                    inner_depth.increment()?;
9649                }
9650                let val_ref = self.namespace.get_or_insert_with(|| fidl::new_empty!(bool, D));
9651                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9652                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9653                {
9654                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9655                }
9656                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9657                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9658                }
9659            }
9660
9661            next_offset += envelope_size;
9662            _next_ordinal_to_read += 1;
9663            if next_offset >= end_offset {
9664                return Ok(());
9665            }
9666
9667            // Decode unknown envelopes for gaps in ordinals.
9668            while _next_ordinal_to_read < 6 {
9669                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9670                _next_ordinal_to_read += 1;
9671                next_offset += envelope_size;
9672            }
9673
9674            let next_out_of_line = decoder.next_out_of_line();
9675            let handles_before = decoder.remaining_handles();
9676            if let Some((inlined, num_bytes, num_handles)) =
9677                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9678            {
9679                let member_inline_size =
9680                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9681                if inlined != (member_inline_size <= 4) {
9682                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9683                }
9684                let inner_offset;
9685                let mut inner_depth = depth.clone();
9686                if inlined {
9687                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9688                    inner_offset = next_offset;
9689                } else {
9690                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9691                    inner_depth.increment()?;
9692                }
9693                let val_ref = self.component.get_or_insert_with(|| fidl::new_empty!(bool, D));
9694                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9695                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9696                {
9697                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9698                }
9699                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9700                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9701                }
9702            }
9703
9704            next_offset += envelope_size;
9705            _next_ordinal_to_read += 1;
9706            if next_offset >= end_offset {
9707                return Ok(());
9708            }
9709
9710            // Decode unknown envelopes for gaps in ordinals.
9711            while _next_ordinal_to_read < 7 {
9712                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9713                _next_ordinal_to_read += 1;
9714                next_offset += envelope_size;
9715            }
9716
9717            let next_out_of_line = decoder.next_out_of_line();
9718            let handles_before = decoder.remaining_handles();
9719            if let Some((inlined, num_bytes, num_handles)) =
9720                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9721            {
9722                let member_inline_size =
9723                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
9724                        decoder.context,
9725                    );
9726                if inlined != (member_inline_size <= 4) {
9727                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9728                }
9729                let inner_offset;
9730                let mut inner_depth = depth.clone();
9731                if inlined {
9732                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9733                    inner_offset = next_offset;
9734                } else {
9735                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9736                    inner_depth.increment()?;
9737                }
9738                let val_ref = self
9739                    .capability_type
9740                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
9741                fidl::decode!(
9742                    fidl::encoding::BoundedString<100>,
9743                    D,
9744                    val_ref,
9745                    decoder,
9746                    inner_offset,
9747                    inner_depth
9748                )?;
9749                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9750                {
9751                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9752                }
9753                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9754                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9755                }
9756            }
9757
9758            next_offset += envelope_size;
9759
9760            // Decode the remaining unknown envelopes.
9761            while next_offset < end_offset {
9762                _next_ordinal_to_read += 1;
9763                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9764                next_offset += envelope_size;
9765            }
9766
9767            Ok(())
9768        }
9769    }
9770
9771    impl Void {
9772        #[inline(always)]
9773        fn max_ordinal_present(&self) -> u64 {
9774            if let Some(_) = self.moniker {
9775                return 2;
9776            }
9777            if let Some(_) = self.capability {
9778                return 1;
9779            }
9780            0
9781        }
9782    }
9783
9784    impl fidl::encoding::ValueTypeMarker for Void {
9785        type Borrowed<'a> = &'a Self;
9786        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9787            value
9788        }
9789    }
9790
9791    unsafe impl fidl::encoding::TypeMarker for Void {
9792        type Owned = Self;
9793
9794        #[inline(always)]
9795        fn inline_align(_context: fidl::encoding::Context) -> usize {
9796            8
9797        }
9798
9799        #[inline(always)]
9800        fn inline_size(_context: fidl::encoding::Context) -> usize {
9801            16
9802        }
9803    }
9804
9805    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Void, D> for &Void {
9806        unsafe fn encode(
9807            self,
9808            encoder: &mut fidl::encoding::Encoder<'_, D>,
9809            offset: usize,
9810            mut depth: fidl::encoding::Depth,
9811        ) -> fidl::Result<()> {
9812            encoder.debug_check_bounds::<Void>(offset);
9813            // Vector header
9814            let max_ordinal: u64 = self.max_ordinal_present();
9815            encoder.write_num(max_ordinal, offset);
9816            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9817            // Calling encoder.out_of_line_offset(0) is not allowed.
9818            if max_ordinal == 0 {
9819                return Ok(());
9820            }
9821            depth.increment()?;
9822            let envelope_size = 8;
9823            let bytes_len = max_ordinal as usize * envelope_size;
9824            #[allow(unused_variables)]
9825            let offset = encoder.out_of_line_offset(bytes_len);
9826            let mut _prev_end_offset: usize = 0;
9827            if 1 > max_ordinal {
9828                return Ok(());
9829            }
9830
9831            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9832            // are envelope_size bytes.
9833            let cur_offset: usize = (1 - 1) * envelope_size;
9834
9835            // Zero reserved fields.
9836            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9837
9838            // Safety:
9839            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9840            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9841            //   envelope_size bytes, there is always sufficient room.
9842            fidl::encoding::encode_in_envelope_optional::<InternalCapability, D>(
9843                self.capability
9844                    .as_ref()
9845                    .map(<InternalCapability as fidl::encoding::ValueTypeMarker>::borrow),
9846                encoder,
9847                offset + cur_offset,
9848                depth,
9849            )?;
9850
9851            _prev_end_offset = cur_offset + envelope_size;
9852            if 2 > max_ordinal {
9853                return Ok(());
9854            }
9855
9856            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9857            // are envelope_size bytes.
9858            let cur_offset: usize = (2 - 1) * envelope_size;
9859
9860            // Zero reserved fields.
9861            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9862
9863            // Safety:
9864            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9865            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9866            //   envelope_size bytes, there is always sufficient room.
9867            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
9868            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
9869            encoder, offset + cur_offset, depth
9870        )?;
9871
9872            _prev_end_offset = cur_offset + envelope_size;
9873
9874            Ok(())
9875        }
9876    }
9877
9878    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Void {
9879        #[inline(always)]
9880        fn new_empty() -> Self {
9881            Self::default()
9882        }
9883
9884        unsafe fn decode(
9885            &mut self,
9886            decoder: &mut fidl::encoding::Decoder<'_, D>,
9887            offset: usize,
9888            mut depth: fidl::encoding::Depth,
9889        ) -> fidl::Result<()> {
9890            decoder.debug_check_bounds::<Self>(offset);
9891            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9892                None => return Err(fidl::Error::NotNullable),
9893                Some(len) => len,
9894            };
9895            // Calling decoder.out_of_line_offset(0) is not allowed.
9896            if len == 0 {
9897                return Ok(());
9898            };
9899            depth.increment()?;
9900            let envelope_size = 8;
9901            let bytes_len = len * envelope_size;
9902            let offset = decoder.out_of_line_offset(bytes_len)?;
9903            // Decode the envelope for each type.
9904            let mut _next_ordinal_to_read = 0;
9905            let mut next_offset = offset;
9906            let end_offset = offset + bytes_len;
9907            _next_ordinal_to_read += 1;
9908            if next_offset >= end_offset {
9909                return Ok(());
9910            }
9911
9912            // Decode unknown envelopes for gaps in ordinals.
9913            while _next_ordinal_to_read < 1 {
9914                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9915                _next_ordinal_to_read += 1;
9916                next_offset += envelope_size;
9917            }
9918
9919            let next_out_of_line = decoder.next_out_of_line();
9920            let handles_before = decoder.remaining_handles();
9921            if let Some((inlined, num_bytes, num_handles)) =
9922                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9923            {
9924                let member_inline_size =
9925                    <InternalCapability as fidl::encoding::TypeMarker>::inline_size(
9926                        decoder.context,
9927                    );
9928                if inlined != (member_inline_size <= 4) {
9929                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9930                }
9931                let inner_offset;
9932                let mut inner_depth = depth.clone();
9933                if inlined {
9934                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9935                    inner_offset = next_offset;
9936                } else {
9937                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9938                    inner_depth.increment()?;
9939                }
9940                let val_ref =
9941                    self.capability.get_or_insert_with(|| fidl::new_empty!(InternalCapability, D));
9942                fidl::decode!(InternalCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
9943                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9944                {
9945                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9946                }
9947                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9948                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9949                }
9950            }
9951
9952            next_offset += envelope_size;
9953            _next_ordinal_to_read += 1;
9954            if next_offset >= end_offset {
9955                return Ok(());
9956            }
9957
9958            // Decode unknown envelopes for gaps in ordinals.
9959            while _next_ordinal_to_read < 2 {
9960                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9961                _next_ordinal_to_read += 1;
9962                next_offset += envelope_size;
9963            }
9964
9965            let next_out_of_line = decoder.next_out_of_line();
9966            let handles_before = decoder.remaining_handles();
9967            if let Some((inlined, num_bytes, num_handles)) =
9968                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9969            {
9970                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9971                if inlined != (member_inline_size <= 4) {
9972                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9973                }
9974                let inner_offset;
9975                let mut inner_depth = depth.clone();
9976                if inlined {
9977                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9978                    inner_offset = next_offset;
9979                } else {
9980                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9981                    inner_depth.increment()?;
9982                }
9983                let val_ref = self.moniker.get_or_insert_with(|| {
9984                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
9985                });
9986                fidl::decode!(
9987                    fidl::encoding::BoundedString<4096>,
9988                    D,
9989                    val_ref,
9990                    decoder,
9991                    inner_offset,
9992                    inner_depth
9993                )?;
9994                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9995                {
9996                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9997                }
9998                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9999                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10000                }
10001            }
10002
10003            next_offset += envelope_size;
10004
10005            // Decode the remaining unknown envelopes.
10006            while next_offset < end_offset {
10007                _next_ordinal_to_read += 1;
10008                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10009                next_offset += envelope_size;
10010            }
10011
10012            Ok(())
10013        }
10014    }
10015
10016    impl fidl::encoding::ValueTypeMarker for AggregateCapability {
10017        type Borrowed<'a> = &'a Self;
10018        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10019            value
10020        }
10021    }
10022
10023    unsafe impl fidl::encoding::TypeMarker for AggregateCapability {
10024        type Owned = Self;
10025
10026        #[inline(always)]
10027        fn inline_align(_context: fidl::encoding::Context) -> usize {
10028            8
10029        }
10030
10031        #[inline(always)]
10032        fn inline_size(_context: fidl::encoding::Context) -> usize {
10033            16
10034        }
10035    }
10036
10037    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AggregateCapability, D>
10038        for &AggregateCapability
10039    {
10040        #[inline]
10041        unsafe fn encode(
10042            self,
10043            encoder: &mut fidl::encoding::Encoder<'_, D>,
10044            offset: usize,
10045            _depth: fidl::encoding::Depth,
10046        ) -> fidl::Result<()> {
10047            encoder.debug_check_bounds::<AggregateCapability>(offset);
10048            encoder.write_num::<u64>(self.ordinal(), offset);
10049            match self {
10050                AggregateCapability::Service(ref val) => fidl::encoding::encode_in_envelope::<
10051                    fidl::encoding::BoundedString<100>,
10052                    D,
10053                >(
10054                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
10055                        val,
10056                    ),
10057                    encoder,
10058                    offset + 8,
10059                    _depth,
10060                ),
10061            }
10062        }
10063    }
10064
10065    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AggregateCapability {
10066        #[inline(always)]
10067        fn new_empty() -> Self {
10068            Self::Service(fidl::new_empty!(fidl::encoding::BoundedString<100>, D))
10069        }
10070
10071        #[inline]
10072        unsafe fn decode(
10073            &mut self,
10074            decoder: &mut fidl::encoding::Decoder<'_, D>,
10075            offset: usize,
10076            mut depth: fidl::encoding::Depth,
10077        ) -> fidl::Result<()> {
10078            decoder.debug_check_bounds::<Self>(offset);
10079            #[allow(unused_variables)]
10080            let next_out_of_line = decoder.next_out_of_line();
10081            let handles_before = decoder.remaining_handles();
10082            let (ordinal, inlined, num_bytes, num_handles) =
10083                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10084
10085            let member_inline_size = match ordinal {
10086                1 => {
10087                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
10088                        decoder.context,
10089                    )
10090                }
10091                _ => return Err(fidl::Error::UnknownUnionTag),
10092            };
10093
10094            if inlined != (member_inline_size <= 4) {
10095                return Err(fidl::Error::InvalidInlineBitInEnvelope);
10096            }
10097            let _inner_offset;
10098            if inlined {
10099                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10100                _inner_offset = offset + 8;
10101            } else {
10102                depth.increment()?;
10103                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10104            }
10105            match ordinal {
10106                1 => {
10107                    #[allow(irrefutable_let_patterns)]
10108                    if let AggregateCapability::Service(_) = self {
10109                        // Do nothing, read the value into the object
10110                    } else {
10111                        // Initialize `self` to the right variant
10112                        *self = AggregateCapability::Service(fidl::new_empty!(
10113                            fidl::encoding::BoundedString<100>,
10114                            D
10115                        ));
10116                    }
10117                    #[allow(irrefutable_let_patterns)]
10118                    if let AggregateCapability::Service(ref mut val) = self {
10119                        fidl::decode!(
10120                            fidl::encoding::BoundedString<100>,
10121                            D,
10122                            val,
10123                            decoder,
10124                            _inner_offset,
10125                            depth
10126                        )?;
10127                    } else {
10128                        unreachable!()
10129                    }
10130                }
10131                ordinal => panic!("unexpected ordinal {:?}", ordinal),
10132            }
10133            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10134                return Err(fidl::Error::InvalidNumBytesInEnvelope);
10135            }
10136            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10137                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10138            }
10139            Ok(())
10140        }
10141    }
10142
10143    impl fidl::encoding::ValueTypeMarker for AggregateMember {
10144        type Borrowed<'a> = &'a Self;
10145        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10146            value
10147        }
10148    }
10149
10150    unsafe impl fidl::encoding::TypeMarker for AggregateMember {
10151        type Owned = Self;
10152
10153        #[inline(always)]
10154        fn inline_align(_context: fidl::encoding::Context) -> usize {
10155            8
10156        }
10157
10158        #[inline(always)]
10159        fn inline_size(_context: fidl::encoding::Context) -> usize {
10160            16
10161        }
10162    }
10163
10164    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AggregateMember, D>
10165        for &AggregateMember
10166    {
10167        #[inline]
10168        unsafe fn encode(
10169            self,
10170            encoder: &mut fidl::encoding::Encoder<'_, D>,
10171            offset: usize,
10172            _depth: fidl::encoding::Depth,
10173        ) -> fidl::Result<()> {
10174            encoder.debug_check_bounds::<AggregateMember>(offset);
10175            encoder.write_num::<u64>(self.ordinal(), offset);
10176            match self {
10177            AggregateMember::Child(ref val) => {
10178                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::ChildRef, D>(
10179                    <fidl_fuchsia_component_decl__common::ChildRef as fidl::encoding::ValueTypeMarker>::borrow(val),
10180                    encoder, offset + 8, _depth
10181                )
10182            }
10183            AggregateMember::Collection(ref val) => {
10184                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<100>, D>(
10185                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(val),
10186                    encoder, offset + 8, _depth
10187                )
10188            }
10189            AggregateMember::Parent(ref val) => {
10190                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::ParentRef, D>(
10191                    <fidl_fuchsia_component_decl__common::ParentRef as fidl::encoding::ValueTypeMarker>::borrow(val),
10192                    encoder, offset + 8, _depth
10193                )
10194            }
10195            AggregateMember::Self_(ref val) => {
10196                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::SelfRef, D>(
10197                    <fidl_fuchsia_component_decl__common::SelfRef as fidl::encoding::ValueTypeMarker>::borrow(val),
10198                    encoder, offset + 8, _depth
10199                )
10200            }
10201        }
10202        }
10203    }
10204
10205    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AggregateMember {
10206        #[inline(always)]
10207        fn new_empty() -> Self {
10208            Self::Child(fidl::new_empty!(fidl_fuchsia_component_decl__common::ChildRef, D))
10209        }
10210
10211        #[inline]
10212        unsafe fn decode(
10213            &mut self,
10214            decoder: &mut fidl::encoding::Decoder<'_, D>,
10215            offset: usize,
10216            mut depth: fidl::encoding::Depth,
10217        ) -> fidl::Result<()> {
10218            decoder.debug_check_bounds::<Self>(offset);
10219            #[allow(unused_variables)]
10220            let next_out_of_line = decoder.next_out_of_line();
10221            let handles_before = decoder.remaining_handles();
10222            let (ordinal, inlined, num_bytes, num_handles) =
10223                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10224
10225            let member_inline_size = match ordinal {
10226            1 => <fidl_fuchsia_component_decl__common::ChildRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10227            2 => <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10228            3 => <fidl_fuchsia_component_decl__common::ParentRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10229            4 => <fidl_fuchsia_component_decl__common::SelfRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10230            _ => return Err(fidl::Error::UnknownUnionTag),
10231        };
10232
10233            if inlined != (member_inline_size <= 4) {
10234                return Err(fidl::Error::InvalidInlineBitInEnvelope);
10235            }
10236            let _inner_offset;
10237            if inlined {
10238                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10239                _inner_offset = offset + 8;
10240            } else {
10241                depth.increment()?;
10242                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10243            }
10244            match ordinal {
10245                1 => {
10246                    #[allow(irrefutable_let_patterns)]
10247                    if let AggregateMember::Child(_) = self {
10248                        // Do nothing, read the value into the object
10249                    } else {
10250                        // Initialize `self` to the right variant
10251                        *self = AggregateMember::Child(fidl::new_empty!(
10252                            fidl_fuchsia_component_decl__common::ChildRef,
10253                            D
10254                        ));
10255                    }
10256                    #[allow(irrefutable_let_patterns)]
10257                    if let AggregateMember::Child(ref mut val) = self {
10258                        fidl::decode!(
10259                            fidl_fuchsia_component_decl__common::ChildRef,
10260                            D,
10261                            val,
10262                            decoder,
10263                            _inner_offset,
10264                            depth
10265                        )?;
10266                    } else {
10267                        unreachable!()
10268                    }
10269                }
10270                2 => {
10271                    #[allow(irrefutable_let_patterns)]
10272                    if let AggregateMember::Collection(_) = self {
10273                        // Do nothing, read the value into the object
10274                    } else {
10275                        // Initialize `self` to the right variant
10276                        *self = AggregateMember::Collection(fidl::new_empty!(
10277                            fidl::encoding::BoundedString<100>,
10278                            D
10279                        ));
10280                    }
10281                    #[allow(irrefutable_let_patterns)]
10282                    if let AggregateMember::Collection(ref mut val) = self {
10283                        fidl::decode!(
10284                            fidl::encoding::BoundedString<100>,
10285                            D,
10286                            val,
10287                            decoder,
10288                            _inner_offset,
10289                            depth
10290                        )?;
10291                    } else {
10292                        unreachable!()
10293                    }
10294                }
10295                3 => {
10296                    #[allow(irrefutable_let_patterns)]
10297                    if let AggregateMember::Parent(_) = self {
10298                        // Do nothing, read the value into the object
10299                    } else {
10300                        // Initialize `self` to the right variant
10301                        *self = AggregateMember::Parent(fidl::new_empty!(
10302                            fidl_fuchsia_component_decl__common::ParentRef,
10303                            D
10304                        ));
10305                    }
10306                    #[allow(irrefutable_let_patterns)]
10307                    if let AggregateMember::Parent(ref mut val) = self {
10308                        fidl::decode!(
10309                            fidl_fuchsia_component_decl__common::ParentRef,
10310                            D,
10311                            val,
10312                            decoder,
10313                            _inner_offset,
10314                            depth
10315                        )?;
10316                    } else {
10317                        unreachable!()
10318                    }
10319                }
10320                4 => {
10321                    #[allow(irrefutable_let_patterns)]
10322                    if let AggregateMember::Self_(_) = self {
10323                        // Do nothing, read the value into the object
10324                    } else {
10325                        // Initialize `self` to the right variant
10326                        *self = AggregateMember::Self_(fidl::new_empty!(
10327                            fidl_fuchsia_component_decl__common::SelfRef,
10328                            D
10329                        ));
10330                    }
10331                    #[allow(irrefutable_let_patterns)]
10332                    if let AggregateMember::Self_(ref mut val) = self {
10333                        fidl::decode!(
10334                            fidl_fuchsia_component_decl__common::SelfRef,
10335                            D,
10336                            val,
10337                            decoder,
10338                            _inner_offset,
10339                            depth
10340                        )?;
10341                    } else {
10342                        unreachable!()
10343                    }
10344                }
10345                ordinal => panic!("unexpected ordinal {:?}", ordinal),
10346            }
10347            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10348                return Err(fidl::Error::InvalidNumBytesInEnvelope);
10349            }
10350            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10351                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10352            }
10353            Ok(())
10354        }
10355    }
10356
10357    impl fidl::encoding::ValueTypeMarker for AllowlistedCapability {
10358        type Borrowed<'a> = &'a Self;
10359        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10360            value
10361        }
10362    }
10363
10364    unsafe impl fidl::encoding::TypeMarker for AllowlistedCapability {
10365        type Owned = Self;
10366
10367        #[inline(always)]
10368        fn inline_align(_context: fidl::encoding::Context) -> usize {
10369            8
10370        }
10371
10372        #[inline(always)]
10373        fn inline_size(_context: fidl::encoding::Context) -> usize {
10374            16
10375        }
10376    }
10377
10378    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedCapability, D>
10379        for &AllowlistedCapability
10380    {
10381        #[inline]
10382        unsafe fn encode(
10383            self,
10384            encoder: &mut fidl::encoding::Encoder<'_, D>,
10385            offset: usize,
10386            _depth: fidl::encoding::Depth,
10387        ) -> fidl::Result<()> {
10388            encoder.debug_check_bounds::<AllowlistedCapability>(offset);
10389            encoder.write_num::<u64>(self.ordinal(), offset);
10390            match self {
10391                AllowlistedCapability::Directory(ref val) => {
10392                    fidl::encoding::encode_in_envelope::<AllowlistedDirectory, D>(
10393                        <AllowlistedDirectory as fidl::encoding::ValueTypeMarker>::borrow(val),
10394                        encoder,
10395                        offset + 8,
10396                        _depth,
10397                    )
10398                }
10399                AllowlistedCapability::Protocol(ref val) => {
10400                    fidl::encoding::encode_in_envelope::<AllowlistedProtocol, D>(
10401                        <AllowlistedProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
10402                        encoder,
10403                        offset + 8,
10404                        _depth,
10405                    )
10406                }
10407                AllowlistedCapability::Service(ref val) => {
10408                    fidl::encoding::encode_in_envelope::<AllowlistedService, D>(
10409                        <AllowlistedService as fidl::encoding::ValueTypeMarker>::borrow(val),
10410                        encoder,
10411                        offset + 8,
10412                        _depth,
10413                    )
10414                }
10415                AllowlistedCapability::Storage(ref val) => {
10416                    fidl::encoding::encode_in_envelope::<AllowlistedStorage, D>(
10417                        <AllowlistedStorage as fidl::encoding::ValueTypeMarker>::borrow(val),
10418                        encoder,
10419                        offset + 8,
10420                        _depth,
10421                    )
10422                }
10423                AllowlistedCapability::Runner(ref val) => {
10424                    fidl::encoding::encode_in_envelope::<AllowlistedRunner, D>(
10425                        <AllowlistedRunner as fidl::encoding::ValueTypeMarker>::borrow(val),
10426                        encoder,
10427                        offset + 8,
10428                        _depth,
10429                    )
10430                }
10431                AllowlistedCapability::Resolver(ref val) => {
10432                    fidl::encoding::encode_in_envelope::<AllowlistedResolver, D>(
10433                        <AllowlistedResolver as fidl::encoding::ValueTypeMarker>::borrow(val),
10434                        encoder,
10435                        offset + 8,
10436                        _depth,
10437                    )
10438                }
10439                AllowlistedCapability::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
10440            }
10441        }
10442    }
10443
10444    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedCapability {
10445        #[inline(always)]
10446        fn new_empty() -> Self {
10447            Self::__SourceBreaking { unknown_ordinal: 0 }
10448        }
10449
10450        #[inline]
10451        unsafe fn decode(
10452            &mut self,
10453            decoder: &mut fidl::encoding::Decoder<'_, D>,
10454            offset: usize,
10455            mut depth: fidl::encoding::Depth,
10456        ) -> fidl::Result<()> {
10457            decoder.debug_check_bounds::<Self>(offset);
10458            #[allow(unused_variables)]
10459            let next_out_of_line = decoder.next_out_of_line();
10460            let handles_before = decoder.remaining_handles();
10461            let (ordinal, inlined, num_bytes, num_handles) =
10462                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10463
10464            let member_inline_size = match ordinal {
10465                1 => <AllowlistedDirectory as fidl::encoding::TypeMarker>::inline_size(
10466                    decoder.context,
10467                ),
10468                3 => <AllowlistedProtocol as fidl::encoding::TypeMarker>::inline_size(
10469                    decoder.context,
10470                ),
10471                4 => {
10472                    <AllowlistedService as fidl::encoding::TypeMarker>::inline_size(decoder.context)
10473                }
10474                5 => {
10475                    <AllowlistedStorage as fidl::encoding::TypeMarker>::inline_size(decoder.context)
10476                }
10477                6 => {
10478                    <AllowlistedRunner as fidl::encoding::TypeMarker>::inline_size(decoder.context)
10479                }
10480                7 => <AllowlistedResolver as fidl::encoding::TypeMarker>::inline_size(
10481                    decoder.context,
10482                ),
10483                0 => return Err(fidl::Error::UnknownUnionTag),
10484                _ => num_bytes as usize,
10485            };
10486
10487            if inlined != (member_inline_size <= 4) {
10488                return Err(fidl::Error::InvalidInlineBitInEnvelope);
10489            }
10490            let _inner_offset;
10491            if inlined {
10492                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10493                _inner_offset = offset + 8;
10494            } else {
10495                depth.increment()?;
10496                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10497            }
10498            match ordinal {
10499                1 => {
10500                    #[allow(irrefutable_let_patterns)]
10501                    if let AllowlistedCapability::Directory(_) = self {
10502                        // Do nothing, read the value into the object
10503                    } else {
10504                        // Initialize `self` to the right variant
10505                        *self = AllowlistedCapability::Directory(fidl::new_empty!(
10506                            AllowlistedDirectory,
10507                            D
10508                        ));
10509                    }
10510                    #[allow(irrefutable_let_patterns)]
10511                    if let AllowlistedCapability::Directory(ref mut val) = self {
10512                        fidl::decode!(AllowlistedDirectory, D, val, decoder, _inner_offset, depth)?;
10513                    } else {
10514                        unreachable!()
10515                    }
10516                }
10517                3 => {
10518                    #[allow(irrefutable_let_patterns)]
10519                    if let AllowlistedCapability::Protocol(_) = self {
10520                        // Do nothing, read the value into the object
10521                    } else {
10522                        // Initialize `self` to the right variant
10523                        *self = AllowlistedCapability::Protocol(fidl::new_empty!(
10524                            AllowlistedProtocol,
10525                            D
10526                        ));
10527                    }
10528                    #[allow(irrefutable_let_patterns)]
10529                    if let AllowlistedCapability::Protocol(ref mut val) = self {
10530                        fidl::decode!(AllowlistedProtocol, D, val, decoder, _inner_offset, depth)?;
10531                    } else {
10532                        unreachable!()
10533                    }
10534                }
10535                4 => {
10536                    #[allow(irrefutable_let_patterns)]
10537                    if let AllowlistedCapability::Service(_) = self {
10538                        // Do nothing, read the value into the object
10539                    } else {
10540                        // Initialize `self` to the right variant
10541                        *self =
10542                            AllowlistedCapability::Service(fidl::new_empty!(AllowlistedService, D));
10543                    }
10544                    #[allow(irrefutable_let_patterns)]
10545                    if let AllowlistedCapability::Service(ref mut val) = self {
10546                        fidl::decode!(AllowlistedService, D, val, decoder, _inner_offset, depth)?;
10547                    } else {
10548                        unreachable!()
10549                    }
10550                }
10551                5 => {
10552                    #[allow(irrefutable_let_patterns)]
10553                    if let AllowlistedCapability::Storage(_) = self {
10554                        // Do nothing, read the value into the object
10555                    } else {
10556                        // Initialize `self` to the right variant
10557                        *self =
10558                            AllowlistedCapability::Storage(fidl::new_empty!(AllowlistedStorage, D));
10559                    }
10560                    #[allow(irrefutable_let_patterns)]
10561                    if let AllowlistedCapability::Storage(ref mut val) = self {
10562                        fidl::decode!(AllowlistedStorage, D, val, decoder, _inner_offset, depth)?;
10563                    } else {
10564                        unreachable!()
10565                    }
10566                }
10567                6 => {
10568                    #[allow(irrefutable_let_patterns)]
10569                    if let AllowlistedCapability::Runner(_) = self {
10570                        // Do nothing, read the value into the object
10571                    } else {
10572                        // Initialize `self` to the right variant
10573                        *self =
10574                            AllowlistedCapability::Runner(fidl::new_empty!(AllowlistedRunner, D));
10575                    }
10576                    #[allow(irrefutable_let_patterns)]
10577                    if let AllowlistedCapability::Runner(ref mut val) = self {
10578                        fidl::decode!(AllowlistedRunner, D, val, decoder, _inner_offset, depth)?;
10579                    } else {
10580                        unreachable!()
10581                    }
10582                }
10583                7 => {
10584                    #[allow(irrefutable_let_patterns)]
10585                    if let AllowlistedCapability::Resolver(_) = self {
10586                        // Do nothing, read the value into the object
10587                    } else {
10588                        // Initialize `self` to the right variant
10589                        *self = AllowlistedCapability::Resolver(fidl::new_empty!(
10590                            AllowlistedResolver,
10591                            D
10592                        ));
10593                    }
10594                    #[allow(irrefutable_let_patterns)]
10595                    if let AllowlistedCapability::Resolver(ref mut val) = self {
10596                        fidl::decode!(AllowlistedResolver, D, val, decoder, _inner_offset, depth)?;
10597                    } else {
10598                        unreachable!()
10599                    }
10600                }
10601                #[allow(deprecated)]
10602                ordinal => {
10603                    for _ in 0..num_handles {
10604                        decoder.drop_next_handle()?;
10605                    }
10606                    *self = AllowlistedCapability::__SourceBreaking { unknown_ordinal: ordinal };
10607                }
10608            }
10609            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10610                return Err(fidl::Error::InvalidNumBytesInEnvelope);
10611            }
10612            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10613                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10614            }
10615            Ok(())
10616        }
10617    }
10618
10619    impl fidl::encoding::ValueTypeMarker for AllowlistedDebugRegistration {
10620        type Borrowed<'a> = &'a Self;
10621        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10622            value
10623        }
10624    }
10625
10626    unsafe impl fidl::encoding::TypeMarker for AllowlistedDebugRegistration {
10627        type Owned = Self;
10628
10629        #[inline(always)]
10630        fn inline_align(_context: fidl::encoding::Context) -> usize {
10631            8
10632        }
10633
10634        #[inline(always)]
10635        fn inline_size(_context: fidl::encoding::Context) -> usize {
10636            16
10637        }
10638    }
10639
10640    unsafe impl<D: fidl::encoding::ResourceDialect>
10641        fidl::encoding::Encode<AllowlistedDebugRegistration, D> for &AllowlistedDebugRegistration
10642    {
10643        #[inline]
10644        unsafe fn encode(
10645            self,
10646            encoder: &mut fidl::encoding::Encoder<'_, D>,
10647            offset: usize,
10648            _depth: fidl::encoding::Depth,
10649        ) -> fidl::Result<()> {
10650            encoder.debug_check_bounds::<AllowlistedDebugRegistration>(offset);
10651            encoder.write_num::<u64>(self.ordinal(), offset);
10652            match self {
10653                AllowlistedDebugRegistration::Protocol(ref val) => {
10654                    fidl::encoding::encode_in_envelope::<AllowlistedProtocol, D>(
10655                        <AllowlistedProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
10656                        encoder,
10657                        offset + 8,
10658                        _depth,
10659                    )
10660                }
10661                AllowlistedDebugRegistration::__SourceBreaking { .. } => {
10662                    Err(fidl::Error::UnknownUnionTag)
10663                }
10664            }
10665        }
10666    }
10667
10668    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10669        for AllowlistedDebugRegistration
10670    {
10671        #[inline(always)]
10672        fn new_empty() -> Self {
10673            Self::__SourceBreaking { unknown_ordinal: 0 }
10674        }
10675
10676        #[inline]
10677        unsafe fn decode(
10678            &mut self,
10679            decoder: &mut fidl::encoding::Decoder<'_, D>,
10680            offset: usize,
10681            mut depth: fidl::encoding::Depth,
10682        ) -> fidl::Result<()> {
10683            decoder.debug_check_bounds::<Self>(offset);
10684            #[allow(unused_variables)]
10685            let next_out_of_line = decoder.next_out_of_line();
10686            let handles_before = decoder.remaining_handles();
10687            let (ordinal, inlined, num_bytes, num_handles) =
10688                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10689
10690            let member_inline_size = match ordinal {
10691                1 => <AllowlistedProtocol as fidl::encoding::TypeMarker>::inline_size(
10692                    decoder.context,
10693                ),
10694                0 => return Err(fidl::Error::UnknownUnionTag),
10695                _ => num_bytes as usize,
10696            };
10697
10698            if inlined != (member_inline_size <= 4) {
10699                return Err(fidl::Error::InvalidInlineBitInEnvelope);
10700            }
10701            let _inner_offset;
10702            if inlined {
10703                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10704                _inner_offset = offset + 8;
10705            } else {
10706                depth.increment()?;
10707                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10708            }
10709            match ordinal {
10710                1 => {
10711                    #[allow(irrefutable_let_patterns)]
10712                    if let AllowlistedDebugRegistration::Protocol(_) = self {
10713                        // Do nothing, read the value into the object
10714                    } else {
10715                        // Initialize `self` to the right variant
10716                        *self = AllowlistedDebugRegistration::Protocol(fidl::new_empty!(
10717                            AllowlistedProtocol,
10718                            D
10719                        ));
10720                    }
10721                    #[allow(irrefutable_let_patterns)]
10722                    if let AllowlistedDebugRegistration::Protocol(ref mut val) = self {
10723                        fidl::decode!(AllowlistedProtocol, D, val, decoder, _inner_offset, depth)?;
10724                    } else {
10725                        unreachable!()
10726                    }
10727                }
10728                #[allow(deprecated)]
10729                ordinal => {
10730                    for _ in 0..num_handles {
10731                        decoder.drop_next_handle()?;
10732                    }
10733                    *self =
10734                        AllowlistedDebugRegistration::__SourceBreaking { unknown_ordinal: ordinal };
10735                }
10736            }
10737            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10738                return Err(fidl::Error::InvalidNumBytesInEnvelope);
10739            }
10740            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10741                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10742            }
10743            Ok(())
10744        }
10745    }
10746
10747    impl fidl::encoding::ValueTypeMarker for CapabilitySource {
10748        type Borrowed<'a> = &'a Self;
10749        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10750            value
10751        }
10752    }
10753
10754    unsafe impl fidl::encoding::TypeMarker for CapabilitySource {
10755        type Owned = Self;
10756
10757        #[inline(always)]
10758        fn inline_align(_context: fidl::encoding::Context) -> usize {
10759            8
10760        }
10761
10762        #[inline(always)]
10763        fn inline_size(_context: fidl::encoding::Context) -> usize {
10764            16
10765        }
10766    }
10767
10768    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CapabilitySource, D>
10769        for &CapabilitySource
10770    {
10771        #[inline]
10772        unsafe fn encode(
10773            self,
10774            encoder: &mut fidl::encoding::Encoder<'_, D>,
10775            offset: usize,
10776            _depth: fidl::encoding::Depth,
10777        ) -> fidl::Result<()> {
10778            encoder.debug_check_bounds::<CapabilitySource>(offset);
10779            encoder.write_num::<u64>(self.ordinal(), offset);
10780            match self {
10781                CapabilitySource::Component(ref val) => {
10782                    fidl::encoding::encode_in_envelope::<Component, D>(
10783                        <Component as fidl::encoding::ValueTypeMarker>::borrow(val),
10784                        encoder,
10785                        offset + 8,
10786                        _depth,
10787                    )
10788                }
10789                CapabilitySource::Framework(ref val) => {
10790                    fidl::encoding::encode_in_envelope::<Framework, D>(
10791                        <Framework as fidl::encoding::ValueTypeMarker>::borrow(val),
10792                        encoder,
10793                        offset + 8,
10794                        _depth,
10795                    )
10796                }
10797                CapabilitySource::Builtin(ref val) => {
10798                    fidl::encoding::encode_in_envelope::<Builtin, D>(
10799                        <Builtin as fidl::encoding::ValueTypeMarker>::borrow(val),
10800                        encoder,
10801                        offset + 8,
10802                        _depth,
10803                    )
10804                }
10805                CapabilitySource::Namespace(ref val) => {
10806                    fidl::encoding::encode_in_envelope::<Namespace, D>(
10807                        <Namespace as fidl::encoding::ValueTypeMarker>::borrow(val),
10808                        encoder,
10809                        offset + 8,
10810                        _depth,
10811                    )
10812                }
10813                CapabilitySource::Capability(ref val) => {
10814                    fidl::encoding::encode_in_envelope::<Capability, D>(
10815                        <Capability as fidl::encoding::ValueTypeMarker>::borrow(val),
10816                        encoder,
10817                        offset + 8,
10818                        _depth,
10819                    )
10820                }
10821                CapabilitySource::AnonymizedAggregate(ref val) => {
10822                    fidl::encoding::encode_in_envelope::<AnonymizedAggregate, D>(
10823                        <AnonymizedAggregate as fidl::encoding::ValueTypeMarker>::borrow(val),
10824                        encoder,
10825                        offset + 8,
10826                        _depth,
10827                    )
10828                }
10829                CapabilitySource::FilteredProvider(ref val) => {
10830                    fidl::encoding::encode_in_envelope::<FilteredProvider, D>(
10831                        <FilteredProvider as fidl::encoding::ValueTypeMarker>::borrow(val),
10832                        encoder,
10833                        offset + 8,
10834                        _depth,
10835                    )
10836                }
10837                CapabilitySource::FilteredAggregateProvider(ref val) => {
10838                    fidl::encoding::encode_in_envelope::<FilteredAggregateProvider, D>(
10839                        <FilteredAggregateProvider as fidl::encoding::ValueTypeMarker>::borrow(val),
10840                        encoder,
10841                        offset + 8,
10842                        _depth,
10843                    )
10844                }
10845                CapabilitySource::Environment(ref val) => {
10846                    fidl::encoding::encode_in_envelope::<Environment, D>(
10847                        <Environment as fidl::encoding::ValueTypeMarker>::borrow(val),
10848                        encoder,
10849                        offset + 8,
10850                        _depth,
10851                    )
10852                }
10853                CapabilitySource::Void(ref val) => fidl::encoding::encode_in_envelope::<Void, D>(
10854                    <Void as fidl::encoding::ValueTypeMarker>::borrow(val),
10855                    encoder,
10856                    offset + 8,
10857                    _depth,
10858                ),
10859            }
10860        }
10861    }
10862
10863    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CapabilitySource {
10864        #[inline(always)]
10865        fn new_empty() -> Self {
10866            Self::Component(fidl::new_empty!(Component, D))
10867        }
10868
10869        #[inline]
10870        unsafe fn decode(
10871            &mut self,
10872            decoder: &mut fidl::encoding::Decoder<'_, D>,
10873            offset: usize,
10874            mut depth: fidl::encoding::Depth,
10875        ) -> fidl::Result<()> {
10876            decoder.debug_check_bounds::<Self>(offset);
10877            #[allow(unused_variables)]
10878            let next_out_of_line = decoder.next_out_of_line();
10879            let handles_before = decoder.remaining_handles();
10880            let (ordinal, inlined, num_bytes, num_handles) =
10881                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10882
10883            let member_inline_size = match ordinal {
10884                1 => <Component as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10885                2 => <Framework as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10886                3 => <Builtin as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10887                4 => <Namespace as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10888                5 => <Capability as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10889                6 => <AnonymizedAggregate as fidl::encoding::TypeMarker>::inline_size(
10890                    decoder.context,
10891                ),
10892                7 => <FilteredProvider as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10893                8 => <FilteredAggregateProvider as fidl::encoding::TypeMarker>::inline_size(
10894                    decoder.context,
10895                ),
10896                9 => <Environment as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10897                10 => <Void as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10898                _ => return Err(fidl::Error::UnknownUnionTag),
10899            };
10900
10901            if inlined != (member_inline_size <= 4) {
10902                return Err(fidl::Error::InvalidInlineBitInEnvelope);
10903            }
10904            let _inner_offset;
10905            if inlined {
10906                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10907                _inner_offset = offset + 8;
10908            } else {
10909                depth.increment()?;
10910                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10911            }
10912            match ordinal {
10913                1 => {
10914                    #[allow(irrefutable_let_patterns)]
10915                    if let CapabilitySource::Component(_) = self {
10916                        // Do nothing, read the value into the object
10917                    } else {
10918                        // Initialize `self` to the right variant
10919                        *self = CapabilitySource::Component(fidl::new_empty!(Component, D));
10920                    }
10921                    #[allow(irrefutable_let_patterns)]
10922                    if let CapabilitySource::Component(ref mut val) = self {
10923                        fidl::decode!(Component, D, val, decoder, _inner_offset, depth)?;
10924                    } else {
10925                        unreachable!()
10926                    }
10927                }
10928                2 => {
10929                    #[allow(irrefutable_let_patterns)]
10930                    if let CapabilitySource::Framework(_) = self {
10931                        // Do nothing, read the value into the object
10932                    } else {
10933                        // Initialize `self` to the right variant
10934                        *self = CapabilitySource::Framework(fidl::new_empty!(Framework, D));
10935                    }
10936                    #[allow(irrefutable_let_patterns)]
10937                    if let CapabilitySource::Framework(ref mut val) = self {
10938                        fidl::decode!(Framework, D, val, decoder, _inner_offset, depth)?;
10939                    } else {
10940                        unreachable!()
10941                    }
10942                }
10943                3 => {
10944                    #[allow(irrefutable_let_patterns)]
10945                    if let CapabilitySource::Builtin(_) = self {
10946                        // Do nothing, read the value into the object
10947                    } else {
10948                        // Initialize `self` to the right variant
10949                        *self = CapabilitySource::Builtin(fidl::new_empty!(Builtin, D));
10950                    }
10951                    #[allow(irrefutable_let_patterns)]
10952                    if let CapabilitySource::Builtin(ref mut val) = self {
10953                        fidl::decode!(Builtin, D, val, decoder, _inner_offset, depth)?;
10954                    } else {
10955                        unreachable!()
10956                    }
10957                }
10958                4 => {
10959                    #[allow(irrefutable_let_patterns)]
10960                    if let CapabilitySource::Namespace(_) = self {
10961                        // Do nothing, read the value into the object
10962                    } else {
10963                        // Initialize `self` to the right variant
10964                        *self = CapabilitySource::Namespace(fidl::new_empty!(Namespace, D));
10965                    }
10966                    #[allow(irrefutable_let_patterns)]
10967                    if let CapabilitySource::Namespace(ref mut val) = self {
10968                        fidl::decode!(Namespace, D, val, decoder, _inner_offset, depth)?;
10969                    } else {
10970                        unreachable!()
10971                    }
10972                }
10973                5 => {
10974                    #[allow(irrefutable_let_patterns)]
10975                    if let CapabilitySource::Capability(_) = self {
10976                        // Do nothing, read the value into the object
10977                    } else {
10978                        // Initialize `self` to the right variant
10979                        *self = CapabilitySource::Capability(fidl::new_empty!(Capability, D));
10980                    }
10981                    #[allow(irrefutable_let_patterns)]
10982                    if let CapabilitySource::Capability(ref mut val) = self {
10983                        fidl::decode!(Capability, D, val, decoder, _inner_offset, depth)?;
10984                    } else {
10985                        unreachable!()
10986                    }
10987                }
10988                6 => {
10989                    #[allow(irrefutable_let_patterns)]
10990                    if let CapabilitySource::AnonymizedAggregate(_) = self {
10991                        // Do nothing, read the value into the object
10992                    } else {
10993                        // Initialize `self` to the right variant
10994                        *self = CapabilitySource::AnonymizedAggregate(fidl::new_empty!(
10995                            AnonymizedAggregate,
10996                            D
10997                        ));
10998                    }
10999                    #[allow(irrefutable_let_patterns)]
11000                    if let CapabilitySource::AnonymizedAggregate(ref mut val) = self {
11001                        fidl::decode!(AnonymizedAggregate, D, val, decoder, _inner_offset, depth)?;
11002                    } else {
11003                        unreachable!()
11004                    }
11005                }
11006                7 => {
11007                    #[allow(irrefutable_let_patterns)]
11008                    if let CapabilitySource::FilteredProvider(_) = self {
11009                        // Do nothing, read the value into the object
11010                    } else {
11011                        // Initialize `self` to the right variant
11012                        *self = CapabilitySource::FilteredProvider(fidl::new_empty!(
11013                            FilteredProvider,
11014                            D
11015                        ));
11016                    }
11017                    #[allow(irrefutable_let_patterns)]
11018                    if let CapabilitySource::FilteredProvider(ref mut val) = self {
11019                        fidl::decode!(FilteredProvider, D, val, decoder, _inner_offset, depth)?;
11020                    } else {
11021                        unreachable!()
11022                    }
11023                }
11024                8 => {
11025                    #[allow(irrefutable_let_patterns)]
11026                    if let CapabilitySource::FilteredAggregateProvider(_) = self {
11027                        // Do nothing, read the value into the object
11028                    } else {
11029                        // Initialize `self` to the right variant
11030                        *self = CapabilitySource::FilteredAggregateProvider(fidl::new_empty!(
11031                            FilteredAggregateProvider,
11032                            D
11033                        ));
11034                    }
11035                    #[allow(irrefutable_let_patterns)]
11036                    if let CapabilitySource::FilteredAggregateProvider(ref mut val) = self {
11037                        fidl::decode!(
11038                            FilteredAggregateProvider,
11039                            D,
11040                            val,
11041                            decoder,
11042                            _inner_offset,
11043                            depth
11044                        )?;
11045                    } else {
11046                        unreachable!()
11047                    }
11048                }
11049                9 => {
11050                    #[allow(irrefutable_let_patterns)]
11051                    if let CapabilitySource::Environment(_) = self {
11052                        // Do nothing, read the value into the object
11053                    } else {
11054                        // Initialize `self` to the right variant
11055                        *self = CapabilitySource::Environment(fidl::new_empty!(Environment, D));
11056                    }
11057                    #[allow(irrefutable_let_patterns)]
11058                    if let CapabilitySource::Environment(ref mut val) = self {
11059                        fidl::decode!(Environment, D, val, decoder, _inner_offset, depth)?;
11060                    } else {
11061                        unreachable!()
11062                    }
11063                }
11064                10 => {
11065                    #[allow(irrefutable_let_patterns)]
11066                    if let CapabilitySource::Void(_) = self {
11067                        // Do nothing, read the value into the object
11068                    } else {
11069                        // Initialize `self` to the right variant
11070                        *self = CapabilitySource::Void(fidl::new_empty!(Void, D));
11071                    }
11072                    #[allow(irrefutable_let_patterns)]
11073                    if let CapabilitySource::Void(ref mut val) = self {
11074                        fidl::decode!(Void, D, val, decoder, _inner_offset, depth)?;
11075                    } else {
11076                        unreachable!()
11077                    }
11078                }
11079                ordinal => panic!("unexpected ordinal {:?}", ordinal),
11080            }
11081            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11082                return Err(fidl::Error::InvalidNumBytesInEnvelope);
11083            }
11084            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11085                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11086            }
11087            Ok(())
11088        }
11089    }
11090
11091    impl fidl::encoding::ValueTypeMarker for ComponentCapability {
11092        type Borrowed<'a> = &'a Self;
11093        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11094            value
11095        }
11096    }
11097
11098    unsafe impl fidl::encoding::TypeMarker for ComponentCapability {
11099        type Owned = Self;
11100
11101        #[inline(always)]
11102        fn inline_align(_context: fidl::encoding::Context) -> usize {
11103            8
11104        }
11105
11106        #[inline(always)]
11107        fn inline_size(_context: fidl::encoding::Context) -> usize {
11108            16
11109        }
11110    }
11111
11112    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ComponentCapability, D>
11113        for &ComponentCapability
11114    {
11115        #[inline]
11116        unsafe fn encode(
11117            self,
11118            encoder: &mut fidl::encoding::Encoder<'_, D>,
11119            offset: usize,
11120            _depth: fidl::encoding::Depth,
11121        ) -> fidl::Result<()> {
11122            encoder.debug_check_bounds::<ComponentCapability>(offset);
11123            encoder.write_num::<u64>(self.ordinal(), offset);
11124            match self {
11125            ComponentCapability::Use_(ref val) => {
11126                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Use, D>(
11127                    <fidl_fuchsia_component_decl__common::Use as fidl::encoding::ValueTypeMarker>::borrow(val),
11128                    encoder, offset + 8, _depth
11129                )
11130            }
11131            ComponentCapability::Offer(ref val) => {
11132                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Offer, D>(
11133                    <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::ValueTypeMarker>::borrow(val),
11134                    encoder, offset + 8, _depth
11135                )
11136            }
11137            ComponentCapability::Expose(ref val) => {
11138                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Expose, D>(
11139                    <fidl_fuchsia_component_decl__common::Expose as fidl::encoding::ValueTypeMarker>::borrow(val),
11140                    encoder, offset + 8, _depth
11141                )
11142            }
11143            ComponentCapability::Config(ref val) => {
11144                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Configuration, D>(
11145                    <fidl_fuchsia_component_decl__common::Configuration as fidl::encoding::ValueTypeMarker>::borrow(val),
11146                    encoder, offset + 8, _depth
11147                )
11148            }
11149            ComponentCapability::Dictionary(ref val) => {
11150                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Dictionary, D>(
11151                    <fidl_fuchsia_component_decl__common::Dictionary as fidl::encoding::ValueTypeMarker>::borrow(val),
11152                    encoder, offset + 8, _depth
11153                )
11154            }
11155            ComponentCapability::Directory(ref val) => {
11156                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Directory, D>(
11157                    <fidl_fuchsia_component_decl__common::Directory as fidl::encoding::ValueTypeMarker>::borrow(val),
11158                    encoder, offset + 8, _depth
11159                )
11160            }
11161            ComponentCapability::Environment(ref val) => {
11162                fidl::encoding::encode_in_envelope::<EnvironmentCapability, D>(
11163                    <EnvironmentCapability as fidl::encoding::ValueTypeMarker>::borrow(val),
11164                    encoder, offset + 8, _depth
11165                )
11166            }
11167            ComponentCapability::EventStream(ref val) => {
11168                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::EventStream, D>(
11169                    <fidl_fuchsia_component_decl__common::EventStream as fidl::encoding::ValueTypeMarker>::borrow(val),
11170                    encoder, offset + 8, _depth
11171                )
11172            }
11173            ComponentCapability::Protocol(ref val) => {
11174                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Protocol, D>(
11175                    <fidl_fuchsia_component_decl__common::Protocol as fidl::encoding::ValueTypeMarker>::borrow(val),
11176                    encoder, offset + 8, _depth
11177                )
11178            }
11179            ComponentCapability::Resolver(ref val) => {
11180                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Resolver, D>(
11181                    <fidl_fuchsia_component_decl__common::Resolver as fidl::encoding::ValueTypeMarker>::borrow(val),
11182                    encoder, offset + 8, _depth
11183                )
11184            }
11185            ComponentCapability::Runner(ref val) => {
11186                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Runner, D>(
11187                    <fidl_fuchsia_component_decl__common::Runner as fidl::encoding::ValueTypeMarker>::borrow(val),
11188                    encoder, offset + 8, _depth
11189                )
11190            }
11191            ComponentCapability::Service(ref val) => {
11192                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Service, D>(
11193                    <fidl_fuchsia_component_decl__common::Service as fidl::encoding::ValueTypeMarker>::borrow(val),
11194                    encoder, offset + 8, _depth
11195                )
11196            }
11197            ComponentCapability::Storage(ref val) => {
11198                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Storage, D>(
11199                    <fidl_fuchsia_component_decl__common::Storage as fidl::encoding::ValueTypeMarker>::borrow(val),
11200                    encoder, offset + 8, _depth
11201                )
11202            }
11203        }
11204        }
11205    }
11206
11207    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ComponentCapability {
11208        #[inline(always)]
11209        fn new_empty() -> Self {
11210            Self::Use_(fidl::new_empty!(fidl_fuchsia_component_decl__common::Use, D))
11211        }
11212
11213        #[inline]
11214        unsafe fn decode(
11215            &mut self,
11216            decoder: &mut fidl::encoding::Decoder<'_, D>,
11217            offset: usize,
11218            mut depth: fidl::encoding::Depth,
11219        ) -> fidl::Result<()> {
11220            decoder.debug_check_bounds::<Self>(offset);
11221            #[allow(unused_variables)]
11222            let next_out_of_line = decoder.next_out_of_line();
11223            let handles_before = decoder.remaining_handles();
11224            let (ordinal, inlined, num_bytes, num_handles) =
11225                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11226
11227            let member_inline_size = match ordinal {
11228            1 => <fidl_fuchsia_component_decl__common::Use as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11229            2 => <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11230            3 => <fidl_fuchsia_component_decl__common::Expose as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11231            4 => <fidl_fuchsia_component_decl__common::Configuration as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11232            5 => <fidl_fuchsia_component_decl__common::Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11233            6 => <fidl_fuchsia_component_decl__common::Directory as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11234            7 => <EnvironmentCapability as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11235            8 => <fidl_fuchsia_component_decl__common::EventStream as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11236            9 => <fidl_fuchsia_component_decl__common::Protocol as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11237            10 => <fidl_fuchsia_component_decl__common::Resolver as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11238            11 => <fidl_fuchsia_component_decl__common::Runner as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11239            12 => <fidl_fuchsia_component_decl__common::Service as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11240            13 => <fidl_fuchsia_component_decl__common::Storage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11241            _ => return Err(fidl::Error::UnknownUnionTag),
11242        };
11243
11244            if inlined != (member_inline_size <= 4) {
11245                return Err(fidl::Error::InvalidInlineBitInEnvelope);
11246            }
11247            let _inner_offset;
11248            if inlined {
11249                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11250                _inner_offset = offset + 8;
11251            } else {
11252                depth.increment()?;
11253                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11254            }
11255            match ordinal {
11256                1 => {
11257                    #[allow(irrefutable_let_patterns)]
11258                    if let ComponentCapability::Use_(_) = self {
11259                        // Do nothing, read the value into the object
11260                    } else {
11261                        // Initialize `self` to the right variant
11262                        *self = ComponentCapability::Use_(fidl::new_empty!(
11263                            fidl_fuchsia_component_decl__common::Use,
11264                            D
11265                        ));
11266                    }
11267                    #[allow(irrefutable_let_patterns)]
11268                    if let ComponentCapability::Use_(ref mut val) = self {
11269                        fidl::decode!(
11270                            fidl_fuchsia_component_decl__common::Use,
11271                            D,
11272                            val,
11273                            decoder,
11274                            _inner_offset,
11275                            depth
11276                        )?;
11277                    } else {
11278                        unreachable!()
11279                    }
11280                }
11281                2 => {
11282                    #[allow(irrefutable_let_patterns)]
11283                    if let ComponentCapability::Offer(_) = self {
11284                        // Do nothing, read the value into the object
11285                    } else {
11286                        // Initialize `self` to the right variant
11287                        *self = ComponentCapability::Offer(fidl::new_empty!(
11288                            fidl_fuchsia_component_decl__common::Offer,
11289                            D
11290                        ));
11291                    }
11292                    #[allow(irrefutable_let_patterns)]
11293                    if let ComponentCapability::Offer(ref mut val) = self {
11294                        fidl::decode!(
11295                            fidl_fuchsia_component_decl__common::Offer,
11296                            D,
11297                            val,
11298                            decoder,
11299                            _inner_offset,
11300                            depth
11301                        )?;
11302                    } else {
11303                        unreachable!()
11304                    }
11305                }
11306                3 => {
11307                    #[allow(irrefutable_let_patterns)]
11308                    if let ComponentCapability::Expose(_) = self {
11309                        // Do nothing, read the value into the object
11310                    } else {
11311                        // Initialize `self` to the right variant
11312                        *self = ComponentCapability::Expose(fidl::new_empty!(
11313                            fidl_fuchsia_component_decl__common::Expose,
11314                            D
11315                        ));
11316                    }
11317                    #[allow(irrefutable_let_patterns)]
11318                    if let ComponentCapability::Expose(ref mut val) = self {
11319                        fidl::decode!(
11320                            fidl_fuchsia_component_decl__common::Expose,
11321                            D,
11322                            val,
11323                            decoder,
11324                            _inner_offset,
11325                            depth
11326                        )?;
11327                    } else {
11328                        unreachable!()
11329                    }
11330                }
11331                4 => {
11332                    #[allow(irrefutable_let_patterns)]
11333                    if let ComponentCapability::Config(_) = self {
11334                        // Do nothing, read the value into the object
11335                    } else {
11336                        // Initialize `self` to the right variant
11337                        *self = ComponentCapability::Config(fidl::new_empty!(
11338                            fidl_fuchsia_component_decl__common::Configuration,
11339                            D
11340                        ));
11341                    }
11342                    #[allow(irrefutable_let_patterns)]
11343                    if let ComponentCapability::Config(ref mut val) = self {
11344                        fidl::decode!(
11345                            fidl_fuchsia_component_decl__common::Configuration,
11346                            D,
11347                            val,
11348                            decoder,
11349                            _inner_offset,
11350                            depth
11351                        )?;
11352                    } else {
11353                        unreachable!()
11354                    }
11355                }
11356                5 => {
11357                    #[allow(irrefutable_let_patterns)]
11358                    if let ComponentCapability::Dictionary(_) = self {
11359                        // Do nothing, read the value into the object
11360                    } else {
11361                        // Initialize `self` to the right variant
11362                        *self = ComponentCapability::Dictionary(fidl::new_empty!(
11363                            fidl_fuchsia_component_decl__common::Dictionary,
11364                            D
11365                        ));
11366                    }
11367                    #[allow(irrefutable_let_patterns)]
11368                    if let ComponentCapability::Dictionary(ref mut val) = self {
11369                        fidl::decode!(
11370                            fidl_fuchsia_component_decl__common::Dictionary,
11371                            D,
11372                            val,
11373                            decoder,
11374                            _inner_offset,
11375                            depth
11376                        )?;
11377                    } else {
11378                        unreachable!()
11379                    }
11380                }
11381                6 => {
11382                    #[allow(irrefutable_let_patterns)]
11383                    if let ComponentCapability::Directory(_) = self {
11384                        // Do nothing, read the value into the object
11385                    } else {
11386                        // Initialize `self` to the right variant
11387                        *self = ComponentCapability::Directory(fidl::new_empty!(
11388                            fidl_fuchsia_component_decl__common::Directory,
11389                            D
11390                        ));
11391                    }
11392                    #[allow(irrefutable_let_patterns)]
11393                    if let ComponentCapability::Directory(ref mut val) = self {
11394                        fidl::decode!(
11395                            fidl_fuchsia_component_decl__common::Directory,
11396                            D,
11397                            val,
11398                            decoder,
11399                            _inner_offset,
11400                            depth
11401                        )?;
11402                    } else {
11403                        unreachable!()
11404                    }
11405                }
11406                7 => {
11407                    #[allow(irrefutable_let_patterns)]
11408                    if let ComponentCapability::Environment(_) = self {
11409                        // Do nothing, read the value into the object
11410                    } else {
11411                        // Initialize `self` to the right variant
11412                        *self = ComponentCapability::Environment(fidl::new_empty!(
11413                            EnvironmentCapability,
11414                            D
11415                        ));
11416                    }
11417                    #[allow(irrefutable_let_patterns)]
11418                    if let ComponentCapability::Environment(ref mut val) = self {
11419                        fidl::decode!(
11420                            EnvironmentCapability,
11421                            D,
11422                            val,
11423                            decoder,
11424                            _inner_offset,
11425                            depth
11426                        )?;
11427                    } else {
11428                        unreachable!()
11429                    }
11430                }
11431                8 => {
11432                    #[allow(irrefutable_let_patterns)]
11433                    if let ComponentCapability::EventStream(_) = self {
11434                        // Do nothing, read the value into the object
11435                    } else {
11436                        // Initialize `self` to the right variant
11437                        *self = ComponentCapability::EventStream(fidl::new_empty!(
11438                            fidl_fuchsia_component_decl__common::EventStream,
11439                            D
11440                        ));
11441                    }
11442                    #[allow(irrefutable_let_patterns)]
11443                    if let ComponentCapability::EventStream(ref mut val) = self {
11444                        fidl::decode!(
11445                            fidl_fuchsia_component_decl__common::EventStream,
11446                            D,
11447                            val,
11448                            decoder,
11449                            _inner_offset,
11450                            depth
11451                        )?;
11452                    } else {
11453                        unreachable!()
11454                    }
11455                }
11456                9 => {
11457                    #[allow(irrefutable_let_patterns)]
11458                    if let ComponentCapability::Protocol(_) = self {
11459                        // Do nothing, read the value into the object
11460                    } else {
11461                        // Initialize `self` to the right variant
11462                        *self = ComponentCapability::Protocol(fidl::new_empty!(
11463                            fidl_fuchsia_component_decl__common::Protocol,
11464                            D
11465                        ));
11466                    }
11467                    #[allow(irrefutable_let_patterns)]
11468                    if let ComponentCapability::Protocol(ref mut val) = self {
11469                        fidl::decode!(
11470                            fidl_fuchsia_component_decl__common::Protocol,
11471                            D,
11472                            val,
11473                            decoder,
11474                            _inner_offset,
11475                            depth
11476                        )?;
11477                    } else {
11478                        unreachable!()
11479                    }
11480                }
11481                10 => {
11482                    #[allow(irrefutable_let_patterns)]
11483                    if let ComponentCapability::Resolver(_) = self {
11484                        // Do nothing, read the value into the object
11485                    } else {
11486                        // Initialize `self` to the right variant
11487                        *self = ComponentCapability::Resolver(fidl::new_empty!(
11488                            fidl_fuchsia_component_decl__common::Resolver,
11489                            D
11490                        ));
11491                    }
11492                    #[allow(irrefutable_let_patterns)]
11493                    if let ComponentCapability::Resolver(ref mut val) = self {
11494                        fidl::decode!(
11495                            fidl_fuchsia_component_decl__common::Resolver,
11496                            D,
11497                            val,
11498                            decoder,
11499                            _inner_offset,
11500                            depth
11501                        )?;
11502                    } else {
11503                        unreachable!()
11504                    }
11505                }
11506                11 => {
11507                    #[allow(irrefutable_let_patterns)]
11508                    if let ComponentCapability::Runner(_) = self {
11509                        // Do nothing, read the value into the object
11510                    } else {
11511                        // Initialize `self` to the right variant
11512                        *self = ComponentCapability::Runner(fidl::new_empty!(
11513                            fidl_fuchsia_component_decl__common::Runner,
11514                            D
11515                        ));
11516                    }
11517                    #[allow(irrefutable_let_patterns)]
11518                    if let ComponentCapability::Runner(ref mut val) = self {
11519                        fidl::decode!(
11520                            fidl_fuchsia_component_decl__common::Runner,
11521                            D,
11522                            val,
11523                            decoder,
11524                            _inner_offset,
11525                            depth
11526                        )?;
11527                    } else {
11528                        unreachable!()
11529                    }
11530                }
11531                12 => {
11532                    #[allow(irrefutable_let_patterns)]
11533                    if let ComponentCapability::Service(_) = self {
11534                        // Do nothing, read the value into the object
11535                    } else {
11536                        // Initialize `self` to the right variant
11537                        *self = ComponentCapability::Service(fidl::new_empty!(
11538                            fidl_fuchsia_component_decl__common::Service,
11539                            D
11540                        ));
11541                    }
11542                    #[allow(irrefutable_let_patterns)]
11543                    if let ComponentCapability::Service(ref mut val) = self {
11544                        fidl::decode!(
11545                            fidl_fuchsia_component_decl__common::Service,
11546                            D,
11547                            val,
11548                            decoder,
11549                            _inner_offset,
11550                            depth
11551                        )?;
11552                    } else {
11553                        unreachable!()
11554                    }
11555                }
11556                13 => {
11557                    #[allow(irrefutable_let_patterns)]
11558                    if let ComponentCapability::Storage(_) = self {
11559                        // Do nothing, read the value into the object
11560                    } else {
11561                        // Initialize `self` to the right variant
11562                        *self = ComponentCapability::Storage(fidl::new_empty!(
11563                            fidl_fuchsia_component_decl__common::Storage,
11564                            D
11565                        ));
11566                    }
11567                    #[allow(irrefutable_let_patterns)]
11568                    if let ComponentCapability::Storage(ref mut val) = self {
11569                        fidl::decode!(
11570                            fidl_fuchsia_component_decl__common::Storage,
11571                            D,
11572                            val,
11573                            decoder,
11574                            _inner_offset,
11575                            depth
11576                        )?;
11577                    } else {
11578                        unreachable!()
11579                    }
11580                }
11581                ordinal => panic!("unexpected ordinal {:?}", ordinal),
11582            }
11583            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11584                return Err(fidl::Error::InvalidNumBytesInEnvelope);
11585            }
11586            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11587                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11588            }
11589            Ok(())
11590        }
11591    }
11592
11593    impl fidl::encoding::ValueTypeMarker for EnvironmentCapability {
11594        type Borrowed<'a> = &'a Self;
11595        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11596            value
11597        }
11598    }
11599
11600    unsafe impl fidl::encoding::TypeMarker for EnvironmentCapability {
11601        type Owned = Self;
11602
11603        #[inline(always)]
11604        fn inline_align(_context: fidl::encoding::Context) -> usize {
11605            8
11606        }
11607
11608        #[inline(always)]
11609        fn inline_size(_context: fidl::encoding::Context) -> usize {
11610            16
11611        }
11612    }
11613
11614    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnvironmentCapability, D>
11615        for &EnvironmentCapability
11616    {
11617        #[inline]
11618        unsafe fn encode(
11619            self,
11620            encoder: &mut fidl::encoding::Encoder<'_, D>,
11621            offset: usize,
11622            _depth: fidl::encoding::Depth,
11623        ) -> fidl::Result<()> {
11624            encoder.debug_check_bounds::<EnvironmentCapability>(offset);
11625            encoder.write_num::<u64>(self.ordinal(), offset);
11626            match self {
11627                EnvironmentCapability::Runner(ref val) => {
11628                    fidl::encoding::encode_in_envelope::<EnvironmentSource, D>(
11629                        <EnvironmentSource as fidl::encoding::ValueTypeMarker>::borrow(val),
11630                        encoder,
11631                        offset + 8,
11632                        _depth,
11633                    )
11634                }
11635                EnvironmentCapability::Resolver(ref val) => {
11636                    fidl::encoding::encode_in_envelope::<EnvironmentSource, D>(
11637                        <EnvironmentSource as fidl::encoding::ValueTypeMarker>::borrow(val),
11638                        encoder,
11639                        offset + 8,
11640                        _depth,
11641                    )
11642                }
11643                EnvironmentCapability::Debug(ref val) => {
11644                    fidl::encoding::encode_in_envelope::<EnvironmentSource, D>(
11645                        <EnvironmentSource as fidl::encoding::ValueTypeMarker>::borrow(val),
11646                        encoder,
11647                        offset + 8,
11648                        _depth,
11649                    )
11650                }
11651            }
11652        }
11653    }
11654
11655    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnvironmentCapability {
11656        #[inline(always)]
11657        fn new_empty() -> Self {
11658            Self::Runner(fidl::new_empty!(EnvironmentSource, D))
11659        }
11660
11661        #[inline]
11662        unsafe fn decode(
11663            &mut self,
11664            decoder: &mut fidl::encoding::Decoder<'_, D>,
11665            offset: usize,
11666            mut depth: fidl::encoding::Depth,
11667        ) -> fidl::Result<()> {
11668            decoder.debug_check_bounds::<Self>(offset);
11669            #[allow(unused_variables)]
11670            let next_out_of_line = decoder.next_out_of_line();
11671            let handles_before = decoder.remaining_handles();
11672            let (ordinal, inlined, num_bytes, num_handles) =
11673                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11674
11675            let member_inline_size = match ordinal {
11676                1 => {
11677                    <EnvironmentSource as fidl::encoding::TypeMarker>::inline_size(decoder.context)
11678                }
11679                2 => {
11680                    <EnvironmentSource as fidl::encoding::TypeMarker>::inline_size(decoder.context)
11681                }
11682                3 => {
11683                    <EnvironmentSource as fidl::encoding::TypeMarker>::inline_size(decoder.context)
11684                }
11685                _ => return Err(fidl::Error::UnknownUnionTag),
11686            };
11687
11688            if inlined != (member_inline_size <= 4) {
11689                return Err(fidl::Error::InvalidInlineBitInEnvelope);
11690            }
11691            let _inner_offset;
11692            if inlined {
11693                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11694                _inner_offset = offset + 8;
11695            } else {
11696                depth.increment()?;
11697                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11698            }
11699            match ordinal {
11700                1 => {
11701                    #[allow(irrefutable_let_patterns)]
11702                    if let EnvironmentCapability::Runner(_) = self {
11703                        // Do nothing, read the value into the object
11704                    } else {
11705                        // Initialize `self` to the right variant
11706                        *self =
11707                            EnvironmentCapability::Runner(fidl::new_empty!(EnvironmentSource, D));
11708                    }
11709                    #[allow(irrefutable_let_patterns)]
11710                    if let EnvironmentCapability::Runner(ref mut val) = self {
11711                        fidl::decode!(EnvironmentSource, D, val, decoder, _inner_offset, depth)?;
11712                    } else {
11713                        unreachable!()
11714                    }
11715                }
11716                2 => {
11717                    #[allow(irrefutable_let_patterns)]
11718                    if let EnvironmentCapability::Resolver(_) = self {
11719                        // Do nothing, read the value into the object
11720                    } else {
11721                        // Initialize `self` to the right variant
11722                        *self =
11723                            EnvironmentCapability::Resolver(fidl::new_empty!(EnvironmentSource, D));
11724                    }
11725                    #[allow(irrefutable_let_patterns)]
11726                    if let EnvironmentCapability::Resolver(ref mut val) = self {
11727                        fidl::decode!(EnvironmentSource, D, val, decoder, _inner_offset, depth)?;
11728                    } else {
11729                        unreachable!()
11730                    }
11731                }
11732                3 => {
11733                    #[allow(irrefutable_let_patterns)]
11734                    if let EnvironmentCapability::Debug(_) = self {
11735                        // Do nothing, read the value into the object
11736                    } else {
11737                        // Initialize `self` to the right variant
11738                        *self =
11739                            EnvironmentCapability::Debug(fidl::new_empty!(EnvironmentSource, D));
11740                    }
11741                    #[allow(irrefutable_let_patterns)]
11742                    if let EnvironmentCapability::Debug(ref mut val) = self {
11743                        fidl::decode!(EnvironmentSource, D, val, decoder, _inner_offset, depth)?;
11744                    } else {
11745                        unreachable!()
11746                    }
11747                }
11748                ordinal => panic!("unexpected ordinal {:?}", ordinal),
11749            }
11750            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11751                return Err(fidl::Error::InvalidNumBytesInEnvelope);
11752            }
11753            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11754                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11755            }
11756            Ok(())
11757        }
11758    }
11759
11760    impl fidl::encoding::ValueTypeMarker for InternalCapability {
11761        type Borrowed<'a> = &'a Self;
11762        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11763            value
11764        }
11765    }
11766
11767    unsafe impl fidl::encoding::TypeMarker for InternalCapability {
11768        type Owned = Self;
11769
11770        #[inline(always)]
11771        fn inline_align(_context: fidl::encoding::Context) -> usize {
11772            8
11773        }
11774
11775        #[inline(always)]
11776        fn inline_size(_context: fidl::encoding::Context) -> usize {
11777            16
11778        }
11779    }
11780
11781    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InternalCapability, D>
11782        for &InternalCapability
11783    {
11784        #[inline]
11785        unsafe fn encode(
11786            self,
11787            encoder: &mut fidl::encoding::Encoder<'_, D>,
11788            offset: usize,
11789            _depth: fidl::encoding::Depth,
11790        ) -> fidl::Result<()> {
11791            encoder.debug_check_bounds::<InternalCapability>(offset);
11792            encoder.write_num::<u64>(self.ordinal(), offset);
11793            match self {
11794                InternalCapability::Config(ref val) => fidl::encoding::encode_in_envelope::<
11795                    fidl::encoding::BoundedString<100>,
11796                    D,
11797                >(
11798                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11799                        val,
11800                    ),
11801                    encoder,
11802                    offset + 8,
11803                    _depth,
11804                ),
11805                InternalCapability::Dictionary(ref val) => fidl::encoding::encode_in_envelope::<
11806                    fidl::encoding::BoundedString<100>,
11807                    D,
11808                >(
11809                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11810                        val,
11811                    ),
11812                    encoder,
11813                    offset + 8,
11814                    _depth,
11815                ),
11816                InternalCapability::Directory(ref val) => fidl::encoding::encode_in_envelope::<
11817                    fidl::encoding::BoundedString<100>,
11818                    D,
11819                >(
11820                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11821                        val,
11822                    ),
11823                    encoder,
11824                    offset + 8,
11825                    _depth,
11826                ),
11827                InternalCapability::EventStream(ref val) => fidl::encoding::encode_in_envelope::<
11828                    fidl::encoding::BoundedString<100>,
11829                    D,
11830                >(
11831                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11832                        val,
11833                    ),
11834                    encoder,
11835                    offset + 8,
11836                    _depth,
11837                ),
11838                InternalCapability::Protocol(ref val) => fidl::encoding::encode_in_envelope::<
11839                    fidl::encoding::BoundedString<100>,
11840                    D,
11841                >(
11842                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11843                        val,
11844                    ),
11845                    encoder,
11846                    offset + 8,
11847                    _depth,
11848                ),
11849                InternalCapability::Resolver(ref val) => fidl::encoding::encode_in_envelope::<
11850                    fidl::encoding::BoundedString<100>,
11851                    D,
11852                >(
11853                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11854                        val,
11855                    ),
11856                    encoder,
11857                    offset + 8,
11858                    _depth,
11859                ),
11860                InternalCapability::Runner(ref val) => fidl::encoding::encode_in_envelope::<
11861                    fidl::encoding::BoundedString<100>,
11862                    D,
11863                >(
11864                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11865                        val,
11866                    ),
11867                    encoder,
11868                    offset + 8,
11869                    _depth,
11870                ),
11871                InternalCapability::Service(ref val) => fidl::encoding::encode_in_envelope::<
11872                    fidl::encoding::BoundedString<100>,
11873                    D,
11874                >(
11875                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11876                        val,
11877                    ),
11878                    encoder,
11879                    offset + 8,
11880                    _depth,
11881                ),
11882                InternalCapability::Storage(ref val) => fidl::encoding::encode_in_envelope::<
11883                    fidl::encoding::BoundedString<100>,
11884                    D,
11885                >(
11886                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11887                        val,
11888                    ),
11889                    encoder,
11890                    offset + 8,
11891                    _depth,
11892                ),
11893            }
11894        }
11895    }
11896
11897    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InternalCapability {
11898        #[inline(always)]
11899        fn new_empty() -> Self {
11900            Self::Config(fidl::new_empty!(fidl::encoding::BoundedString<100>, D))
11901        }
11902
11903        #[inline]
11904        unsafe fn decode(
11905            &mut self,
11906            decoder: &mut fidl::encoding::Decoder<'_, D>,
11907            offset: usize,
11908            mut depth: fidl::encoding::Depth,
11909        ) -> fidl::Result<()> {
11910            decoder.debug_check_bounds::<Self>(offset);
11911            #[allow(unused_variables)]
11912            let next_out_of_line = decoder.next_out_of_line();
11913            let handles_before = decoder.remaining_handles();
11914            let (ordinal, inlined, num_bytes, num_handles) =
11915                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11916
11917            let member_inline_size = match ordinal {
11918                1 => {
11919                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11920                        decoder.context,
11921                    )
11922                }
11923                2 => {
11924                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11925                        decoder.context,
11926                    )
11927                }
11928                3 => {
11929                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11930                        decoder.context,
11931                    )
11932                }
11933                4 => {
11934                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11935                        decoder.context,
11936                    )
11937                }
11938                5 => {
11939                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11940                        decoder.context,
11941                    )
11942                }
11943                6 => {
11944                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11945                        decoder.context,
11946                    )
11947                }
11948                7 => {
11949                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11950                        decoder.context,
11951                    )
11952                }
11953                8 => {
11954                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11955                        decoder.context,
11956                    )
11957                }
11958                9 => {
11959                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11960                        decoder.context,
11961                    )
11962                }
11963                _ => return Err(fidl::Error::UnknownUnionTag),
11964            };
11965
11966            if inlined != (member_inline_size <= 4) {
11967                return Err(fidl::Error::InvalidInlineBitInEnvelope);
11968            }
11969            let _inner_offset;
11970            if inlined {
11971                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11972                _inner_offset = offset + 8;
11973            } else {
11974                depth.increment()?;
11975                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11976            }
11977            match ordinal {
11978                1 => {
11979                    #[allow(irrefutable_let_patterns)]
11980                    if let InternalCapability::Config(_) = self {
11981                        // Do nothing, read the value into the object
11982                    } else {
11983                        // Initialize `self` to the right variant
11984                        *self = InternalCapability::Config(fidl::new_empty!(
11985                            fidl::encoding::BoundedString<100>,
11986                            D
11987                        ));
11988                    }
11989                    #[allow(irrefutable_let_patterns)]
11990                    if let InternalCapability::Config(ref mut val) = self {
11991                        fidl::decode!(
11992                            fidl::encoding::BoundedString<100>,
11993                            D,
11994                            val,
11995                            decoder,
11996                            _inner_offset,
11997                            depth
11998                        )?;
11999                    } else {
12000                        unreachable!()
12001                    }
12002                }
12003                2 => {
12004                    #[allow(irrefutable_let_patterns)]
12005                    if let InternalCapability::Dictionary(_) = self {
12006                        // Do nothing, read the value into the object
12007                    } else {
12008                        // Initialize `self` to the right variant
12009                        *self = InternalCapability::Dictionary(fidl::new_empty!(
12010                            fidl::encoding::BoundedString<100>,
12011                            D
12012                        ));
12013                    }
12014                    #[allow(irrefutable_let_patterns)]
12015                    if let InternalCapability::Dictionary(ref mut val) = self {
12016                        fidl::decode!(
12017                            fidl::encoding::BoundedString<100>,
12018                            D,
12019                            val,
12020                            decoder,
12021                            _inner_offset,
12022                            depth
12023                        )?;
12024                    } else {
12025                        unreachable!()
12026                    }
12027                }
12028                3 => {
12029                    #[allow(irrefutable_let_patterns)]
12030                    if let InternalCapability::Directory(_) = self {
12031                        // Do nothing, read the value into the object
12032                    } else {
12033                        // Initialize `self` to the right variant
12034                        *self = InternalCapability::Directory(fidl::new_empty!(
12035                            fidl::encoding::BoundedString<100>,
12036                            D
12037                        ));
12038                    }
12039                    #[allow(irrefutable_let_patterns)]
12040                    if let InternalCapability::Directory(ref mut val) = self {
12041                        fidl::decode!(
12042                            fidl::encoding::BoundedString<100>,
12043                            D,
12044                            val,
12045                            decoder,
12046                            _inner_offset,
12047                            depth
12048                        )?;
12049                    } else {
12050                        unreachable!()
12051                    }
12052                }
12053                4 => {
12054                    #[allow(irrefutable_let_patterns)]
12055                    if let InternalCapability::EventStream(_) = self {
12056                        // Do nothing, read the value into the object
12057                    } else {
12058                        // Initialize `self` to the right variant
12059                        *self = InternalCapability::EventStream(fidl::new_empty!(
12060                            fidl::encoding::BoundedString<100>,
12061                            D
12062                        ));
12063                    }
12064                    #[allow(irrefutable_let_patterns)]
12065                    if let InternalCapability::EventStream(ref mut val) = self {
12066                        fidl::decode!(
12067                            fidl::encoding::BoundedString<100>,
12068                            D,
12069                            val,
12070                            decoder,
12071                            _inner_offset,
12072                            depth
12073                        )?;
12074                    } else {
12075                        unreachable!()
12076                    }
12077                }
12078                5 => {
12079                    #[allow(irrefutable_let_patterns)]
12080                    if let InternalCapability::Protocol(_) = self {
12081                        // Do nothing, read the value into the object
12082                    } else {
12083                        // Initialize `self` to the right variant
12084                        *self = InternalCapability::Protocol(fidl::new_empty!(
12085                            fidl::encoding::BoundedString<100>,
12086                            D
12087                        ));
12088                    }
12089                    #[allow(irrefutable_let_patterns)]
12090                    if let InternalCapability::Protocol(ref mut val) = self {
12091                        fidl::decode!(
12092                            fidl::encoding::BoundedString<100>,
12093                            D,
12094                            val,
12095                            decoder,
12096                            _inner_offset,
12097                            depth
12098                        )?;
12099                    } else {
12100                        unreachable!()
12101                    }
12102                }
12103                6 => {
12104                    #[allow(irrefutable_let_patterns)]
12105                    if let InternalCapability::Resolver(_) = self {
12106                        // Do nothing, read the value into the object
12107                    } else {
12108                        // Initialize `self` to the right variant
12109                        *self = InternalCapability::Resolver(fidl::new_empty!(
12110                            fidl::encoding::BoundedString<100>,
12111                            D
12112                        ));
12113                    }
12114                    #[allow(irrefutable_let_patterns)]
12115                    if let InternalCapability::Resolver(ref mut val) = self {
12116                        fidl::decode!(
12117                            fidl::encoding::BoundedString<100>,
12118                            D,
12119                            val,
12120                            decoder,
12121                            _inner_offset,
12122                            depth
12123                        )?;
12124                    } else {
12125                        unreachable!()
12126                    }
12127                }
12128                7 => {
12129                    #[allow(irrefutable_let_patterns)]
12130                    if let InternalCapability::Runner(_) = self {
12131                        // Do nothing, read the value into the object
12132                    } else {
12133                        // Initialize `self` to the right variant
12134                        *self = InternalCapability::Runner(fidl::new_empty!(
12135                            fidl::encoding::BoundedString<100>,
12136                            D
12137                        ));
12138                    }
12139                    #[allow(irrefutable_let_patterns)]
12140                    if let InternalCapability::Runner(ref mut val) = self {
12141                        fidl::decode!(
12142                            fidl::encoding::BoundedString<100>,
12143                            D,
12144                            val,
12145                            decoder,
12146                            _inner_offset,
12147                            depth
12148                        )?;
12149                    } else {
12150                        unreachable!()
12151                    }
12152                }
12153                8 => {
12154                    #[allow(irrefutable_let_patterns)]
12155                    if let InternalCapability::Service(_) = self {
12156                        // Do nothing, read the value into the object
12157                    } else {
12158                        // Initialize `self` to the right variant
12159                        *self = InternalCapability::Service(fidl::new_empty!(
12160                            fidl::encoding::BoundedString<100>,
12161                            D
12162                        ));
12163                    }
12164                    #[allow(irrefutable_let_patterns)]
12165                    if let InternalCapability::Service(ref mut val) = self {
12166                        fidl::decode!(
12167                            fidl::encoding::BoundedString<100>,
12168                            D,
12169                            val,
12170                            decoder,
12171                            _inner_offset,
12172                            depth
12173                        )?;
12174                    } else {
12175                        unreachable!()
12176                    }
12177                }
12178                9 => {
12179                    #[allow(irrefutable_let_patterns)]
12180                    if let InternalCapability::Storage(_) = self {
12181                        // Do nothing, read the value into the object
12182                    } else {
12183                        // Initialize `self` to the right variant
12184                        *self = InternalCapability::Storage(fidl::new_empty!(
12185                            fidl::encoding::BoundedString<100>,
12186                            D
12187                        ));
12188                    }
12189                    #[allow(irrefutable_let_patterns)]
12190                    if let InternalCapability::Storage(ref mut val) = self {
12191                        fidl::decode!(
12192                            fidl::encoding::BoundedString<100>,
12193                            D,
12194                            val,
12195                            decoder,
12196                            _inner_offset,
12197                            depth
12198                        )?;
12199                    } else {
12200                        unreachable!()
12201                    }
12202                }
12203                ordinal => panic!("unexpected ordinal {:?}", ordinal),
12204            }
12205            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
12206                return Err(fidl::Error::InvalidNumBytesInEnvelope);
12207            }
12208            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12209                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12210            }
12211            Ok(())
12212        }
12213    }
12214}
fidl_fuchsia_component_internal__common/fidl_fuchsia_component_internal__common.rs

fidl_fuchsia_component_internal__common/
fidl_fuchsia_component_internal__common.rs
