fidl_fuchsia_component_internal__common/
fidl_fuchsia_component_internal__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// 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    /// Capabilities to inject into components at runtime.
399    pub inject_capabilities: Option<Vec<InjectedCapabilities>>,
400    /// Runtime configuration for Scudo heap allocation, using a 'KEY=VALUE,KEY=VALUE'
401    /// format. See Scudo flags documentation for details. It is shadowed by `SCUDO_OPTIONS`
402    pub scudo_options: Option<String>,
403    #[doc(hidden)]
404    pub __source_breaking: fidl::marker::SourceBreaking,
405}
406
407impl fidl::Persistable for Config {}
408
409/// Defines a capability policy entry in the set of debug capability policy
410/// allowlists.
411#[derive(Clone, Debug, Default, PartialEq)]
412pub struct DebugRegistrationAllowlistEntry {
413    /// The name of the capability as it's registered in the environment.
414    pub name: Option<String>,
415    /// Represents the type of capability that is being restricted along
416    /// with any other properties required by a particular capability type.
417    pub debug: Option<AllowlistedDebugRegistration>,
418    /// The moniker of the component which is allowed to register
419    /// this capability in its environment's debug sction.
420    pub moniker: Option<String>,
421    /// Name of the environment where this capability can be registered.
422    pub environment_name: Option<String>,
423    #[doc(hidden)]
424    pub __source_breaking: fidl::marker::SourceBreaking,
425}
426
427impl fidl::Persistable for DebugRegistrationAllowlistEntry {}
428
429/// Defines the total set of debug capability allowlists.
430#[derive(Clone, Debug, Default, PartialEq)]
431pub struct DebugRegistrationPolicyAllowlists {
432    pub allowlist: Option<Vec<DebugRegistrationAllowlistEntry>>,
433    #[doc(hidden)]
434    pub __source_breaking: fidl::marker::SourceBreaking,
435}
436
437impl fidl::Persistable for DebugRegistrationPolicyAllowlists {}
438
439#[derive(Clone, Debug, Default, PartialEq)]
440pub struct Environment {
441    pub capability: Option<ComponentCapability>,
442    pub moniker: Option<String>,
443    #[doc(hidden)]
444    pub __source_breaking: fidl::marker::SourceBreaking,
445}
446
447impl fidl::Persistable for Environment {}
448
449#[derive(Clone, Debug, Default, PartialEq)]
450pub struct EnvironmentSource {
451    pub source_name: Option<String>,
452    pub source: Option<fidl_fuchsia_component_decl__common::Ref>,
453    #[doc(hidden)]
454    pub __source_breaking: fidl::marker::SourceBreaking,
455}
456
457impl fidl::Persistable for EnvironmentSource {}
458
459/// This value is used internally by event stream routers, to carry information
460/// pertinent to the route.
461#[derive(Clone, Debug, Default, PartialEq)]
462pub struct EventStreamRouteMetadata {
463    /// The moniker of the component that has set a scope on this event stream.
464    /// Unset if there is no scope on the event stream.
465    pub scope_moniker: Option<String>,
466    /// The scope(s) from which the consumer of this event stream will be able
467    /// to observe events. Relative to the `scope_moniker`. Unset if there is no
468    /// scope on the event stream.
469    pub scope: Option<Vec<fidl_fuchsia_component_decl__common::Ref>>,
470    #[doc(hidden)]
471    pub __source_breaking: fidl::marker::SourceBreaking,
472}
473
474impl fidl::Persistable for EventStreamRouteMetadata {}
475
476#[derive(Clone, Debug, Default, PartialEq)]
477pub struct FilteredAggregateProvider {
478    pub capability: Option<AggregateCapability>,
479    pub moniker: Option<String>,
480    pub offer_service_decls: Option<Vec<fidl_fuchsia_component_decl__common::OfferService>>,
481    pub sources: Option<Sources>,
482    #[doc(hidden)]
483    pub __source_breaking: fidl::marker::SourceBreaking,
484}
485
486impl fidl::Persistable for FilteredAggregateProvider {}
487
488#[derive(Clone, Debug, Default, PartialEq)]
489pub struct FilteredProvider {
490    pub capability: Option<AggregateCapability>,
491    pub moniker: Option<String>,
492    pub service_capability: Option<ComponentCapability>,
493    pub offer_service_decl: Option<fidl_fuchsia_component_decl__common::OfferService>,
494    #[doc(hidden)]
495    pub __source_breaking: fidl::marker::SourceBreaking,
496}
497
498impl fidl::Persistable for FilteredProvider {}
499
500#[derive(Clone, Debug, Default, PartialEq)]
501pub struct Framework {
502    pub capability: Option<InternalCapability>,
503    pub moniker: Option<String>,
504    #[doc(hidden)]
505    pub __source_breaking: fidl::marker::SourceBreaking,
506}
507
508impl fidl::Persistable for Framework {}
509
510/// Information about the health checks during the update process.
511#[derive(Clone, Debug, Default, PartialEq)]
512pub struct HealthCheck {
513    /// Component monikers that must be healthy in order to complete an OTA update.
514    pub monikers: Option<Vec<String>>,
515    #[doc(hidden)]
516    pub __source_breaking: fidl::marker::SourceBreaking,
517}
518
519impl fidl::Persistable for HealthCheck {}
520
521/// Declares a group of extra capabilities that are layered at runtime on top of
522/// those that would normally be routed to the component.
523#[derive(Clone, Debug, Default, PartialEq)]
524pub struct InjectedCapabilities {
525    /// (Required) Components that will have these capabilities injected into.
526    pub components: Option<Vec<String>>,
527    /// (Optional) Capabilities to be injected.
528    pub use_: Option<Vec<InjectedUse>>,
529    #[doc(hidden)]
530    pub __source_breaking: fidl::marker::SourceBreaking,
531}
532
533impl fidl::Persistable for InjectedCapabilities {}
534
535/// Declares a protocol to be injected into a component.
536#[derive(Clone, Debug, Default, PartialEq)]
537pub struct InjectedUseProtocol {
538    /// (Required) Name identifying the protocol within the root component.
539    pub source_name: Option<String>,
540    /// (Required) The path where the capability should be injected in the new
541    /// component's namespace.
542    ///
543    /// Must be an absolute path starting with /.
544    pub target_path: Option<String>,
545    #[doc(hidden)]
546    pub __source_breaking: fidl::marker::SourceBreaking,
547}
548
549impl fidl::Persistable for InjectedUseProtocol {}
550
551#[derive(Clone, Debug, Default, PartialEq)]
552pub struct InstanceIdEntry {
553    /// A 256-bit identifier encoded in base64 which is unique across all other
554    /// instance IDs in the index.
555    pub instance_id: Option<String>,
556    /// The moniker identifying the component instance.
557    pub moniker: Option<String>,
558    #[doc(hidden)]
559    pub __source_breaking: fidl::marker::SourceBreaking,
560}
561
562impl fidl::Persistable for InstanceIdEntry {}
563
564/// Allowlists for Zircon job policy.
565#[derive(Clone, Debug, Default, PartialEq)]
566pub struct JobPolicyAllowlists {
567    /// Allowlist entry monikers for components allowed to be given the
568    /// ZX_POL_AMBIENT_MARK_VMO_EXEC job policy.
569    ///
570    /// Components must request this policy by including "job_policy_ambient_mark_vmo_exec: true" in
571    /// their CML's `program` section and must be using the ELF runner.
572    /// This is equivalent to the v1 'deprecated-ambient-replace-as-executable' feature.
573    pub ambient_mark_vmo_exec: Option<Vec<String>>,
574    /// Allowlist entry monikers for components allowed to have their original process
575    /// marked as critical to component_manager's job.
576    ///
577    /// Components must request this critical marking by including "main_process_critical: true" in
578    /// their CML's `program` section and must be using the ELF runner.
579    pub main_process_critical: Option<Vec<String>>,
580    /// Allowlist entry monikers for components allowed to call zx_process_create directly
581    /// (e.g., do not have ZX_POL_NEW_PROCESS set to ZX_POL_ACTION_DENY).
582    ///
583    /// Components must request this policy by including "job_policy_create_raw_processes: true" in
584    /// their manifest's program object and must be using the ELF runner.
585    pub create_raw_processes: Option<Vec<String>>,
586    #[doc(hidden)]
587    pub __source_breaking: fidl::marker::SourceBreaking,
588}
589
590impl fidl::Persistable for JobPolicyAllowlists {}
591
592#[derive(Clone, Debug, Default, PartialEq)]
593pub struct Namespace {
594    pub capability: Option<ComponentCapability>,
595    #[doc(hidden)]
596    pub __source_breaking: fidl::marker::SourceBreaking,
597}
598
599impl fidl::Persistable for Namespace {}
600
601/// Runtime security policy.
602#[derive(Clone, Debug, Default, PartialEq)]
603pub struct SecurityPolicy {
604    /// Allowlists for Zircon job policy.
605    pub job_policy: Option<JobPolicyAllowlists>,
606    /// Capability access policy.
607    pub capability_policy: Option<CapabilityPolicyAllowlists>,
608    /// Debug capability registration policy.
609    pub debug_registration_policy: Option<DebugRegistrationPolicyAllowlists>,
610    /// Component child options policy.
611    pub child_policy: Option<ChildPolicyAllowlists>,
612    #[doc(hidden)]
613    pub __source_breaking: fidl::marker::SourceBreaking,
614}
615
616impl fidl::Persistable for SecurityPolicy {}
617
618#[derive(Clone, Debug, Default, PartialEq)]
619pub struct Sources {
620    pub framework: Option<bool>,
621    pub builtin: Option<bool>,
622    pub capability: Option<bool>,
623    pub collection: Option<bool>,
624    pub namespace: Option<bool>,
625    pub component: Option<bool>,
626    pub capability_type: Option<String>,
627    #[doc(hidden)]
628    pub __source_breaking: fidl::marker::SourceBreaking,
629}
630
631impl fidl::Persistable for Sources {}
632
633#[derive(Clone, Debug, Default, PartialEq)]
634pub struct StorageBackingDirectory {
635    pub capability: Option<ComponentCapability>,
636    pub moniker: Option<String>,
637    pub backing_dir_subdir: Option<String>,
638    pub storage_subdir: Option<String>,
639    pub storage_source_moniker: Option<String>,
640    #[doc(hidden)]
641    pub __source_breaking: fidl::marker::SourceBreaking,
642}
643
644impl fidl::Persistable for StorageBackingDirectory {}
645
646#[derive(Clone, Debug, Default, PartialEq)]
647pub struct Void {
648    pub capability: Option<InternalCapability>,
649    pub moniker: Option<String>,
650    #[doc(hidden)]
651    pub __source_breaking: fidl::marker::SourceBreaking,
652}
653
654impl fidl::Persistable for Void {}
655
656#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
657pub enum AggregateCapability {
658    Service(String),
659}
660
661impl AggregateCapability {
662    #[inline]
663    pub fn ordinal(&self) -> u64 {
664        match *self {
665            Self::Service(_) => 1,
666        }
667    }
668}
669
670impl fidl::Persistable for AggregateCapability {}
671
672#[derive(Clone, Debug, PartialEq)]
673pub enum AggregateMember {
674    Child(fidl_fuchsia_component_decl__common::ChildRef),
675    Collection(String),
676    Parent(fidl_fuchsia_component_decl__common::ParentRef),
677    Self_(fidl_fuchsia_component_decl__common::SelfRef),
678}
679
680impl AggregateMember {
681    #[inline]
682    pub fn ordinal(&self) -> u64 {
683        match *self {
684            Self::Child(_) => 1,
685            Self::Collection(_) => 2,
686            Self::Parent(_) => 3,
687            Self::Self_(_) => 4,
688        }
689    }
690}
691
692impl fidl::Persistable for AggregateMember {}
693
694/// Represents the class of capabilities supported to be allowlisted.
695#[derive(Clone, Debug)]
696pub enum AllowlistedCapability {
697    Directory(AllowlistedDirectory),
698    Protocol(AllowlistedProtocol),
699    Service(AllowlistedService),
700    Storage(AllowlistedStorage),
701    Runner(AllowlistedRunner),
702    Resolver(AllowlistedResolver),
703    #[doc(hidden)]
704    __SourceBreaking {
705        unknown_ordinal: u64,
706    },
707}
708
709/// Pattern that matches an unknown `AllowlistedCapability` member.
710#[macro_export]
711macro_rules! AllowlistedCapabilityUnknown {
712    () => {
713        _
714    };
715}
716
717// Custom PartialEq so that unknown variants are not equal to themselves.
718impl PartialEq for AllowlistedCapability {
719    fn eq(&self, other: &Self) -> bool {
720        match (self, other) {
721            (Self::Directory(x), Self::Directory(y)) => *x == *y,
722            (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
723            (Self::Service(x), Self::Service(y)) => *x == *y,
724            (Self::Storage(x), Self::Storage(y)) => *x == *y,
725            (Self::Runner(x), Self::Runner(y)) => *x == *y,
726            (Self::Resolver(x), Self::Resolver(y)) => *x == *y,
727            _ => false,
728        }
729    }
730}
731
732impl AllowlistedCapability {
733    #[inline]
734    pub fn ordinal(&self) -> u64 {
735        match *self {
736            Self::Directory(_) => 1,
737            Self::Protocol(_) => 3,
738            Self::Service(_) => 4,
739            Self::Storage(_) => 5,
740            Self::Runner(_) => 6,
741            Self::Resolver(_) => 7,
742            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
743        }
744    }
745
746    #[inline]
747    pub fn unknown_variant_for_testing() -> Self {
748        Self::__SourceBreaking { unknown_ordinal: 0 }
749    }
750
751    #[inline]
752    pub fn is_unknown(&self) -> bool {
753        match self {
754            Self::__SourceBreaking { .. } => true,
755            _ => false,
756        }
757    }
758}
759
760impl fidl::Persistable for AllowlistedCapability {}
761
762/// Represents the class of capabilities supported to be allowlisted.
763#[derive(Clone, Debug)]
764pub enum AllowlistedDebugRegistration {
765    Protocol(AllowlistedProtocol),
766    #[doc(hidden)]
767    __SourceBreaking {
768        unknown_ordinal: u64,
769    },
770}
771
772/// Pattern that matches an unknown `AllowlistedDebugRegistration` member.
773#[macro_export]
774macro_rules! AllowlistedDebugRegistrationUnknown {
775    () => {
776        _
777    };
778}
779
780// Custom PartialEq so that unknown variants are not equal to themselves.
781impl PartialEq for AllowlistedDebugRegistration {
782    fn eq(&self, other: &Self) -> bool {
783        match (self, other) {
784            (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
785            _ => false,
786        }
787    }
788}
789
790impl AllowlistedDebugRegistration {
791    #[inline]
792    pub fn ordinal(&self) -> u64 {
793        match *self {
794            Self::Protocol(_) => 1,
795            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
796        }
797    }
798
799    #[inline]
800    pub fn unknown_variant_for_testing() -> Self {
801        Self::__SourceBreaking { unknown_ordinal: 0 }
802    }
803
804    #[inline]
805    pub fn is_unknown(&self) -> bool {
806        match self {
807            Self::__SourceBreaking { .. } => true,
808            _ => false,
809        }
810    }
811}
812
813impl fidl::Persistable for AllowlistedDebugRegistration {}
814
815#[derive(Clone, Debug, PartialEq)]
816pub enum CapabilitySource {
817    Component(Component),
818    Framework(Framework),
819    Builtin(Builtin),
820    Namespace(Namespace),
821    Capability(Capability),
822    AnonymizedAggregate(AnonymizedAggregate),
823    FilteredProvider(FilteredProvider),
824    FilteredAggregateProvider(FilteredAggregateProvider),
825    Environment(Environment),
826    Void(Void),
827    RemotedAt(String),
828    StorageBackingDirectory(StorageBackingDirectory),
829}
830
831impl CapabilitySource {
832    #[inline]
833    pub fn ordinal(&self) -> u64 {
834        match *self {
835            Self::Component(_) => 1,
836            Self::Framework(_) => 2,
837            Self::Builtin(_) => 3,
838            Self::Namespace(_) => 4,
839            Self::Capability(_) => 5,
840            Self::AnonymizedAggregate(_) => 6,
841            Self::FilteredProvider(_) => 7,
842            Self::FilteredAggregateProvider(_) => 8,
843            Self::Environment(_) => 9,
844            Self::Void(_) => 10,
845            Self::RemotedAt(_) => 11,
846            Self::StorageBackingDirectory(_) => 12,
847        }
848    }
849}
850
851impl fidl::Persistable for CapabilitySource {}
852
853#[derive(Clone, Debug, PartialEq)]
854pub enum ComponentCapability {
855    Use_(fidl_fuchsia_component_decl__common::Use),
856    Offer(fidl_fuchsia_component_decl__common::Offer),
857    Expose(fidl_fuchsia_component_decl__common::Expose),
858    Config(fidl_fuchsia_component_decl__common::Configuration),
859    Dictionary(fidl_fuchsia_component_decl__common::Dictionary),
860    Directory(fidl_fuchsia_component_decl__common::Directory),
861    Environment(EnvironmentCapability),
862    EventStream(fidl_fuchsia_component_decl__common::EventStream),
863    Protocol(fidl_fuchsia_component_decl__common::Protocol),
864    Resolver(fidl_fuchsia_component_decl__common::Resolver),
865    Runner(fidl_fuchsia_component_decl__common::Runner),
866    Service(fidl_fuchsia_component_decl__common::Service),
867    Storage(fidl_fuchsia_component_decl__common::Storage),
868}
869
870impl ComponentCapability {
871    #[inline]
872    pub fn ordinal(&self) -> u64 {
873        match *self {
874            Self::Use_(_) => 1,
875            Self::Offer(_) => 2,
876            Self::Expose(_) => 3,
877            Self::Config(_) => 4,
878            Self::Dictionary(_) => 5,
879            Self::Directory(_) => 6,
880            Self::Environment(_) => 7,
881            Self::EventStream(_) => 8,
882            Self::Protocol(_) => 9,
883            Self::Resolver(_) => 10,
884            Self::Runner(_) => 11,
885            Self::Service(_) => 12,
886            Self::Storage(_) => 13,
887        }
888    }
889}
890
891impl fidl::Persistable for ComponentCapability {}
892
893#[derive(Clone, Debug, PartialEq)]
894pub enum EnvironmentCapability {
895    Runner(EnvironmentSource),
896    Resolver(EnvironmentSource),
897    Debug(EnvironmentSource),
898}
899
900impl EnvironmentCapability {
901    #[inline]
902    pub fn ordinal(&self) -> u64 {
903        match *self {
904            Self::Runner(_) => 1,
905            Self::Resolver(_) => 2,
906            Self::Debug(_) => 3,
907        }
908    }
909}
910
911impl fidl::Persistable for EnvironmentCapability {}
912
913/// Declares a capability to be injected into a component.
914#[derive(Clone, Debug)]
915pub enum InjectedUse {
916    Protocol(InjectedUseProtocol),
917    #[doc(hidden)]
918    __SourceBreaking {
919        unknown_ordinal: u64,
920    },
921}
922
923/// Pattern that matches an unknown `InjectedUse` member.
924#[macro_export]
925macro_rules! InjectedUseUnknown {
926    () => {
927        _
928    };
929}
930
931// Custom PartialEq so that unknown variants are not equal to themselves.
932impl PartialEq for InjectedUse {
933    fn eq(&self, other: &Self) -> bool {
934        match (self, other) {
935            (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
936            _ => false,
937        }
938    }
939}
940
941impl InjectedUse {
942    #[inline]
943    pub fn ordinal(&self) -> u64 {
944        match *self {
945            Self::Protocol(_) => 1,
946            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
947        }
948    }
949
950    #[inline]
951    pub fn unknown_variant_for_testing() -> Self {
952        Self::__SourceBreaking { unknown_ordinal: 0 }
953    }
954
955    #[inline]
956    pub fn is_unknown(&self) -> bool {
957        match self {
958            Self::__SourceBreaking { .. } => true,
959            _ => false,
960        }
961    }
962}
963
964impl fidl::Persistable for InjectedUse {}
965
966#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
967pub enum InternalCapability {
968    Config(String),
969    Dictionary(String),
970    Directory(String),
971    EventStream(String),
972    Protocol(String),
973    Resolver(String),
974    Runner(String),
975    Service(String),
976    Storage(String),
977}
978
979impl InternalCapability {
980    #[inline]
981    pub fn ordinal(&self) -> u64 {
982        match *self {
983            Self::Config(_) => 1,
984            Self::Dictionary(_) => 2,
985            Self::Directory(_) => 3,
986            Self::EventStream(_) => 4,
987            Self::Protocol(_) => 5,
988            Self::Resolver(_) => 6,
989            Self::Runner(_) => 7,
990            Self::Service(_) => 8,
991            Self::Storage(_) => 9,
992        }
993    }
994}
995
996impl fidl::Persistable for InternalCapability {}
997
998pub mod component_sandbox_retriever_ordinals {
999    pub const GET_MY_SANDBOX: u64 = 0x61ca075fb9860e84;
1000}
1001
1002mod internal {
1003    use super::*;
1004    unsafe impl fidl::encoding::TypeMarker for BuiltinBootResolver {
1005        type Owned = Self;
1006
1007        #[inline(always)]
1008        fn inline_align(_context: fidl::encoding::Context) -> usize {
1009            std::mem::align_of::<u8>()
1010        }
1011
1012        #[inline(always)]
1013        fn inline_size(_context: fidl::encoding::Context) -> usize {
1014            std::mem::size_of::<u8>()
1015        }
1016
1017        #[inline(always)]
1018        fn encode_is_copy() -> bool {
1019            true
1020        }
1021
1022        #[inline(always)]
1023        fn decode_is_copy() -> bool {
1024            false
1025        }
1026    }
1027
1028    impl fidl::encoding::ValueTypeMarker for BuiltinBootResolver {
1029        type Borrowed<'a> = Self;
1030        #[inline(always)]
1031        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1032            *value
1033        }
1034    }
1035
1036    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1037        for BuiltinBootResolver
1038    {
1039        #[inline]
1040        unsafe fn encode(
1041            self,
1042            encoder: &mut fidl::encoding::Encoder<'_, D>,
1043            offset: usize,
1044            _depth: fidl::encoding::Depth,
1045        ) -> fidl::Result<()> {
1046            encoder.debug_check_bounds::<Self>(offset);
1047            encoder.write_num(self.into_primitive(), offset);
1048            Ok(())
1049        }
1050    }
1051
1052    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BuiltinBootResolver {
1053        #[inline(always)]
1054        fn new_empty() -> Self {
1055            Self::None
1056        }
1057
1058        #[inline]
1059        unsafe fn decode(
1060            &mut self,
1061            decoder: &mut fidl::encoding::Decoder<'_, D>,
1062            offset: usize,
1063            _depth: fidl::encoding::Depth,
1064        ) -> fidl::Result<()> {
1065            decoder.debug_check_bounds::<Self>(offset);
1066            let prim = decoder.read_num::<u8>(offset);
1067
1068            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1069            Ok(())
1070        }
1071    }
1072    unsafe impl fidl::encoding::TypeMarker for LogDestination {
1073        type Owned = Self;
1074
1075        #[inline(always)]
1076        fn inline_align(_context: fidl::encoding::Context) -> usize {
1077            std::mem::align_of::<u8>()
1078        }
1079
1080        #[inline(always)]
1081        fn inline_size(_context: fidl::encoding::Context) -> usize {
1082            std::mem::size_of::<u8>()
1083        }
1084
1085        #[inline(always)]
1086        fn encode_is_copy() -> bool {
1087            true
1088        }
1089
1090        #[inline(always)]
1091        fn decode_is_copy() -> bool {
1092            false
1093        }
1094    }
1095
1096    impl fidl::encoding::ValueTypeMarker for LogDestination {
1097        type Borrowed<'a> = Self;
1098        #[inline(always)]
1099        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1100            *value
1101        }
1102    }
1103
1104    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for LogDestination {
1105        #[inline]
1106        unsafe fn encode(
1107            self,
1108            encoder: &mut fidl::encoding::Encoder<'_, D>,
1109            offset: usize,
1110            _depth: fidl::encoding::Depth,
1111        ) -> fidl::Result<()> {
1112            encoder.debug_check_bounds::<Self>(offset);
1113            encoder.write_num(self.into_primitive(), offset);
1114            Ok(())
1115        }
1116    }
1117
1118    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LogDestination {
1119        #[inline(always)]
1120        fn new_empty() -> Self {
1121            Self::Syslog
1122        }
1123
1124        #[inline]
1125        unsafe fn decode(
1126            &mut self,
1127            decoder: &mut fidl::encoding::Decoder<'_, D>,
1128            offset: usize,
1129            _depth: fidl::encoding::Depth,
1130        ) -> fidl::Result<()> {
1131            decoder.debug_check_bounds::<Self>(offset);
1132            let prim = decoder.read_num::<u8>(offset);
1133
1134            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1135            Ok(())
1136        }
1137    }
1138    unsafe impl fidl::encoding::TypeMarker for RealmBuilderResolverAndRunner {
1139        type Owned = Self;
1140
1141        #[inline(always)]
1142        fn inline_align(_context: fidl::encoding::Context) -> usize {
1143            std::mem::align_of::<u8>()
1144        }
1145
1146        #[inline(always)]
1147        fn inline_size(_context: fidl::encoding::Context) -> usize {
1148            std::mem::size_of::<u8>()
1149        }
1150
1151        #[inline(always)]
1152        fn encode_is_copy() -> bool {
1153            true
1154        }
1155
1156        #[inline(always)]
1157        fn decode_is_copy() -> bool {
1158            false
1159        }
1160    }
1161
1162    impl fidl::encoding::ValueTypeMarker for RealmBuilderResolverAndRunner {
1163        type Borrowed<'a> = Self;
1164        #[inline(always)]
1165        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1166            *value
1167        }
1168    }
1169
1170    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1171        for RealmBuilderResolverAndRunner
1172    {
1173        #[inline]
1174        unsafe fn encode(
1175            self,
1176            encoder: &mut fidl::encoding::Encoder<'_, D>,
1177            offset: usize,
1178            _depth: fidl::encoding::Depth,
1179        ) -> fidl::Result<()> {
1180            encoder.debug_check_bounds::<Self>(offset);
1181            encoder.write_num(self.into_primitive(), offset);
1182            Ok(())
1183        }
1184    }
1185
1186    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1187        for RealmBuilderResolverAndRunner
1188    {
1189        #[inline(always)]
1190        fn new_empty() -> Self {
1191            Self::None
1192        }
1193
1194        #[inline]
1195        unsafe fn decode(
1196            &mut self,
1197            decoder: &mut fidl::encoding::Decoder<'_, D>,
1198            offset: usize,
1199            _depth: fidl::encoding::Depth,
1200        ) -> fidl::Result<()> {
1201            decoder.debug_check_bounds::<Self>(offset);
1202            let prim = decoder.read_num::<u8>(offset);
1203
1204            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1205            Ok(())
1206        }
1207    }
1208    unsafe impl fidl::encoding::TypeMarker for TraceProvider {
1209        type Owned = Self;
1210
1211        #[inline(always)]
1212        fn inline_align(_context: fidl::encoding::Context) -> usize {
1213            std::mem::align_of::<u8>()
1214        }
1215
1216        #[inline(always)]
1217        fn inline_size(_context: fidl::encoding::Context) -> usize {
1218            std::mem::size_of::<u8>()
1219        }
1220
1221        #[inline(always)]
1222        fn encode_is_copy() -> bool {
1223            true
1224        }
1225
1226        #[inline(always)]
1227        fn decode_is_copy() -> bool {
1228            false
1229        }
1230    }
1231
1232    impl fidl::encoding::ValueTypeMarker for TraceProvider {
1233        type Borrowed<'a> = Self;
1234        #[inline(always)]
1235        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1236            *value
1237        }
1238    }
1239
1240    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for TraceProvider {
1241        #[inline]
1242        unsafe fn encode(
1243            self,
1244            encoder: &mut fidl::encoding::Encoder<'_, D>,
1245            offset: usize,
1246            _depth: fidl::encoding::Depth,
1247        ) -> fidl::Result<()> {
1248            encoder.debug_check_bounds::<Self>(offset);
1249            encoder.write_num(self.into_primitive(), offset);
1250            Ok(())
1251        }
1252    }
1253
1254    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TraceProvider {
1255        #[inline(always)]
1256        fn new_empty() -> Self {
1257            Self::Namespace
1258        }
1259
1260        #[inline]
1261        unsafe fn decode(
1262            &mut self,
1263            decoder: &mut fidl::encoding::Decoder<'_, D>,
1264            offset: usize,
1265            _depth: fidl::encoding::Depth,
1266        ) -> fidl::Result<()> {
1267            decoder.debug_check_bounds::<Self>(offset);
1268            let prim = decoder.read_num::<u8>(offset);
1269
1270            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1271            Ok(())
1272        }
1273    }
1274    unsafe impl fidl::encoding::TypeMarker for VmexSource {
1275        type Owned = Self;
1276
1277        #[inline(always)]
1278        fn inline_align(_context: fidl::encoding::Context) -> usize {
1279            std::mem::align_of::<u8>()
1280        }
1281
1282        #[inline(always)]
1283        fn inline_size(_context: fidl::encoding::Context) -> usize {
1284            std::mem::size_of::<u8>()
1285        }
1286
1287        #[inline(always)]
1288        fn encode_is_copy() -> bool {
1289            true
1290        }
1291
1292        #[inline(always)]
1293        fn decode_is_copy() -> bool {
1294            false
1295        }
1296    }
1297
1298    impl fidl::encoding::ValueTypeMarker for VmexSource {
1299        type Borrowed<'a> = Self;
1300        #[inline(always)]
1301        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1302            *value
1303        }
1304    }
1305
1306    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for VmexSource {
1307        #[inline]
1308        unsafe fn encode(
1309            self,
1310            encoder: &mut fidl::encoding::Encoder<'_, D>,
1311            offset: usize,
1312            _depth: fidl::encoding::Depth,
1313        ) -> fidl::Result<()> {
1314            encoder.debug_check_bounds::<Self>(offset);
1315            encoder.write_num(self.into_primitive(), offset);
1316            Ok(())
1317        }
1318    }
1319
1320    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VmexSource {
1321        #[inline(always)]
1322        fn new_empty() -> Self {
1323            Self::SystemResource
1324        }
1325
1326        #[inline]
1327        unsafe fn decode(
1328            &mut self,
1329            decoder: &mut fidl::encoding::Decoder<'_, D>,
1330            offset: usize,
1331            _depth: fidl::encoding::Depth,
1332        ) -> fidl::Result<()> {
1333            decoder.debug_check_bounds::<Self>(offset);
1334            let prim = decoder.read_num::<u8>(offset);
1335
1336            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1337            Ok(())
1338        }
1339    }
1340
1341    impl AbiRevisionPolicy {
1342        #[inline(always)]
1343        fn max_ordinal_present(&self) -> u64 {
1344            if let Some(_) = self.allowlist {
1345                return 1;
1346            }
1347            0
1348        }
1349    }
1350
1351    impl fidl::encoding::ValueTypeMarker for AbiRevisionPolicy {
1352        type Borrowed<'a> = &'a Self;
1353        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1354            value
1355        }
1356    }
1357
1358    unsafe impl fidl::encoding::TypeMarker for AbiRevisionPolicy {
1359        type Owned = Self;
1360
1361        #[inline(always)]
1362        fn inline_align(_context: fidl::encoding::Context) -> usize {
1363            8
1364        }
1365
1366        #[inline(always)]
1367        fn inline_size(_context: fidl::encoding::Context) -> usize {
1368            16
1369        }
1370    }
1371
1372    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AbiRevisionPolicy, D>
1373        for &AbiRevisionPolicy
1374    {
1375        unsafe fn encode(
1376            self,
1377            encoder: &mut fidl::encoding::Encoder<'_, D>,
1378            offset: usize,
1379            mut depth: fidl::encoding::Depth,
1380        ) -> fidl::Result<()> {
1381            encoder.debug_check_bounds::<AbiRevisionPolicy>(offset);
1382            // Vector header
1383            let max_ordinal: u64 = self.max_ordinal_present();
1384            encoder.write_num(max_ordinal, offset);
1385            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1386            // Calling encoder.out_of_line_offset(0) is not allowed.
1387            if max_ordinal == 0 {
1388                return Ok(());
1389            }
1390            depth.increment()?;
1391            let envelope_size = 8;
1392            let bytes_len = max_ordinal as usize * envelope_size;
1393            #[allow(unused_variables)]
1394            let offset = encoder.out_of_line_offset(bytes_len);
1395            let mut _prev_end_offset: usize = 0;
1396            if 1 > max_ordinal {
1397                return Ok(());
1398            }
1399
1400            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1401            // are envelope_size bytes.
1402            let cur_offset: usize = (1 - 1) * envelope_size;
1403
1404            // Zero reserved fields.
1405            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1406
1407            // Safety:
1408            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1409            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1410            //   envelope_size bytes, there is always sufficient room.
1411            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
1412            self.allowlist.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
1413            encoder, offset + cur_offset, depth
1414        )?;
1415
1416            _prev_end_offset = cur_offset + envelope_size;
1417
1418            Ok(())
1419        }
1420    }
1421
1422    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AbiRevisionPolicy {
1423        #[inline(always)]
1424        fn new_empty() -> Self {
1425            Self::default()
1426        }
1427
1428        unsafe fn decode(
1429            &mut self,
1430            decoder: &mut fidl::encoding::Decoder<'_, D>,
1431            offset: usize,
1432            mut depth: fidl::encoding::Depth,
1433        ) -> fidl::Result<()> {
1434            decoder.debug_check_bounds::<Self>(offset);
1435            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1436                None => return Err(fidl::Error::NotNullable),
1437                Some(len) => len,
1438            };
1439            // Calling decoder.out_of_line_offset(0) is not allowed.
1440            if len == 0 {
1441                return Ok(());
1442            };
1443            depth.increment()?;
1444            let envelope_size = 8;
1445            let bytes_len = len * envelope_size;
1446            let offset = decoder.out_of_line_offset(bytes_len)?;
1447            // Decode the envelope for each type.
1448            let mut _next_ordinal_to_read = 0;
1449            let mut next_offset = offset;
1450            let end_offset = offset + bytes_len;
1451            _next_ordinal_to_read += 1;
1452            if next_offset >= end_offset {
1453                return Ok(());
1454            }
1455
1456            // Decode unknown envelopes for gaps in ordinals.
1457            while _next_ordinal_to_read < 1 {
1458                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1459                _next_ordinal_to_read += 1;
1460                next_offset += envelope_size;
1461            }
1462
1463            let next_out_of_line = decoder.next_out_of_line();
1464            let handles_before = decoder.remaining_handles();
1465            if let Some((inlined, num_bytes, num_handles)) =
1466                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1467            {
1468                let member_inline_size = <fidl::encoding::Vector<
1469                    fidl::encoding::BoundedString<4096>,
1470                    128,
1471                > as fidl::encoding::TypeMarker>::inline_size(
1472                    decoder.context
1473                );
1474                if inlined != (member_inline_size <= 4) {
1475                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1476                }
1477                let inner_offset;
1478                let mut inner_depth = depth.clone();
1479                if inlined {
1480                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1481                    inner_offset = next_offset;
1482                } else {
1483                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1484                    inner_depth.increment()?;
1485                }
1486                let val_ref = self.allowlist.get_or_insert_with(|| {
1487                    fidl::new_empty!(
1488                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
1489                        D
1490                    )
1491                });
1492                fidl::decode!(
1493                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
1494                    D,
1495                    val_ref,
1496                    decoder,
1497                    inner_offset,
1498                    inner_depth
1499                )?;
1500                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1501                {
1502                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1503                }
1504                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1505                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1506                }
1507            }
1508
1509            next_offset += envelope_size;
1510
1511            // Decode the remaining unknown envelopes.
1512            while next_offset < end_offset {
1513                _next_ordinal_to_read += 1;
1514                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1515                next_offset += envelope_size;
1516            }
1517
1518            Ok(())
1519        }
1520    }
1521
1522    impl AllowlistedDirectory {
1523        #[inline(always)]
1524        fn max_ordinal_present(&self) -> u64 {
1525            0
1526        }
1527    }
1528
1529    impl fidl::encoding::ValueTypeMarker for AllowlistedDirectory {
1530        type Borrowed<'a> = &'a Self;
1531        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1532            value
1533        }
1534    }
1535
1536    unsafe impl fidl::encoding::TypeMarker for AllowlistedDirectory {
1537        type Owned = Self;
1538
1539        #[inline(always)]
1540        fn inline_align(_context: fidl::encoding::Context) -> usize {
1541            8
1542        }
1543
1544        #[inline(always)]
1545        fn inline_size(_context: fidl::encoding::Context) -> usize {
1546            16
1547        }
1548    }
1549
1550    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedDirectory, D>
1551        for &AllowlistedDirectory
1552    {
1553        unsafe fn encode(
1554            self,
1555            encoder: &mut fidl::encoding::Encoder<'_, D>,
1556            offset: usize,
1557            mut depth: fidl::encoding::Depth,
1558        ) -> fidl::Result<()> {
1559            encoder.debug_check_bounds::<AllowlistedDirectory>(offset);
1560            // Vector header
1561            let max_ordinal: u64 = self.max_ordinal_present();
1562            encoder.write_num(max_ordinal, offset);
1563            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1564            // Calling encoder.out_of_line_offset(0) is not allowed.
1565            if max_ordinal == 0 {
1566                return Ok(());
1567            }
1568            depth.increment()?;
1569            let envelope_size = 8;
1570            let bytes_len = max_ordinal as usize * envelope_size;
1571            #[allow(unused_variables)]
1572            let offset = encoder.out_of_line_offset(bytes_len);
1573            let mut _prev_end_offset: usize = 0;
1574
1575            Ok(())
1576        }
1577    }
1578
1579    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedDirectory {
1580        #[inline(always)]
1581        fn new_empty() -> Self {
1582            Self::default()
1583        }
1584
1585        unsafe fn decode(
1586            &mut self,
1587            decoder: &mut fidl::encoding::Decoder<'_, D>,
1588            offset: usize,
1589            mut depth: fidl::encoding::Depth,
1590        ) -> fidl::Result<()> {
1591            decoder.debug_check_bounds::<Self>(offset);
1592            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1593                None => return Err(fidl::Error::NotNullable),
1594                Some(len) => len,
1595            };
1596            // Calling decoder.out_of_line_offset(0) is not allowed.
1597            if len == 0 {
1598                return Ok(());
1599            };
1600            depth.increment()?;
1601            let envelope_size = 8;
1602            let bytes_len = len * envelope_size;
1603            let offset = decoder.out_of_line_offset(bytes_len)?;
1604            // Decode the envelope for each type.
1605            let mut _next_ordinal_to_read = 0;
1606            let mut next_offset = offset;
1607            let end_offset = offset + bytes_len;
1608
1609            // Decode the remaining unknown envelopes.
1610            while next_offset < end_offset {
1611                _next_ordinal_to_read += 1;
1612                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1613                next_offset += envelope_size;
1614            }
1615
1616            Ok(())
1617        }
1618    }
1619
1620    impl AllowlistedProtocol {
1621        #[inline(always)]
1622        fn max_ordinal_present(&self) -> u64 {
1623            0
1624        }
1625    }
1626
1627    impl fidl::encoding::ValueTypeMarker for AllowlistedProtocol {
1628        type Borrowed<'a> = &'a Self;
1629        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1630            value
1631        }
1632    }
1633
1634    unsafe impl fidl::encoding::TypeMarker for AllowlistedProtocol {
1635        type Owned = Self;
1636
1637        #[inline(always)]
1638        fn inline_align(_context: fidl::encoding::Context) -> usize {
1639            8
1640        }
1641
1642        #[inline(always)]
1643        fn inline_size(_context: fidl::encoding::Context) -> usize {
1644            16
1645        }
1646    }
1647
1648    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedProtocol, D>
1649        for &AllowlistedProtocol
1650    {
1651        unsafe fn encode(
1652            self,
1653            encoder: &mut fidl::encoding::Encoder<'_, D>,
1654            offset: usize,
1655            mut depth: fidl::encoding::Depth,
1656        ) -> fidl::Result<()> {
1657            encoder.debug_check_bounds::<AllowlistedProtocol>(offset);
1658            // Vector header
1659            let max_ordinal: u64 = self.max_ordinal_present();
1660            encoder.write_num(max_ordinal, offset);
1661            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1662            // Calling encoder.out_of_line_offset(0) is not allowed.
1663            if max_ordinal == 0 {
1664                return Ok(());
1665            }
1666            depth.increment()?;
1667            let envelope_size = 8;
1668            let bytes_len = max_ordinal as usize * envelope_size;
1669            #[allow(unused_variables)]
1670            let offset = encoder.out_of_line_offset(bytes_len);
1671            let mut _prev_end_offset: usize = 0;
1672
1673            Ok(())
1674        }
1675    }
1676
1677    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedProtocol {
1678        #[inline(always)]
1679        fn new_empty() -> Self {
1680            Self::default()
1681        }
1682
1683        unsafe fn decode(
1684            &mut self,
1685            decoder: &mut fidl::encoding::Decoder<'_, D>,
1686            offset: usize,
1687            mut depth: fidl::encoding::Depth,
1688        ) -> fidl::Result<()> {
1689            decoder.debug_check_bounds::<Self>(offset);
1690            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1691                None => return Err(fidl::Error::NotNullable),
1692                Some(len) => len,
1693            };
1694            // Calling decoder.out_of_line_offset(0) is not allowed.
1695            if len == 0 {
1696                return Ok(());
1697            };
1698            depth.increment()?;
1699            let envelope_size = 8;
1700            let bytes_len = len * envelope_size;
1701            let offset = decoder.out_of_line_offset(bytes_len)?;
1702            // Decode the envelope for each type.
1703            let mut _next_ordinal_to_read = 0;
1704            let mut next_offset = offset;
1705            let end_offset = offset + bytes_len;
1706
1707            // Decode the remaining unknown envelopes.
1708            while next_offset < end_offset {
1709                _next_ordinal_to_read += 1;
1710                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1711                next_offset += envelope_size;
1712            }
1713
1714            Ok(())
1715        }
1716    }
1717
1718    impl AllowlistedResolver {
1719        #[inline(always)]
1720        fn max_ordinal_present(&self) -> u64 {
1721            0
1722        }
1723    }
1724
1725    impl fidl::encoding::ValueTypeMarker for AllowlistedResolver {
1726        type Borrowed<'a> = &'a Self;
1727        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1728            value
1729        }
1730    }
1731
1732    unsafe impl fidl::encoding::TypeMarker for AllowlistedResolver {
1733        type Owned = Self;
1734
1735        #[inline(always)]
1736        fn inline_align(_context: fidl::encoding::Context) -> usize {
1737            8
1738        }
1739
1740        #[inline(always)]
1741        fn inline_size(_context: fidl::encoding::Context) -> usize {
1742            16
1743        }
1744    }
1745
1746    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedResolver, D>
1747        for &AllowlistedResolver
1748    {
1749        unsafe fn encode(
1750            self,
1751            encoder: &mut fidl::encoding::Encoder<'_, D>,
1752            offset: usize,
1753            mut depth: fidl::encoding::Depth,
1754        ) -> fidl::Result<()> {
1755            encoder.debug_check_bounds::<AllowlistedResolver>(offset);
1756            // Vector header
1757            let max_ordinal: u64 = self.max_ordinal_present();
1758            encoder.write_num(max_ordinal, offset);
1759            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1760            // Calling encoder.out_of_line_offset(0) is not allowed.
1761            if max_ordinal == 0 {
1762                return Ok(());
1763            }
1764            depth.increment()?;
1765            let envelope_size = 8;
1766            let bytes_len = max_ordinal as usize * envelope_size;
1767            #[allow(unused_variables)]
1768            let offset = encoder.out_of_line_offset(bytes_len);
1769            let mut _prev_end_offset: usize = 0;
1770
1771            Ok(())
1772        }
1773    }
1774
1775    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedResolver {
1776        #[inline(always)]
1777        fn new_empty() -> Self {
1778            Self::default()
1779        }
1780
1781        unsafe fn decode(
1782            &mut self,
1783            decoder: &mut fidl::encoding::Decoder<'_, D>,
1784            offset: usize,
1785            mut depth: fidl::encoding::Depth,
1786        ) -> fidl::Result<()> {
1787            decoder.debug_check_bounds::<Self>(offset);
1788            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1789                None => return Err(fidl::Error::NotNullable),
1790                Some(len) => len,
1791            };
1792            // Calling decoder.out_of_line_offset(0) is not allowed.
1793            if len == 0 {
1794                return Ok(());
1795            };
1796            depth.increment()?;
1797            let envelope_size = 8;
1798            let bytes_len = len * envelope_size;
1799            let offset = decoder.out_of_line_offset(bytes_len)?;
1800            // Decode the envelope for each type.
1801            let mut _next_ordinal_to_read = 0;
1802            let mut next_offset = offset;
1803            let end_offset = offset + bytes_len;
1804
1805            // Decode the remaining unknown envelopes.
1806            while next_offset < end_offset {
1807                _next_ordinal_to_read += 1;
1808                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1809                next_offset += envelope_size;
1810            }
1811
1812            Ok(())
1813        }
1814    }
1815
1816    impl AllowlistedRunner {
1817        #[inline(always)]
1818        fn max_ordinal_present(&self) -> u64 {
1819            0
1820        }
1821    }
1822
1823    impl fidl::encoding::ValueTypeMarker for AllowlistedRunner {
1824        type Borrowed<'a> = &'a Self;
1825        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1826            value
1827        }
1828    }
1829
1830    unsafe impl fidl::encoding::TypeMarker for AllowlistedRunner {
1831        type Owned = Self;
1832
1833        #[inline(always)]
1834        fn inline_align(_context: fidl::encoding::Context) -> usize {
1835            8
1836        }
1837
1838        #[inline(always)]
1839        fn inline_size(_context: fidl::encoding::Context) -> usize {
1840            16
1841        }
1842    }
1843
1844    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedRunner, D>
1845        for &AllowlistedRunner
1846    {
1847        unsafe fn encode(
1848            self,
1849            encoder: &mut fidl::encoding::Encoder<'_, D>,
1850            offset: usize,
1851            mut depth: fidl::encoding::Depth,
1852        ) -> fidl::Result<()> {
1853            encoder.debug_check_bounds::<AllowlistedRunner>(offset);
1854            // Vector header
1855            let max_ordinal: u64 = self.max_ordinal_present();
1856            encoder.write_num(max_ordinal, offset);
1857            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1858            // Calling encoder.out_of_line_offset(0) is not allowed.
1859            if max_ordinal == 0 {
1860                return Ok(());
1861            }
1862            depth.increment()?;
1863            let envelope_size = 8;
1864            let bytes_len = max_ordinal as usize * envelope_size;
1865            #[allow(unused_variables)]
1866            let offset = encoder.out_of_line_offset(bytes_len);
1867            let mut _prev_end_offset: usize = 0;
1868
1869            Ok(())
1870        }
1871    }
1872
1873    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedRunner {
1874        #[inline(always)]
1875        fn new_empty() -> Self {
1876            Self::default()
1877        }
1878
1879        unsafe fn decode(
1880            &mut self,
1881            decoder: &mut fidl::encoding::Decoder<'_, D>,
1882            offset: usize,
1883            mut depth: fidl::encoding::Depth,
1884        ) -> fidl::Result<()> {
1885            decoder.debug_check_bounds::<Self>(offset);
1886            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1887                None => return Err(fidl::Error::NotNullable),
1888                Some(len) => len,
1889            };
1890            // Calling decoder.out_of_line_offset(0) is not allowed.
1891            if len == 0 {
1892                return Ok(());
1893            };
1894            depth.increment()?;
1895            let envelope_size = 8;
1896            let bytes_len = len * envelope_size;
1897            let offset = decoder.out_of_line_offset(bytes_len)?;
1898            // Decode the envelope for each type.
1899            let mut _next_ordinal_to_read = 0;
1900            let mut next_offset = offset;
1901            let end_offset = offset + bytes_len;
1902
1903            // Decode the remaining unknown envelopes.
1904            while next_offset < end_offset {
1905                _next_ordinal_to_read += 1;
1906                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1907                next_offset += envelope_size;
1908            }
1909
1910            Ok(())
1911        }
1912    }
1913
1914    impl AllowlistedService {
1915        #[inline(always)]
1916        fn max_ordinal_present(&self) -> u64 {
1917            0
1918        }
1919    }
1920
1921    impl fidl::encoding::ValueTypeMarker for AllowlistedService {
1922        type Borrowed<'a> = &'a Self;
1923        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1924            value
1925        }
1926    }
1927
1928    unsafe impl fidl::encoding::TypeMarker for AllowlistedService {
1929        type Owned = Self;
1930
1931        #[inline(always)]
1932        fn inline_align(_context: fidl::encoding::Context) -> usize {
1933            8
1934        }
1935
1936        #[inline(always)]
1937        fn inline_size(_context: fidl::encoding::Context) -> usize {
1938            16
1939        }
1940    }
1941
1942    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedService, D>
1943        for &AllowlistedService
1944    {
1945        unsafe fn encode(
1946            self,
1947            encoder: &mut fidl::encoding::Encoder<'_, D>,
1948            offset: usize,
1949            mut depth: fidl::encoding::Depth,
1950        ) -> fidl::Result<()> {
1951            encoder.debug_check_bounds::<AllowlistedService>(offset);
1952            // Vector header
1953            let max_ordinal: u64 = self.max_ordinal_present();
1954            encoder.write_num(max_ordinal, offset);
1955            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1956            // Calling encoder.out_of_line_offset(0) is not allowed.
1957            if max_ordinal == 0 {
1958                return Ok(());
1959            }
1960            depth.increment()?;
1961            let envelope_size = 8;
1962            let bytes_len = max_ordinal as usize * envelope_size;
1963            #[allow(unused_variables)]
1964            let offset = encoder.out_of_line_offset(bytes_len);
1965            let mut _prev_end_offset: usize = 0;
1966
1967            Ok(())
1968        }
1969    }
1970
1971    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedService {
1972        #[inline(always)]
1973        fn new_empty() -> Self {
1974            Self::default()
1975        }
1976
1977        unsafe fn decode(
1978            &mut self,
1979            decoder: &mut fidl::encoding::Decoder<'_, D>,
1980            offset: usize,
1981            mut depth: fidl::encoding::Depth,
1982        ) -> fidl::Result<()> {
1983            decoder.debug_check_bounds::<Self>(offset);
1984            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1985                None => return Err(fidl::Error::NotNullable),
1986                Some(len) => len,
1987            };
1988            // Calling decoder.out_of_line_offset(0) is not allowed.
1989            if len == 0 {
1990                return Ok(());
1991            };
1992            depth.increment()?;
1993            let envelope_size = 8;
1994            let bytes_len = len * envelope_size;
1995            let offset = decoder.out_of_line_offset(bytes_len)?;
1996            // Decode the envelope for each type.
1997            let mut _next_ordinal_to_read = 0;
1998            let mut next_offset = offset;
1999            let end_offset = offset + bytes_len;
2000
2001            // Decode the remaining unknown envelopes.
2002            while next_offset < end_offset {
2003                _next_ordinal_to_read += 1;
2004                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2005                next_offset += envelope_size;
2006            }
2007
2008            Ok(())
2009        }
2010    }
2011
2012    impl AllowlistedStorage {
2013        #[inline(always)]
2014        fn max_ordinal_present(&self) -> u64 {
2015            0
2016        }
2017    }
2018
2019    impl fidl::encoding::ValueTypeMarker for AllowlistedStorage {
2020        type Borrowed<'a> = &'a Self;
2021        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2022            value
2023        }
2024    }
2025
2026    unsafe impl fidl::encoding::TypeMarker for AllowlistedStorage {
2027        type Owned = Self;
2028
2029        #[inline(always)]
2030        fn inline_align(_context: fidl::encoding::Context) -> usize {
2031            8
2032        }
2033
2034        #[inline(always)]
2035        fn inline_size(_context: fidl::encoding::Context) -> usize {
2036            16
2037        }
2038    }
2039
2040    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedStorage, D>
2041        for &AllowlistedStorage
2042    {
2043        unsafe fn encode(
2044            self,
2045            encoder: &mut fidl::encoding::Encoder<'_, D>,
2046            offset: usize,
2047            mut depth: fidl::encoding::Depth,
2048        ) -> fidl::Result<()> {
2049            encoder.debug_check_bounds::<AllowlistedStorage>(offset);
2050            // Vector header
2051            let max_ordinal: u64 = self.max_ordinal_present();
2052            encoder.write_num(max_ordinal, offset);
2053            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2054            // Calling encoder.out_of_line_offset(0) is not allowed.
2055            if max_ordinal == 0 {
2056                return Ok(());
2057            }
2058            depth.increment()?;
2059            let envelope_size = 8;
2060            let bytes_len = max_ordinal as usize * envelope_size;
2061            #[allow(unused_variables)]
2062            let offset = encoder.out_of_line_offset(bytes_len);
2063            let mut _prev_end_offset: usize = 0;
2064
2065            Ok(())
2066        }
2067    }
2068
2069    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedStorage {
2070        #[inline(always)]
2071        fn new_empty() -> Self {
2072            Self::default()
2073        }
2074
2075        unsafe fn decode(
2076            &mut self,
2077            decoder: &mut fidl::encoding::Decoder<'_, D>,
2078            offset: usize,
2079            mut depth: fidl::encoding::Depth,
2080        ) -> fidl::Result<()> {
2081            decoder.debug_check_bounds::<Self>(offset);
2082            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2083                None => return Err(fidl::Error::NotNullable),
2084                Some(len) => len,
2085            };
2086            // Calling decoder.out_of_line_offset(0) is not allowed.
2087            if len == 0 {
2088                return Ok(());
2089            };
2090            depth.increment()?;
2091            let envelope_size = 8;
2092            let bytes_len = len * envelope_size;
2093            let offset = decoder.out_of_line_offset(bytes_len)?;
2094            // Decode the envelope for each type.
2095            let mut _next_ordinal_to_read = 0;
2096            let mut next_offset = offset;
2097            let end_offset = offset + bytes_len;
2098
2099            // Decode the remaining unknown envelopes.
2100            while next_offset < end_offset {
2101                _next_ordinal_to_read += 1;
2102                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2103                next_offset += envelope_size;
2104            }
2105
2106            Ok(())
2107        }
2108    }
2109
2110    impl AnonymizedAggregate {
2111        #[inline(always)]
2112        fn max_ordinal_present(&self) -> u64 {
2113            if let Some(_) = self.instances {
2114                return 5;
2115            }
2116            if let Some(_) = self.sources {
2117                return 4;
2118            }
2119            if let Some(_) = self.members {
2120                return 3;
2121            }
2122            if let Some(_) = self.moniker {
2123                return 2;
2124            }
2125            if let Some(_) = self.capability {
2126                return 1;
2127            }
2128            0
2129        }
2130    }
2131
2132    impl fidl::encoding::ValueTypeMarker for AnonymizedAggregate {
2133        type Borrowed<'a> = &'a Self;
2134        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2135            value
2136        }
2137    }
2138
2139    unsafe impl fidl::encoding::TypeMarker for AnonymizedAggregate {
2140        type Owned = Self;
2141
2142        #[inline(always)]
2143        fn inline_align(_context: fidl::encoding::Context) -> usize {
2144            8
2145        }
2146
2147        #[inline(always)]
2148        fn inline_size(_context: fidl::encoding::Context) -> usize {
2149            16
2150        }
2151    }
2152
2153    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AnonymizedAggregate, D>
2154        for &AnonymizedAggregate
2155    {
2156        unsafe fn encode(
2157            self,
2158            encoder: &mut fidl::encoding::Encoder<'_, D>,
2159            offset: usize,
2160            mut depth: fidl::encoding::Depth,
2161        ) -> fidl::Result<()> {
2162            encoder.debug_check_bounds::<AnonymizedAggregate>(offset);
2163            // Vector header
2164            let max_ordinal: u64 = self.max_ordinal_present();
2165            encoder.write_num(max_ordinal, offset);
2166            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2167            // Calling encoder.out_of_line_offset(0) is not allowed.
2168            if max_ordinal == 0 {
2169                return Ok(());
2170            }
2171            depth.increment()?;
2172            let envelope_size = 8;
2173            let bytes_len = max_ordinal as usize * envelope_size;
2174            #[allow(unused_variables)]
2175            let offset = encoder.out_of_line_offset(bytes_len);
2176            let mut _prev_end_offset: usize = 0;
2177            if 1 > max_ordinal {
2178                return Ok(());
2179            }
2180
2181            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2182            // are envelope_size bytes.
2183            let cur_offset: usize = (1 - 1) * envelope_size;
2184
2185            // Zero reserved fields.
2186            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2187
2188            // Safety:
2189            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2190            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2191            //   envelope_size bytes, there is always sufficient room.
2192            fidl::encoding::encode_in_envelope_optional::<AggregateCapability, D>(
2193                self.capability
2194                    .as_ref()
2195                    .map(<AggregateCapability as fidl::encoding::ValueTypeMarker>::borrow),
2196                encoder,
2197                offset + cur_offset,
2198                depth,
2199            )?;
2200
2201            _prev_end_offset = cur_offset + envelope_size;
2202            if 2 > max_ordinal {
2203                return Ok(());
2204            }
2205
2206            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2207            // are envelope_size bytes.
2208            let cur_offset: usize = (2 - 1) * envelope_size;
2209
2210            // Zero reserved fields.
2211            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2212
2213            // Safety:
2214            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2215            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2216            //   envelope_size bytes, there is always sufficient room.
2217            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
2218            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
2219            encoder, offset + cur_offset, depth
2220        )?;
2221
2222            _prev_end_offset = cur_offset + envelope_size;
2223            if 3 > max_ordinal {
2224                return Ok(());
2225            }
2226
2227            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2228            // are envelope_size bytes.
2229            let cur_offset: usize = (3 - 1) * envelope_size;
2230
2231            // Zero reserved fields.
2232            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2233
2234            // Safety:
2235            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2236            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2237            //   envelope_size bytes, there is always sufficient room.
2238            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<AggregateMember>, D>(
2239            self.members.as_ref().map(<fidl::encoding::UnboundedVector<AggregateMember> as fidl::encoding::ValueTypeMarker>::borrow),
2240            encoder, offset + cur_offset, depth
2241        )?;
2242
2243            _prev_end_offset = cur_offset + envelope_size;
2244            if 4 > max_ordinal {
2245                return Ok(());
2246            }
2247
2248            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2249            // are envelope_size bytes.
2250            let cur_offset: usize = (4 - 1) * envelope_size;
2251
2252            // Zero reserved fields.
2253            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2254
2255            // Safety:
2256            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2257            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2258            //   envelope_size bytes, there is always sufficient room.
2259            fidl::encoding::encode_in_envelope_optional::<Sources, D>(
2260                self.sources.as_ref().map(<Sources as fidl::encoding::ValueTypeMarker>::borrow),
2261                encoder,
2262                offset + cur_offset,
2263                depth,
2264            )?;
2265
2266            _prev_end_offset = cur_offset + envelope_size;
2267            if 5 > max_ordinal {
2268                return Ok(());
2269            }
2270
2271            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2272            // are envelope_size bytes.
2273            let cur_offset: usize = (5 - 1) * envelope_size;
2274
2275            // Zero reserved fields.
2276            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2277
2278            // Safety:
2279            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2280            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2281            //   envelope_size bytes, there is always sufficient room.
2282            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance>, D>(
2283            self.instances.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance> as fidl::encoding::ValueTypeMarker>::borrow),
2284            encoder, offset + cur_offset, depth
2285        )?;
2286
2287            _prev_end_offset = cur_offset + envelope_size;
2288
2289            Ok(())
2290        }
2291    }
2292
2293    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AnonymizedAggregate {
2294        #[inline(always)]
2295        fn new_empty() -> Self {
2296            Self::default()
2297        }
2298
2299        unsafe fn decode(
2300            &mut self,
2301            decoder: &mut fidl::encoding::Decoder<'_, D>,
2302            offset: usize,
2303            mut depth: fidl::encoding::Depth,
2304        ) -> fidl::Result<()> {
2305            decoder.debug_check_bounds::<Self>(offset);
2306            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2307                None => return Err(fidl::Error::NotNullable),
2308                Some(len) => len,
2309            };
2310            // Calling decoder.out_of_line_offset(0) is not allowed.
2311            if len == 0 {
2312                return Ok(());
2313            };
2314            depth.increment()?;
2315            let envelope_size = 8;
2316            let bytes_len = len * envelope_size;
2317            let offset = decoder.out_of_line_offset(bytes_len)?;
2318            // Decode the envelope for each type.
2319            let mut _next_ordinal_to_read = 0;
2320            let mut next_offset = offset;
2321            let end_offset = offset + bytes_len;
2322            _next_ordinal_to_read += 1;
2323            if next_offset >= end_offset {
2324                return Ok(());
2325            }
2326
2327            // Decode unknown envelopes for gaps in ordinals.
2328            while _next_ordinal_to_read < 1 {
2329                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2330                _next_ordinal_to_read += 1;
2331                next_offset += envelope_size;
2332            }
2333
2334            let next_out_of_line = decoder.next_out_of_line();
2335            let handles_before = decoder.remaining_handles();
2336            if let Some((inlined, num_bytes, num_handles)) =
2337                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2338            {
2339                let member_inline_size =
2340                    <AggregateCapability as fidl::encoding::TypeMarker>::inline_size(
2341                        decoder.context,
2342                    );
2343                if inlined != (member_inline_size <= 4) {
2344                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2345                }
2346                let inner_offset;
2347                let mut inner_depth = depth.clone();
2348                if inlined {
2349                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2350                    inner_offset = next_offset;
2351                } else {
2352                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2353                    inner_depth.increment()?;
2354                }
2355                let val_ref =
2356                    self.capability.get_or_insert_with(|| fidl::new_empty!(AggregateCapability, D));
2357                fidl::decode!(AggregateCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
2358                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2359                {
2360                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2361                }
2362                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2363                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2364                }
2365            }
2366
2367            next_offset += envelope_size;
2368            _next_ordinal_to_read += 1;
2369            if next_offset >= end_offset {
2370                return Ok(());
2371            }
2372
2373            // Decode unknown envelopes for gaps in ordinals.
2374            while _next_ordinal_to_read < 2 {
2375                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2376                _next_ordinal_to_read += 1;
2377                next_offset += envelope_size;
2378            }
2379
2380            let next_out_of_line = decoder.next_out_of_line();
2381            let handles_before = decoder.remaining_handles();
2382            if let Some((inlined, num_bytes, num_handles)) =
2383                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2384            {
2385                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2386                if inlined != (member_inline_size <= 4) {
2387                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2388                }
2389                let inner_offset;
2390                let mut inner_depth = depth.clone();
2391                if inlined {
2392                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2393                    inner_offset = next_offset;
2394                } else {
2395                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2396                    inner_depth.increment()?;
2397                }
2398                let val_ref = self.moniker.get_or_insert_with(|| {
2399                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
2400                });
2401                fidl::decode!(
2402                    fidl::encoding::BoundedString<4096>,
2403                    D,
2404                    val_ref,
2405                    decoder,
2406                    inner_offset,
2407                    inner_depth
2408                )?;
2409                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2410                {
2411                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2412                }
2413                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2414                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2415                }
2416            }
2417
2418            next_offset += envelope_size;
2419            _next_ordinal_to_read += 1;
2420            if next_offset >= end_offset {
2421                return Ok(());
2422            }
2423
2424            // Decode unknown envelopes for gaps in ordinals.
2425            while _next_ordinal_to_read < 3 {
2426                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2427                _next_ordinal_to_read += 1;
2428                next_offset += envelope_size;
2429            }
2430
2431            let next_out_of_line = decoder.next_out_of_line();
2432            let handles_before = decoder.remaining_handles();
2433            if let Some((inlined, num_bytes, num_handles)) =
2434                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2435            {
2436                let member_inline_size = <fidl::encoding::UnboundedVector<AggregateMember> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2437                if inlined != (member_inline_size <= 4) {
2438                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2439                }
2440                let inner_offset;
2441                let mut inner_depth = depth.clone();
2442                if inlined {
2443                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2444                    inner_offset = next_offset;
2445                } else {
2446                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2447                    inner_depth.increment()?;
2448                }
2449                let val_ref = self.members.get_or_insert_with(|| {
2450                    fidl::new_empty!(fidl::encoding::UnboundedVector<AggregateMember>, D)
2451                });
2452                fidl::decode!(
2453                    fidl::encoding::UnboundedVector<AggregateMember>,
2454                    D,
2455                    val_ref,
2456                    decoder,
2457                    inner_offset,
2458                    inner_depth
2459                )?;
2460                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2461                {
2462                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2463                }
2464                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2465                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2466                }
2467            }
2468
2469            next_offset += envelope_size;
2470            _next_ordinal_to_read += 1;
2471            if next_offset >= end_offset {
2472                return Ok(());
2473            }
2474
2475            // Decode unknown envelopes for gaps in ordinals.
2476            while _next_ordinal_to_read < 4 {
2477                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2478                _next_ordinal_to_read += 1;
2479                next_offset += envelope_size;
2480            }
2481
2482            let next_out_of_line = decoder.next_out_of_line();
2483            let handles_before = decoder.remaining_handles();
2484            if let Some((inlined, num_bytes, num_handles)) =
2485                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2486            {
2487                let member_inline_size =
2488                    <Sources as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2489                if inlined != (member_inline_size <= 4) {
2490                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2491                }
2492                let inner_offset;
2493                let mut inner_depth = depth.clone();
2494                if inlined {
2495                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2496                    inner_offset = next_offset;
2497                } else {
2498                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2499                    inner_depth.increment()?;
2500                }
2501                let val_ref = self.sources.get_or_insert_with(|| fidl::new_empty!(Sources, D));
2502                fidl::decode!(Sources, D, val_ref, decoder, inner_offset, inner_depth)?;
2503                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2504                {
2505                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2506                }
2507                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2508                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2509                }
2510            }
2511
2512            next_offset += envelope_size;
2513            _next_ordinal_to_read += 1;
2514            if next_offset >= end_offset {
2515                return Ok(());
2516            }
2517
2518            // Decode unknown envelopes for gaps in ordinals.
2519            while _next_ordinal_to_read < 5 {
2520                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2521                _next_ordinal_to_read += 1;
2522                next_offset += envelope_size;
2523            }
2524
2525            let next_out_of_line = decoder.next_out_of_line();
2526            let handles_before = decoder.remaining_handles();
2527            if let Some((inlined, num_bytes, num_handles)) =
2528                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2529            {
2530                let member_inline_size = <fidl::encoding::UnboundedVector<
2531                    fidl_fuchsia_sys2__common::ServiceInstance,
2532                > as fidl::encoding::TypeMarker>::inline_size(
2533                    decoder.context
2534                );
2535                if inlined != (member_inline_size <= 4) {
2536                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2537                }
2538                let inner_offset;
2539                let mut inner_depth = depth.clone();
2540                if inlined {
2541                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2542                    inner_offset = next_offset;
2543                } else {
2544                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2545                    inner_depth.increment()?;
2546                }
2547                let val_ref = self.instances.get_or_insert_with(|| {
2548                    fidl::new_empty!(
2549                        fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance>,
2550                        D
2551                    )
2552                });
2553                fidl::decode!(
2554                    fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance>,
2555                    D,
2556                    val_ref,
2557                    decoder,
2558                    inner_offset,
2559                    inner_depth
2560                )?;
2561                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2562                {
2563                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2564                }
2565                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2566                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2567                }
2568            }
2569
2570            next_offset += envelope_size;
2571
2572            // Decode the remaining unknown envelopes.
2573            while next_offset < end_offset {
2574                _next_ordinal_to_read += 1;
2575                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2576                next_offset += envelope_size;
2577            }
2578
2579            Ok(())
2580        }
2581    }
2582
2583    impl Builtin {
2584        #[inline(always)]
2585        fn max_ordinal_present(&self) -> u64 {
2586            if let Some(_) = self.capability {
2587                return 1;
2588            }
2589            0
2590        }
2591    }
2592
2593    impl fidl::encoding::ValueTypeMarker for Builtin {
2594        type Borrowed<'a> = &'a Self;
2595        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2596            value
2597        }
2598    }
2599
2600    unsafe impl fidl::encoding::TypeMarker for Builtin {
2601        type Owned = Self;
2602
2603        #[inline(always)]
2604        fn inline_align(_context: fidl::encoding::Context) -> usize {
2605            8
2606        }
2607
2608        #[inline(always)]
2609        fn inline_size(_context: fidl::encoding::Context) -> usize {
2610            16
2611        }
2612    }
2613
2614    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Builtin, D> for &Builtin {
2615        unsafe fn encode(
2616            self,
2617            encoder: &mut fidl::encoding::Encoder<'_, D>,
2618            offset: usize,
2619            mut depth: fidl::encoding::Depth,
2620        ) -> fidl::Result<()> {
2621            encoder.debug_check_bounds::<Builtin>(offset);
2622            // Vector header
2623            let max_ordinal: u64 = self.max_ordinal_present();
2624            encoder.write_num(max_ordinal, offset);
2625            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2626            // Calling encoder.out_of_line_offset(0) is not allowed.
2627            if max_ordinal == 0 {
2628                return Ok(());
2629            }
2630            depth.increment()?;
2631            let envelope_size = 8;
2632            let bytes_len = max_ordinal as usize * envelope_size;
2633            #[allow(unused_variables)]
2634            let offset = encoder.out_of_line_offset(bytes_len);
2635            let mut _prev_end_offset: usize = 0;
2636            if 1 > max_ordinal {
2637                return Ok(());
2638            }
2639
2640            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2641            // are envelope_size bytes.
2642            let cur_offset: usize = (1 - 1) * envelope_size;
2643
2644            // Zero reserved fields.
2645            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2646
2647            // Safety:
2648            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2649            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2650            //   envelope_size bytes, there is always sufficient room.
2651            fidl::encoding::encode_in_envelope_optional::<InternalCapability, D>(
2652                self.capability
2653                    .as_ref()
2654                    .map(<InternalCapability as fidl::encoding::ValueTypeMarker>::borrow),
2655                encoder,
2656                offset + cur_offset,
2657                depth,
2658            )?;
2659
2660            _prev_end_offset = cur_offset + envelope_size;
2661
2662            Ok(())
2663        }
2664    }
2665
2666    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Builtin {
2667        #[inline(always)]
2668        fn new_empty() -> Self {
2669            Self::default()
2670        }
2671
2672        unsafe fn decode(
2673            &mut self,
2674            decoder: &mut fidl::encoding::Decoder<'_, D>,
2675            offset: usize,
2676            mut depth: fidl::encoding::Depth,
2677        ) -> fidl::Result<()> {
2678            decoder.debug_check_bounds::<Self>(offset);
2679            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2680                None => return Err(fidl::Error::NotNullable),
2681                Some(len) => len,
2682            };
2683            // Calling decoder.out_of_line_offset(0) is not allowed.
2684            if len == 0 {
2685                return Ok(());
2686            };
2687            depth.increment()?;
2688            let envelope_size = 8;
2689            let bytes_len = len * envelope_size;
2690            let offset = decoder.out_of_line_offset(bytes_len)?;
2691            // Decode the envelope for each type.
2692            let mut _next_ordinal_to_read = 0;
2693            let mut next_offset = offset;
2694            let end_offset = offset + bytes_len;
2695            _next_ordinal_to_read += 1;
2696            if next_offset >= end_offset {
2697                return Ok(());
2698            }
2699
2700            // Decode unknown envelopes for gaps in ordinals.
2701            while _next_ordinal_to_read < 1 {
2702                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2703                _next_ordinal_to_read += 1;
2704                next_offset += envelope_size;
2705            }
2706
2707            let next_out_of_line = decoder.next_out_of_line();
2708            let handles_before = decoder.remaining_handles();
2709            if let Some((inlined, num_bytes, num_handles)) =
2710                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2711            {
2712                let member_inline_size =
2713                    <InternalCapability as fidl::encoding::TypeMarker>::inline_size(
2714                        decoder.context,
2715                    );
2716                if inlined != (member_inline_size <= 4) {
2717                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2718                }
2719                let inner_offset;
2720                let mut inner_depth = depth.clone();
2721                if inlined {
2722                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2723                    inner_offset = next_offset;
2724                } else {
2725                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2726                    inner_depth.increment()?;
2727                }
2728                let val_ref =
2729                    self.capability.get_or_insert_with(|| fidl::new_empty!(InternalCapability, D));
2730                fidl::decode!(InternalCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
2731                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2732                {
2733                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2734                }
2735                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2736                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2737                }
2738            }
2739
2740            next_offset += envelope_size;
2741
2742            // Decode the remaining unknown envelopes.
2743            while next_offset < end_offset {
2744                _next_ordinal_to_read += 1;
2745                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2746                next_offset += envelope_size;
2747            }
2748
2749            Ok(())
2750        }
2751    }
2752
2753    impl Capability {
2754        #[inline(always)]
2755        fn max_ordinal_present(&self) -> u64 {
2756            if let Some(_) = self.moniker {
2757                return 2;
2758            }
2759            if let Some(_) = self.source_capability {
2760                return 1;
2761            }
2762            0
2763        }
2764    }
2765
2766    impl fidl::encoding::ValueTypeMarker for Capability {
2767        type Borrowed<'a> = &'a Self;
2768        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2769            value
2770        }
2771    }
2772
2773    unsafe impl fidl::encoding::TypeMarker for Capability {
2774        type Owned = Self;
2775
2776        #[inline(always)]
2777        fn inline_align(_context: fidl::encoding::Context) -> usize {
2778            8
2779        }
2780
2781        #[inline(always)]
2782        fn inline_size(_context: fidl::encoding::Context) -> usize {
2783            16
2784        }
2785    }
2786
2787    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Capability, D>
2788        for &Capability
2789    {
2790        unsafe fn encode(
2791            self,
2792            encoder: &mut fidl::encoding::Encoder<'_, D>,
2793            offset: usize,
2794            mut depth: fidl::encoding::Depth,
2795        ) -> fidl::Result<()> {
2796            encoder.debug_check_bounds::<Capability>(offset);
2797            // Vector header
2798            let max_ordinal: u64 = self.max_ordinal_present();
2799            encoder.write_num(max_ordinal, offset);
2800            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2801            // Calling encoder.out_of_line_offset(0) is not allowed.
2802            if max_ordinal == 0 {
2803                return Ok(());
2804            }
2805            depth.increment()?;
2806            let envelope_size = 8;
2807            let bytes_len = max_ordinal as usize * envelope_size;
2808            #[allow(unused_variables)]
2809            let offset = encoder.out_of_line_offset(bytes_len);
2810            let mut _prev_end_offset: usize = 0;
2811            if 1 > max_ordinal {
2812                return Ok(());
2813            }
2814
2815            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2816            // are envelope_size bytes.
2817            let cur_offset: usize = (1 - 1) * envelope_size;
2818
2819            // Zero reserved fields.
2820            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2821
2822            // Safety:
2823            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2824            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2825            //   envelope_size bytes, there is always sufficient room.
2826            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
2827                self.source_capability
2828                    .as_ref()
2829                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
2830                encoder,
2831                offset + cur_offset,
2832                depth,
2833            )?;
2834
2835            _prev_end_offset = cur_offset + envelope_size;
2836            if 2 > max_ordinal {
2837                return Ok(());
2838            }
2839
2840            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2841            // are envelope_size bytes.
2842            let cur_offset: usize = (2 - 1) * envelope_size;
2843
2844            // Zero reserved fields.
2845            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2846
2847            // Safety:
2848            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2849            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2850            //   envelope_size bytes, there is always sufficient room.
2851            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
2852            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
2853            encoder, offset + cur_offset, depth
2854        )?;
2855
2856            _prev_end_offset = cur_offset + envelope_size;
2857
2858            Ok(())
2859        }
2860    }
2861
2862    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Capability {
2863        #[inline(always)]
2864        fn new_empty() -> Self {
2865            Self::default()
2866        }
2867
2868        unsafe fn decode(
2869            &mut self,
2870            decoder: &mut fidl::encoding::Decoder<'_, D>,
2871            offset: usize,
2872            mut depth: fidl::encoding::Depth,
2873        ) -> fidl::Result<()> {
2874            decoder.debug_check_bounds::<Self>(offset);
2875            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2876                None => return Err(fidl::Error::NotNullable),
2877                Some(len) => len,
2878            };
2879            // Calling decoder.out_of_line_offset(0) is not allowed.
2880            if len == 0 {
2881                return Ok(());
2882            };
2883            depth.increment()?;
2884            let envelope_size = 8;
2885            let bytes_len = len * envelope_size;
2886            let offset = decoder.out_of_line_offset(bytes_len)?;
2887            // Decode the envelope for each type.
2888            let mut _next_ordinal_to_read = 0;
2889            let mut next_offset = offset;
2890            let end_offset = offset + bytes_len;
2891            _next_ordinal_to_read += 1;
2892            if next_offset >= end_offset {
2893                return Ok(());
2894            }
2895
2896            // Decode unknown envelopes for gaps in ordinals.
2897            while _next_ordinal_to_read < 1 {
2898                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2899                _next_ordinal_to_read += 1;
2900                next_offset += envelope_size;
2901            }
2902
2903            let next_out_of_line = decoder.next_out_of_line();
2904            let handles_before = decoder.remaining_handles();
2905            if let Some((inlined, num_bytes, num_handles)) =
2906                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2907            {
2908                let member_inline_size =
2909                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
2910                        decoder.context,
2911                    );
2912                if inlined != (member_inline_size <= 4) {
2913                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2914                }
2915                let inner_offset;
2916                let mut inner_depth = depth.clone();
2917                if inlined {
2918                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2919                    inner_offset = next_offset;
2920                } else {
2921                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2922                    inner_depth.increment()?;
2923                }
2924                let val_ref = self
2925                    .source_capability
2926                    .get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
2927                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
2928                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2929                {
2930                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2931                }
2932                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2933                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2934                }
2935            }
2936
2937            next_offset += envelope_size;
2938            _next_ordinal_to_read += 1;
2939            if next_offset >= end_offset {
2940                return Ok(());
2941            }
2942
2943            // Decode unknown envelopes for gaps in ordinals.
2944            while _next_ordinal_to_read < 2 {
2945                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2946                _next_ordinal_to_read += 1;
2947                next_offset += envelope_size;
2948            }
2949
2950            let next_out_of_line = decoder.next_out_of_line();
2951            let handles_before = decoder.remaining_handles();
2952            if let Some((inlined, num_bytes, num_handles)) =
2953                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2954            {
2955                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2956                if inlined != (member_inline_size <= 4) {
2957                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2958                }
2959                let inner_offset;
2960                let mut inner_depth = depth.clone();
2961                if inlined {
2962                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2963                    inner_offset = next_offset;
2964                } else {
2965                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2966                    inner_depth.increment()?;
2967                }
2968                let val_ref = self.moniker.get_or_insert_with(|| {
2969                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
2970                });
2971                fidl::decode!(
2972                    fidl::encoding::BoundedString<4096>,
2973                    D,
2974                    val_ref,
2975                    decoder,
2976                    inner_offset,
2977                    inner_depth
2978                )?;
2979                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2980                {
2981                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2982                }
2983                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2984                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2985                }
2986            }
2987
2988            next_offset += envelope_size;
2989
2990            // Decode the remaining unknown envelopes.
2991            while next_offset < end_offset {
2992                _next_ordinal_to_read += 1;
2993                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2994                next_offset += envelope_size;
2995            }
2996
2997            Ok(())
2998        }
2999    }
3000
3001    impl CapabilityAllowlistEntry {
3002        #[inline(always)]
3003        fn max_ordinal_present(&self) -> u64 {
3004            if let Some(_) = self.source {
3005                return 5;
3006            }
3007            if let Some(_) = self.target_monikers {
3008                return 4;
3009            }
3010            if let Some(_) = self.capability {
3011                return 3;
3012            }
3013            if let Some(_) = self.source_name {
3014                return 2;
3015            }
3016            if let Some(_) = self.source_moniker {
3017                return 1;
3018            }
3019            0
3020        }
3021    }
3022
3023    impl fidl::encoding::ValueTypeMarker for CapabilityAllowlistEntry {
3024        type Borrowed<'a> = &'a Self;
3025        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3026            value
3027        }
3028    }
3029
3030    unsafe impl fidl::encoding::TypeMarker for CapabilityAllowlistEntry {
3031        type Owned = Self;
3032
3033        #[inline(always)]
3034        fn inline_align(_context: fidl::encoding::Context) -> usize {
3035            8
3036        }
3037
3038        #[inline(always)]
3039        fn inline_size(_context: fidl::encoding::Context) -> usize {
3040            16
3041        }
3042    }
3043
3044    unsafe impl<D: fidl::encoding::ResourceDialect>
3045        fidl::encoding::Encode<CapabilityAllowlistEntry, D> for &CapabilityAllowlistEntry
3046    {
3047        unsafe fn encode(
3048            self,
3049            encoder: &mut fidl::encoding::Encoder<'_, D>,
3050            offset: usize,
3051            mut depth: fidl::encoding::Depth,
3052        ) -> fidl::Result<()> {
3053            encoder.debug_check_bounds::<CapabilityAllowlistEntry>(offset);
3054            // Vector header
3055            let max_ordinal: u64 = self.max_ordinal_present();
3056            encoder.write_num(max_ordinal, offset);
3057            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3058            // Calling encoder.out_of_line_offset(0) is not allowed.
3059            if max_ordinal == 0 {
3060                return Ok(());
3061            }
3062            depth.increment()?;
3063            let envelope_size = 8;
3064            let bytes_len = max_ordinal as usize * envelope_size;
3065            #[allow(unused_variables)]
3066            let offset = encoder.out_of_line_offset(bytes_len);
3067            let mut _prev_end_offset: usize = 0;
3068            if 1 > max_ordinal {
3069                return Ok(());
3070            }
3071
3072            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3073            // are envelope_size bytes.
3074            let cur_offset: usize = (1 - 1) * envelope_size;
3075
3076            // Zero reserved fields.
3077            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3078
3079            // Safety:
3080            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3081            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3082            //   envelope_size bytes, there is always sufficient room.
3083            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
3084            self.source_moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
3085            encoder, offset + cur_offset, depth
3086        )?;
3087
3088            _prev_end_offset = cur_offset + envelope_size;
3089            if 2 > max_ordinal {
3090                return Ok(());
3091            }
3092
3093            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3094            // are envelope_size bytes.
3095            let cur_offset: usize = (2 - 1) * envelope_size;
3096
3097            // Zero reserved fields.
3098            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3099
3100            // Safety:
3101            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3102            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3103            //   envelope_size bytes, there is always sufficient room.
3104            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
3105                self.source_name.as_ref().map(
3106                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
3107                ),
3108                encoder,
3109                offset + cur_offset,
3110                depth,
3111            )?;
3112
3113            _prev_end_offset = cur_offset + envelope_size;
3114            if 3 > max_ordinal {
3115                return Ok(());
3116            }
3117
3118            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3119            // are envelope_size bytes.
3120            let cur_offset: usize = (3 - 1) * envelope_size;
3121
3122            // Zero reserved fields.
3123            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3124
3125            // Safety:
3126            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3127            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3128            //   envelope_size bytes, there is always sufficient room.
3129            fidl::encoding::encode_in_envelope_optional::<AllowlistedCapability, D>(
3130                self.capability
3131                    .as_ref()
3132                    .map(<AllowlistedCapability as fidl::encoding::ValueTypeMarker>::borrow),
3133                encoder,
3134                offset + cur_offset,
3135                depth,
3136            )?;
3137
3138            _prev_end_offset = cur_offset + envelope_size;
3139            if 4 > max_ordinal {
3140                return Ok(());
3141            }
3142
3143            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3144            // are envelope_size bytes.
3145            let cur_offset: usize = (4 - 1) * envelope_size;
3146
3147            // Zero reserved fields.
3148            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3149
3150            // Safety:
3151            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3152            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3153            //   envelope_size bytes, there is always sufficient room.
3154            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
3155            self.target_monikers.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
3156            encoder, offset + cur_offset, depth
3157        )?;
3158
3159            _prev_end_offset = cur_offset + envelope_size;
3160            if 5 > max_ordinal {
3161                return Ok(());
3162            }
3163
3164            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3165            // are envelope_size bytes.
3166            let cur_offset: usize = (5 - 1) * envelope_size;
3167
3168            // Zero reserved fields.
3169            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3170
3171            // Safety:
3172            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3173            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3174            //   envelope_size bytes, there is always sufficient room.
3175            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Ref, D>(
3176            self.source.as_ref().map(<fidl_fuchsia_component_decl__common::Ref as fidl::encoding::ValueTypeMarker>::borrow),
3177            encoder, offset + cur_offset, depth
3178        )?;
3179
3180            _prev_end_offset = cur_offset + envelope_size;
3181
3182            Ok(())
3183        }
3184    }
3185
3186    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3187        for CapabilityAllowlistEntry
3188    {
3189        #[inline(always)]
3190        fn new_empty() -> Self {
3191            Self::default()
3192        }
3193
3194        unsafe fn decode(
3195            &mut self,
3196            decoder: &mut fidl::encoding::Decoder<'_, D>,
3197            offset: usize,
3198            mut depth: fidl::encoding::Depth,
3199        ) -> fidl::Result<()> {
3200            decoder.debug_check_bounds::<Self>(offset);
3201            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3202                None => return Err(fidl::Error::NotNullable),
3203                Some(len) => len,
3204            };
3205            // Calling decoder.out_of_line_offset(0) is not allowed.
3206            if len == 0 {
3207                return Ok(());
3208            };
3209            depth.increment()?;
3210            let envelope_size = 8;
3211            let bytes_len = len * envelope_size;
3212            let offset = decoder.out_of_line_offset(bytes_len)?;
3213            // Decode the envelope for each type.
3214            let mut _next_ordinal_to_read = 0;
3215            let mut next_offset = offset;
3216            let end_offset = offset + bytes_len;
3217            _next_ordinal_to_read += 1;
3218            if next_offset >= end_offset {
3219                return Ok(());
3220            }
3221
3222            // Decode unknown envelopes for gaps in ordinals.
3223            while _next_ordinal_to_read < 1 {
3224                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3225                _next_ordinal_to_read += 1;
3226                next_offset += envelope_size;
3227            }
3228
3229            let next_out_of_line = decoder.next_out_of_line();
3230            let handles_before = decoder.remaining_handles();
3231            if let Some((inlined, num_bytes, num_handles)) =
3232                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3233            {
3234                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3235                if inlined != (member_inline_size <= 4) {
3236                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3237                }
3238                let inner_offset;
3239                let mut inner_depth = depth.clone();
3240                if inlined {
3241                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3242                    inner_offset = next_offset;
3243                } else {
3244                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3245                    inner_depth.increment()?;
3246                }
3247                let val_ref = self.source_moniker.get_or_insert_with(|| {
3248                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
3249                });
3250                fidl::decode!(
3251                    fidl::encoding::BoundedString<4096>,
3252                    D,
3253                    val_ref,
3254                    decoder,
3255                    inner_offset,
3256                    inner_depth
3257                )?;
3258                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3259                {
3260                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3261                }
3262                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3263                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3264                }
3265            }
3266
3267            next_offset += envelope_size;
3268            _next_ordinal_to_read += 1;
3269            if next_offset >= end_offset {
3270                return Ok(());
3271            }
3272
3273            // Decode unknown envelopes for gaps in ordinals.
3274            while _next_ordinal_to_read < 2 {
3275                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3276                _next_ordinal_to_read += 1;
3277                next_offset += envelope_size;
3278            }
3279
3280            let next_out_of_line = decoder.next_out_of_line();
3281            let handles_before = decoder.remaining_handles();
3282            if let Some((inlined, num_bytes, num_handles)) =
3283                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3284            {
3285                let member_inline_size =
3286                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
3287                        decoder.context,
3288                    );
3289                if inlined != (member_inline_size <= 4) {
3290                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3291                }
3292                let inner_offset;
3293                let mut inner_depth = depth.clone();
3294                if inlined {
3295                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3296                    inner_offset = next_offset;
3297                } else {
3298                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3299                    inner_depth.increment()?;
3300                }
3301                let val_ref = self
3302                    .source_name
3303                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
3304                fidl::decode!(
3305                    fidl::encoding::BoundedString<255>,
3306                    D,
3307                    val_ref,
3308                    decoder,
3309                    inner_offset,
3310                    inner_depth
3311                )?;
3312                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3313                {
3314                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3315                }
3316                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3317                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3318                }
3319            }
3320
3321            next_offset += envelope_size;
3322            _next_ordinal_to_read += 1;
3323            if next_offset >= end_offset {
3324                return Ok(());
3325            }
3326
3327            // Decode unknown envelopes for gaps in ordinals.
3328            while _next_ordinal_to_read < 3 {
3329                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3330                _next_ordinal_to_read += 1;
3331                next_offset += envelope_size;
3332            }
3333
3334            let next_out_of_line = decoder.next_out_of_line();
3335            let handles_before = decoder.remaining_handles();
3336            if let Some((inlined, num_bytes, num_handles)) =
3337                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3338            {
3339                let member_inline_size =
3340                    <AllowlistedCapability as fidl::encoding::TypeMarker>::inline_size(
3341                        decoder.context,
3342                    );
3343                if inlined != (member_inline_size <= 4) {
3344                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3345                }
3346                let inner_offset;
3347                let mut inner_depth = depth.clone();
3348                if inlined {
3349                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3350                    inner_offset = next_offset;
3351                } else {
3352                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3353                    inner_depth.increment()?;
3354                }
3355                let val_ref = self
3356                    .capability
3357                    .get_or_insert_with(|| fidl::new_empty!(AllowlistedCapability, D));
3358                fidl::decode!(
3359                    AllowlistedCapability,
3360                    D,
3361                    val_ref,
3362                    decoder,
3363                    inner_offset,
3364                    inner_depth
3365                )?;
3366                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3367                {
3368                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3369                }
3370                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3371                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3372                }
3373            }
3374
3375            next_offset += envelope_size;
3376            _next_ordinal_to_read += 1;
3377            if next_offset >= end_offset {
3378                return Ok(());
3379            }
3380
3381            // Decode unknown envelopes for gaps in ordinals.
3382            while _next_ordinal_to_read < 4 {
3383                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3384                _next_ordinal_to_read += 1;
3385                next_offset += envelope_size;
3386            }
3387
3388            let next_out_of_line = decoder.next_out_of_line();
3389            let handles_before = decoder.remaining_handles();
3390            if let Some((inlined, num_bytes, num_handles)) =
3391                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3392            {
3393                let member_inline_size = <fidl::encoding::Vector<
3394                    fidl::encoding::BoundedString<4096>,
3395                    128,
3396                > as fidl::encoding::TypeMarker>::inline_size(
3397                    decoder.context
3398                );
3399                if inlined != (member_inline_size <= 4) {
3400                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3401                }
3402                let inner_offset;
3403                let mut inner_depth = depth.clone();
3404                if inlined {
3405                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3406                    inner_offset = next_offset;
3407                } else {
3408                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3409                    inner_depth.increment()?;
3410                }
3411                let val_ref = self.target_monikers.get_or_insert_with(|| {
3412                    fidl::new_empty!(
3413                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3414                        D
3415                    )
3416                });
3417                fidl::decode!(
3418                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3419                    D,
3420                    val_ref,
3421                    decoder,
3422                    inner_offset,
3423                    inner_depth
3424                )?;
3425                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3426                {
3427                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3428                }
3429                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3430                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3431                }
3432            }
3433
3434            next_offset += envelope_size;
3435            _next_ordinal_to_read += 1;
3436            if next_offset >= end_offset {
3437                return Ok(());
3438            }
3439
3440            // Decode unknown envelopes for gaps in ordinals.
3441            while _next_ordinal_to_read < 5 {
3442                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3443                _next_ordinal_to_read += 1;
3444                next_offset += envelope_size;
3445            }
3446
3447            let next_out_of_line = decoder.next_out_of_line();
3448            let handles_before = decoder.remaining_handles();
3449            if let Some((inlined, num_bytes, num_handles)) =
3450                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3451            {
3452                let member_inline_size = <fidl_fuchsia_component_decl__common::Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3453                if inlined != (member_inline_size <= 4) {
3454                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3455                }
3456                let inner_offset;
3457                let mut inner_depth = depth.clone();
3458                if inlined {
3459                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3460                    inner_offset = next_offset;
3461                } else {
3462                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3463                    inner_depth.increment()?;
3464                }
3465                let val_ref = self.source.get_or_insert_with(|| {
3466                    fidl::new_empty!(fidl_fuchsia_component_decl__common::Ref, D)
3467                });
3468                fidl::decode!(
3469                    fidl_fuchsia_component_decl__common::Ref,
3470                    D,
3471                    val_ref,
3472                    decoder,
3473                    inner_offset,
3474                    inner_depth
3475                )?;
3476                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3477                {
3478                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3479                }
3480                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3481                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3482                }
3483            }
3484
3485            next_offset += envelope_size;
3486
3487            // Decode the remaining unknown envelopes.
3488            while next_offset < end_offset {
3489                _next_ordinal_to_read += 1;
3490                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3491                next_offset += envelope_size;
3492            }
3493
3494            Ok(())
3495        }
3496    }
3497
3498    impl CapabilityPolicyAllowlists {
3499        #[inline(always)]
3500        fn max_ordinal_present(&self) -> u64 {
3501            if let Some(_) = self.allowlist {
3502                return 1;
3503            }
3504            0
3505        }
3506    }
3507
3508    impl fidl::encoding::ValueTypeMarker for CapabilityPolicyAllowlists {
3509        type Borrowed<'a> = &'a Self;
3510        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3511            value
3512        }
3513    }
3514
3515    unsafe impl fidl::encoding::TypeMarker for CapabilityPolicyAllowlists {
3516        type Owned = Self;
3517
3518        #[inline(always)]
3519        fn inline_align(_context: fidl::encoding::Context) -> usize {
3520            8
3521        }
3522
3523        #[inline(always)]
3524        fn inline_size(_context: fidl::encoding::Context) -> usize {
3525            16
3526        }
3527    }
3528
3529    unsafe impl<D: fidl::encoding::ResourceDialect>
3530        fidl::encoding::Encode<CapabilityPolicyAllowlists, D> for &CapabilityPolicyAllowlists
3531    {
3532        unsafe fn encode(
3533            self,
3534            encoder: &mut fidl::encoding::Encoder<'_, D>,
3535            offset: usize,
3536            mut depth: fidl::encoding::Depth,
3537        ) -> fidl::Result<()> {
3538            encoder.debug_check_bounds::<CapabilityPolicyAllowlists>(offset);
3539            // Vector header
3540            let max_ordinal: u64 = self.max_ordinal_present();
3541            encoder.write_num(max_ordinal, offset);
3542            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3543            // Calling encoder.out_of_line_offset(0) is not allowed.
3544            if max_ordinal == 0 {
3545                return Ok(());
3546            }
3547            depth.increment()?;
3548            let envelope_size = 8;
3549            let bytes_len = max_ordinal as usize * envelope_size;
3550            #[allow(unused_variables)]
3551            let offset = encoder.out_of_line_offset(bytes_len);
3552            let mut _prev_end_offset: usize = 0;
3553            if 1 > max_ordinal {
3554                return Ok(());
3555            }
3556
3557            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3558            // are envelope_size bytes.
3559            let cur_offset: usize = (1 - 1) * envelope_size;
3560
3561            // Zero reserved fields.
3562            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3563
3564            // Safety:
3565            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3566            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3567            //   envelope_size bytes, there is always sufficient room.
3568            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CapabilityAllowlistEntry, 128>, D>(
3569            self.allowlist.as_ref().map(<fidl::encoding::Vector<CapabilityAllowlistEntry, 128> as fidl::encoding::ValueTypeMarker>::borrow),
3570            encoder, offset + cur_offset, depth
3571        )?;
3572
3573            _prev_end_offset = cur_offset + envelope_size;
3574
3575            Ok(())
3576        }
3577    }
3578
3579    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3580        for CapabilityPolicyAllowlists
3581    {
3582        #[inline(always)]
3583        fn new_empty() -> Self {
3584            Self::default()
3585        }
3586
3587        unsafe fn decode(
3588            &mut self,
3589            decoder: &mut fidl::encoding::Decoder<'_, D>,
3590            offset: usize,
3591            mut depth: fidl::encoding::Depth,
3592        ) -> fidl::Result<()> {
3593            decoder.debug_check_bounds::<Self>(offset);
3594            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3595                None => return Err(fidl::Error::NotNullable),
3596                Some(len) => len,
3597            };
3598            // Calling decoder.out_of_line_offset(0) is not allowed.
3599            if len == 0 {
3600                return Ok(());
3601            };
3602            depth.increment()?;
3603            let envelope_size = 8;
3604            let bytes_len = len * envelope_size;
3605            let offset = decoder.out_of_line_offset(bytes_len)?;
3606            // Decode the envelope for each type.
3607            let mut _next_ordinal_to_read = 0;
3608            let mut next_offset = offset;
3609            let end_offset = offset + bytes_len;
3610            _next_ordinal_to_read += 1;
3611            if next_offset >= end_offset {
3612                return Ok(());
3613            }
3614
3615            // Decode unknown envelopes for gaps in ordinals.
3616            while _next_ordinal_to_read < 1 {
3617                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3618                _next_ordinal_to_read += 1;
3619                next_offset += envelope_size;
3620            }
3621
3622            let next_out_of_line = decoder.next_out_of_line();
3623            let handles_before = decoder.remaining_handles();
3624            if let Some((inlined, num_bytes, num_handles)) =
3625                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3626            {
3627                let member_inline_size = <fidl::encoding::Vector<CapabilityAllowlistEntry, 128> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3628                if inlined != (member_inline_size <= 4) {
3629                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3630                }
3631                let inner_offset;
3632                let mut inner_depth = depth.clone();
3633                if inlined {
3634                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3635                    inner_offset = next_offset;
3636                } else {
3637                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3638                    inner_depth.increment()?;
3639                }
3640                let val_ref = self.allowlist.get_or_insert_with(
3641                    || fidl::new_empty!(fidl::encoding::Vector<CapabilityAllowlistEntry, 128>, D),
3642                );
3643                fidl::decode!(fidl::encoding::Vector<CapabilityAllowlistEntry, 128>, D, val_ref, decoder, inner_offset, inner_depth)?;
3644                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3645                {
3646                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3647                }
3648                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3649                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3650                }
3651            }
3652
3653            next_offset += envelope_size;
3654
3655            // Decode the remaining unknown envelopes.
3656            while next_offset < end_offset {
3657                _next_ordinal_to_read += 1;
3658                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3659                next_offset += envelope_size;
3660            }
3661
3662            Ok(())
3663        }
3664    }
3665
3666    impl ChildPolicyAllowlists {
3667        #[inline(always)]
3668        fn max_ordinal_present(&self) -> u64 {
3669            if let Some(_) = self.reboot_on_terminate {
3670                return 1;
3671            }
3672            0
3673        }
3674    }
3675
3676    impl fidl::encoding::ValueTypeMarker for ChildPolicyAllowlists {
3677        type Borrowed<'a> = &'a Self;
3678        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3679            value
3680        }
3681    }
3682
3683    unsafe impl fidl::encoding::TypeMarker for ChildPolicyAllowlists {
3684        type Owned = Self;
3685
3686        #[inline(always)]
3687        fn inline_align(_context: fidl::encoding::Context) -> usize {
3688            8
3689        }
3690
3691        #[inline(always)]
3692        fn inline_size(_context: fidl::encoding::Context) -> usize {
3693            16
3694        }
3695    }
3696
3697    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChildPolicyAllowlists, D>
3698        for &ChildPolicyAllowlists
3699    {
3700        unsafe fn encode(
3701            self,
3702            encoder: &mut fidl::encoding::Encoder<'_, D>,
3703            offset: usize,
3704            mut depth: fidl::encoding::Depth,
3705        ) -> fidl::Result<()> {
3706            encoder.debug_check_bounds::<ChildPolicyAllowlists>(offset);
3707            // Vector header
3708            let max_ordinal: u64 = self.max_ordinal_present();
3709            encoder.write_num(max_ordinal, offset);
3710            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3711            // Calling encoder.out_of_line_offset(0) is not allowed.
3712            if max_ordinal == 0 {
3713                return Ok(());
3714            }
3715            depth.increment()?;
3716            let envelope_size = 8;
3717            let bytes_len = max_ordinal as usize * envelope_size;
3718            #[allow(unused_variables)]
3719            let offset = encoder.out_of_line_offset(bytes_len);
3720            let mut _prev_end_offset: usize = 0;
3721            if 1 > max_ordinal {
3722                return Ok(());
3723            }
3724
3725            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3726            // are envelope_size bytes.
3727            let cur_offset: usize = (1 - 1) * envelope_size;
3728
3729            // Zero reserved fields.
3730            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3731
3732            // Safety:
3733            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3734            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3735            //   envelope_size bytes, there is always sufficient room.
3736            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
3737            self.reboot_on_terminate.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
3738            encoder, offset + cur_offset, depth
3739        )?;
3740
3741            _prev_end_offset = cur_offset + envelope_size;
3742
3743            Ok(())
3744        }
3745    }
3746
3747    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChildPolicyAllowlists {
3748        #[inline(always)]
3749        fn new_empty() -> Self {
3750            Self::default()
3751        }
3752
3753        unsafe fn decode(
3754            &mut self,
3755            decoder: &mut fidl::encoding::Decoder<'_, D>,
3756            offset: usize,
3757            mut depth: fidl::encoding::Depth,
3758        ) -> fidl::Result<()> {
3759            decoder.debug_check_bounds::<Self>(offset);
3760            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3761                None => return Err(fidl::Error::NotNullable),
3762                Some(len) => len,
3763            };
3764            // Calling decoder.out_of_line_offset(0) is not allowed.
3765            if len == 0 {
3766                return Ok(());
3767            };
3768            depth.increment()?;
3769            let envelope_size = 8;
3770            let bytes_len = len * envelope_size;
3771            let offset = decoder.out_of_line_offset(bytes_len)?;
3772            // Decode the envelope for each type.
3773            let mut _next_ordinal_to_read = 0;
3774            let mut next_offset = offset;
3775            let end_offset = offset + bytes_len;
3776            _next_ordinal_to_read += 1;
3777            if next_offset >= end_offset {
3778                return Ok(());
3779            }
3780
3781            // Decode unknown envelopes for gaps in ordinals.
3782            while _next_ordinal_to_read < 1 {
3783                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3784                _next_ordinal_to_read += 1;
3785                next_offset += envelope_size;
3786            }
3787
3788            let next_out_of_line = decoder.next_out_of_line();
3789            let handles_before = decoder.remaining_handles();
3790            if let Some((inlined, num_bytes, num_handles)) =
3791                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3792            {
3793                let member_inline_size = <fidl::encoding::Vector<
3794                    fidl::encoding::BoundedString<4096>,
3795                    128,
3796                > as fidl::encoding::TypeMarker>::inline_size(
3797                    decoder.context
3798                );
3799                if inlined != (member_inline_size <= 4) {
3800                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3801                }
3802                let inner_offset;
3803                let mut inner_depth = depth.clone();
3804                if inlined {
3805                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3806                    inner_offset = next_offset;
3807                } else {
3808                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3809                    inner_depth.increment()?;
3810                }
3811                let val_ref = self.reboot_on_terminate.get_or_insert_with(|| {
3812                    fidl::new_empty!(
3813                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3814                        D
3815                    )
3816                });
3817                fidl::decode!(
3818                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3819                    D,
3820                    val_ref,
3821                    decoder,
3822                    inner_offset,
3823                    inner_depth
3824                )?;
3825                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3826                {
3827                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3828                }
3829                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3830                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3831                }
3832            }
3833
3834            next_offset += envelope_size;
3835
3836            // Decode the remaining unknown envelopes.
3837            while next_offset < end_offset {
3838                _next_ordinal_to_read += 1;
3839                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3840                next_offset += envelope_size;
3841            }
3842
3843            Ok(())
3844        }
3845    }
3846
3847    impl Component {
3848        #[inline(always)]
3849        fn max_ordinal_present(&self) -> u64 {
3850            if let Some(_) = self.moniker {
3851                return 2;
3852            }
3853            if let Some(_) = self.capability {
3854                return 1;
3855            }
3856            0
3857        }
3858    }
3859
3860    impl fidl::encoding::ValueTypeMarker for Component {
3861        type Borrowed<'a> = &'a Self;
3862        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3863            value
3864        }
3865    }
3866
3867    unsafe impl fidl::encoding::TypeMarker for Component {
3868        type Owned = Self;
3869
3870        #[inline(always)]
3871        fn inline_align(_context: fidl::encoding::Context) -> usize {
3872            8
3873        }
3874
3875        #[inline(always)]
3876        fn inline_size(_context: fidl::encoding::Context) -> usize {
3877            16
3878        }
3879    }
3880
3881    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Component, D>
3882        for &Component
3883    {
3884        unsafe fn encode(
3885            self,
3886            encoder: &mut fidl::encoding::Encoder<'_, D>,
3887            offset: usize,
3888            mut depth: fidl::encoding::Depth,
3889        ) -> fidl::Result<()> {
3890            encoder.debug_check_bounds::<Component>(offset);
3891            // Vector header
3892            let max_ordinal: u64 = self.max_ordinal_present();
3893            encoder.write_num(max_ordinal, offset);
3894            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3895            // Calling encoder.out_of_line_offset(0) is not allowed.
3896            if max_ordinal == 0 {
3897                return Ok(());
3898            }
3899            depth.increment()?;
3900            let envelope_size = 8;
3901            let bytes_len = max_ordinal as usize * envelope_size;
3902            #[allow(unused_variables)]
3903            let offset = encoder.out_of_line_offset(bytes_len);
3904            let mut _prev_end_offset: usize = 0;
3905            if 1 > max_ordinal {
3906                return Ok(());
3907            }
3908
3909            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3910            // are envelope_size bytes.
3911            let cur_offset: usize = (1 - 1) * envelope_size;
3912
3913            // Zero reserved fields.
3914            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3915
3916            // Safety:
3917            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3918            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3919            //   envelope_size bytes, there is always sufficient room.
3920            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
3921                self.capability
3922                    .as_ref()
3923                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
3924                encoder,
3925                offset + cur_offset,
3926                depth,
3927            )?;
3928
3929            _prev_end_offset = cur_offset + envelope_size;
3930            if 2 > max_ordinal {
3931                return Ok(());
3932            }
3933
3934            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3935            // are envelope_size bytes.
3936            let cur_offset: usize = (2 - 1) * envelope_size;
3937
3938            // Zero reserved fields.
3939            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3940
3941            // Safety:
3942            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3943            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3944            //   envelope_size bytes, there is always sufficient room.
3945            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
3946            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
3947            encoder, offset + cur_offset, depth
3948        )?;
3949
3950            _prev_end_offset = cur_offset + envelope_size;
3951
3952            Ok(())
3953        }
3954    }
3955
3956    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Component {
3957        #[inline(always)]
3958        fn new_empty() -> Self {
3959            Self::default()
3960        }
3961
3962        unsafe fn decode(
3963            &mut self,
3964            decoder: &mut fidl::encoding::Decoder<'_, D>,
3965            offset: usize,
3966            mut depth: fidl::encoding::Depth,
3967        ) -> fidl::Result<()> {
3968            decoder.debug_check_bounds::<Self>(offset);
3969            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3970                None => return Err(fidl::Error::NotNullable),
3971                Some(len) => len,
3972            };
3973            // Calling decoder.out_of_line_offset(0) is not allowed.
3974            if len == 0 {
3975                return Ok(());
3976            };
3977            depth.increment()?;
3978            let envelope_size = 8;
3979            let bytes_len = len * envelope_size;
3980            let offset = decoder.out_of_line_offset(bytes_len)?;
3981            // Decode the envelope for each type.
3982            let mut _next_ordinal_to_read = 0;
3983            let mut next_offset = offset;
3984            let end_offset = offset + bytes_len;
3985            _next_ordinal_to_read += 1;
3986            if next_offset >= end_offset {
3987                return Ok(());
3988            }
3989
3990            // Decode unknown envelopes for gaps in ordinals.
3991            while _next_ordinal_to_read < 1 {
3992                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3993                _next_ordinal_to_read += 1;
3994                next_offset += envelope_size;
3995            }
3996
3997            let next_out_of_line = decoder.next_out_of_line();
3998            let handles_before = decoder.remaining_handles();
3999            if let Some((inlined, num_bytes, num_handles)) =
4000                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4001            {
4002                let member_inline_size =
4003                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
4004                        decoder.context,
4005                    );
4006                if inlined != (member_inline_size <= 4) {
4007                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4008                }
4009                let inner_offset;
4010                let mut inner_depth = depth.clone();
4011                if inlined {
4012                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4013                    inner_offset = next_offset;
4014                } else {
4015                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4016                    inner_depth.increment()?;
4017                }
4018                let val_ref =
4019                    self.capability.get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
4020                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
4021                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4022                {
4023                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4024                }
4025                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4026                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4027                }
4028            }
4029
4030            next_offset += envelope_size;
4031            _next_ordinal_to_read += 1;
4032            if next_offset >= end_offset {
4033                return Ok(());
4034            }
4035
4036            // Decode unknown envelopes for gaps in ordinals.
4037            while _next_ordinal_to_read < 2 {
4038                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4039                _next_ordinal_to_read += 1;
4040                next_offset += envelope_size;
4041            }
4042
4043            let next_out_of_line = decoder.next_out_of_line();
4044            let handles_before = decoder.remaining_handles();
4045            if let Some((inlined, num_bytes, num_handles)) =
4046                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4047            {
4048                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4049                if inlined != (member_inline_size <= 4) {
4050                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4051                }
4052                let inner_offset;
4053                let mut inner_depth = depth.clone();
4054                if inlined {
4055                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4056                    inner_offset = next_offset;
4057                } else {
4058                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4059                    inner_depth.increment()?;
4060                }
4061                let val_ref = self.moniker.get_or_insert_with(|| {
4062                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
4063                });
4064                fidl::decode!(
4065                    fidl::encoding::BoundedString<4096>,
4066                    D,
4067                    val_ref,
4068                    decoder,
4069                    inner_offset,
4070                    inner_depth
4071                )?;
4072                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4073                {
4074                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4075                }
4076                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4077                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4078                }
4079            }
4080
4081            next_offset += envelope_size;
4082
4083            // Decode the remaining unknown envelopes.
4084            while next_offset < end_offset {
4085                _next_ordinal_to_read += 1;
4086                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4087                next_offset += envelope_size;
4088            }
4089
4090            Ok(())
4091        }
4092    }
4093
4094    impl ComponentIdIndex {
4095        #[inline(always)]
4096        fn max_ordinal_present(&self) -> u64 {
4097            if let Some(_) = self.instances {
4098                return 2;
4099            }
4100            0
4101        }
4102    }
4103
4104    impl fidl::encoding::ValueTypeMarker for ComponentIdIndex {
4105        type Borrowed<'a> = &'a Self;
4106        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4107            value
4108        }
4109    }
4110
4111    unsafe impl fidl::encoding::TypeMarker for ComponentIdIndex {
4112        type Owned = Self;
4113
4114        #[inline(always)]
4115        fn inline_align(_context: fidl::encoding::Context) -> usize {
4116            8
4117        }
4118
4119        #[inline(always)]
4120        fn inline_size(_context: fidl::encoding::Context) -> usize {
4121            16
4122        }
4123    }
4124
4125    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ComponentIdIndex, D>
4126        for &ComponentIdIndex
4127    {
4128        unsafe fn encode(
4129            self,
4130            encoder: &mut fidl::encoding::Encoder<'_, D>,
4131            offset: usize,
4132            mut depth: fidl::encoding::Depth,
4133        ) -> fidl::Result<()> {
4134            encoder.debug_check_bounds::<ComponentIdIndex>(offset);
4135            // Vector header
4136            let max_ordinal: u64 = self.max_ordinal_present();
4137            encoder.write_num(max_ordinal, offset);
4138            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4139            // Calling encoder.out_of_line_offset(0) is not allowed.
4140            if max_ordinal == 0 {
4141                return Ok(());
4142            }
4143            depth.increment()?;
4144            let envelope_size = 8;
4145            let bytes_len = max_ordinal as usize * envelope_size;
4146            #[allow(unused_variables)]
4147            let offset = encoder.out_of_line_offset(bytes_len);
4148            let mut _prev_end_offset: usize = 0;
4149            if 2 > max_ordinal {
4150                return Ok(());
4151            }
4152
4153            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4154            // are envelope_size bytes.
4155            let cur_offset: usize = (2 - 1) * envelope_size;
4156
4157            // Zero reserved fields.
4158            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4159
4160            // Safety:
4161            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4162            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4163            //   envelope_size bytes, there is always sufficient room.
4164            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<InstanceIdEntry, 1024>, D>(
4165            self.instances.as_ref().map(<fidl::encoding::Vector<InstanceIdEntry, 1024> as fidl::encoding::ValueTypeMarker>::borrow),
4166            encoder, offset + cur_offset, depth
4167        )?;
4168
4169            _prev_end_offset = cur_offset + envelope_size;
4170
4171            Ok(())
4172        }
4173    }
4174
4175    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ComponentIdIndex {
4176        #[inline(always)]
4177        fn new_empty() -> Self {
4178            Self::default()
4179        }
4180
4181        unsafe fn decode(
4182            &mut self,
4183            decoder: &mut fidl::encoding::Decoder<'_, D>,
4184            offset: usize,
4185            mut depth: fidl::encoding::Depth,
4186        ) -> fidl::Result<()> {
4187            decoder.debug_check_bounds::<Self>(offset);
4188            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4189                None => return Err(fidl::Error::NotNullable),
4190                Some(len) => len,
4191            };
4192            // Calling decoder.out_of_line_offset(0) is not allowed.
4193            if len == 0 {
4194                return Ok(());
4195            };
4196            depth.increment()?;
4197            let envelope_size = 8;
4198            let bytes_len = len * envelope_size;
4199            let offset = decoder.out_of_line_offset(bytes_len)?;
4200            // Decode the envelope for each type.
4201            let mut _next_ordinal_to_read = 0;
4202            let mut next_offset = offset;
4203            let end_offset = offset + bytes_len;
4204            _next_ordinal_to_read += 1;
4205            if next_offset >= end_offset {
4206                return Ok(());
4207            }
4208
4209            // Decode unknown envelopes for gaps in ordinals.
4210            while _next_ordinal_to_read < 2 {
4211                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4212                _next_ordinal_to_read += 1;
4213                next_offset += envelope_size;
4214            }
4215
4216            let next_out_of_line = decoder.next_out_of_line();
4217            let handles_before = decoder.remaining_handles();
4218            if let Some((inlined, num_bytes, num_handles)) =
4219                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4220            {
4221                let member_inline_size = <fidl::encoding::Vector<InstanceIdEntry, 1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4222                if inlined != (member_inline_size <= 4) {
4223                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4224                }
4225                let inner_offset;
4226                let mut inner_depth = depth.clone();
4227                if inlined {
4228                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4229                    inner_offset = next_offset;
4230                } else {
4231                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4232                    inner_depth.increment()?;
4233                }
4234                let val_ref = self.instances.get_or_insert_with(
4235                    || fidl::new_empty!(fidl::encoding::Vector<InstanceIdEntry, 1024>, D),
4236                );
4237                fidl::decode!(fidl::encoding::Vector<InstanceIdEntry, 1024>, D, val_ref, decoder, inner_offset, inner_depth)?;
4238                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4239                {
4240                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4241                }
4242                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4243                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4244                }
4245            }
4246
4247            next_offset += envelope_size;
4248
4249            // Decode the remaining unknown envelopes.
4250            while next_offset < end_offset {
4251                _next_ordinal_to_read += 1;
4252                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4253                next_offset += envelope_size;
4254            }
4255
4256            Ok(())
4257        }
4258    }
4259
4260    impl Config {
4261        #[inline(always)]
4262        fn max_ordinal_present(&self) -> u64 {
4263            if let Some(_) = self.scudo_options {
4264                return 24;
4265            }
4266            if let Some(_) = self.inject_capabilities {
4267                return 23;
4268            }
4269            if let Some(_) = self.trace_provider {
4270                return 22;
4271            }
4272            if let Some(_) = self.health_check {
4273                return 21;
4274            }
4275            if let Some(_) = self.vmex_source {
4276                return 20;
4277            }
4278            if let Some(_) = self.abi_revision_policy {
4279                return 19;
4280            }
4281            if let Some(_) = self.enable_introspection {
4282                return 18;
4283            }
4284            if let Some(_) = self.builtin_capabilities {
4285                return 17;
4286            }
4287            if let Some(_) = self.realm_builder_resolver_and_runner {
4288                return 16;
4289            }
4290            if let Some(_) = self.builtin_boot_resolver {
4291                return 14;
4292            }
4293            if let Some(_) = self.log_all_events {
4294                return 13;
4295            }
4296            if let Some(_) = self.log_destination {
4297                return 12;
4298            }
4299            if let Some(_) = self.component_id_index_path {
4300                return 11;
4301            }
4302            if let Some(_) = self.root_component_url {
4303                return 10;
4304            }
4305            if let Some(_) = self.num_threads {
4306                return 7;
4307            }
4308            if let Some(_) = self.maintain_utc_clock {
4309                return 6;
4310            }
4311            if let Some(_) = self.use_builtin_process_launcher {
4312                return 5;
4313            }
4314            if let Some(_) = self.namespace_capabilities {
4315                return 4;
4316            }
4317            if let Some(_) = self.security_policy {
4318                return 3;
4319            }
4320            if let Some(_) = self.list_children_batch_size {
4321                return 2;
4322            }
4323            if let Some(_) = self.debug {
4324                return 1;
4325            }
4326            0
4327        }
4328    }
4329
4330    impl fidl::encoding::ValueTypeMarker for Config {
4331        type Borrowed<'a> = &'a Self;
4332        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4333            value
4334        }
4335    }
4336
4337    unsafe impl fidl::encoding::TypeMarker for Config {
4338        type Owned = Self;
4339
4340        #[inline(always)]
4341        fn inline_align(_context: fidl::encoding::Context) -> usize {
4342            8
4343        }
4344
4345        #[inline(always)]
4346        fn inline_size(_context: fidl::encoding::Context) -> usize {
4347            16
4348        }
4349    }
4350
4351    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Config, D> for &Config {
4352        unsafe fn encode(
4353            self,
4354            encoder: &mut fidl::encoding::Encoder<'_, D>,
4355            offset: usize,
4356            mut depth: fidl::encoding::Depth,
4357        ) -> fidl::Result<()> {
4358            encoder.debug_check_bounds::<Config>(offset);
4359            // Vector header
4360            let max_ordinal: u64 = self.max_ordinal_present();
4361            encoder.write_num(max_ordinal, offset);
4362            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4363            // Calling encoder.out_of_line_offset(0) is not allowed.
4364            if max_ordinal == 0 {
4365                return Ok(());
4366            }
4367            depth.increment()?;
4368            let envelope_size = 8;
4369            let bytes_len = max_ordinal as usize * envelope_size;
4370            #[allow(unused_variables)]
4371            let offset = encoder.out_of_line_offset(bytes_len);
4372            let mut _prev_end_offset: usize = 0;
4373            if 1 > 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 = (1 - 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.debug.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4390                encoder,
4391                offset + cur_offset,
4392                depth,
4393            )?;
4394
4395            _prev_end_offset = cur_offset + envelope_size;
4396            if 2 > max_ordinal {
4397                return Ok(());
4398            }
4399
4400            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4401            // are envelope_size bytes.
4402            let cur_offset: usize = (2 - 1) * envelope_size;
4403
4404            // Zero reserved fields.
4405            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4406
4407            // Safety:
4408            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4409            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4410            //   envelope_size bytes, there is always sufficient room.
4411            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4412                self.list_children_batch_size
4413                    .as_ref()
4414                    .map(<u32 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 3 > 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 = (3 - 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::<SecurityPolicy, D>(
4437                self.security_policy
4438                    .as_ref()
4439                    .map(<SecurityPolicy as fidl::encoding::ValueTypeMarker>::borrow),
4440                encoder,
4441                offset + cur_offset,
4442                depth,
4443            )?;
4444
4445            _prev_end_offset = cur_offset + envelope_size;
4446            if 4 > max_ordinal {
4447                return Ok(());
4448            }
4449
4450            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4451            // are envelope_size bytes.
4452            let cur_offset: usize = (4 - 1) * envelope_size;
4453
4454            // Zero reserved fields.
4455            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4456
4457            // Safety:
4458            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4459            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4460            //   envelope_size bytes, there is always sufficient room.
4461            fidl::encoding::encode_in_envelope_optional::<
4462                fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Capability>,
4463                D,
4464            >(
4465                self.namespace_capabilities.as_ref().map(
4466                    <fidl::encoding::UnboundedVector<
4467                        fidl_fuchsia_component_decl__common::Capability,
4468                    > as fidl::encoding::ValueTypeMarker>::borrow,
4469                ),
4470                encoder,
4471                offset + cur_offset,
4472                depth,
4473            )?;
4474
4475            _prev_end_offset = cur_offset + envelope_size;
4476            if 5 > max_ordinal {
4477                return Ok(());
4478            }
4479
4480            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4481            // are envelope_size bytes.
4482            let cur_offset: usize = (5 - 1) * envelope_size;
4483
4484            // Zero reserved fields.
4485            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4486
4487            // Safety:
4488            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4489            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4490            //   envelope_size bytes, there is always sufficient room.
4491            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4492                self.use_builtin_process_launcher
4493                    .as_ref()
4494                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4495                encoder,
4496                offset + cur_offset,
4497                depth,
4498            )?;
4499
4500            _prev_end_offset = cur_offset + envelope_size;
4501            if 6 > max_ordinal {
4502                return Ok(());
4503            }
4504
4505            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4506            // are envelope_size bytes.
4507            let cur_offset: usize = (6 - 1) * envelope_size;
4508
4509            // Zero reserved fields.
4510            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4511
4512            // Safety:
4513            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4514            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4515            //   envelope_size bytes, there is always sufficient room.
4516            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4517                self.maintain_utc_clock
4518                    .as_ref()
4519                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4520                encoder,
4521                offset + cur_offset,
4522                depth,
4523            )?;
4524
4525            _prev_end_offset = cur_offset + envelope_size;
4526            if 7 > max_ordinal {
4527                return Ok(());
4528            }
4529
4530            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4531            // are envelope_size bytes.
4532            let cur_offset: usize = (7 - 1) * envelope_size;
4533
4534            // Zero reserved fields.
4535            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4536
4537            // Safety:
4538            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4539            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4540            //   envelope_size bytes, there is always sufficient room.
4541            fidl::encoding::encode_in_envelope_optional::<u8, D>(
4542                self.num_threads.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
4543                encoder,
4544                offset + cur_offset,
4545                depth,
4546            )?;
4547
4548            _prev_end_offset = cur_offset + envelope_size;
4549            if 10 > max_ordinal {
4550                return Ok(());
4551            }
4552
4553            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4554            // are envelope_size bytes.
4555            let cur_offset: usize = (10 - 1) * envelope_size;
4556
4557            // Zero reserved fields.
4558            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4559
4560            // Safety:
4561            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4562            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4563            //   envelope_size bytes, there is always sufficient room.
4564            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
4565            self.root_component_url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
4566            encoder, offset + cur_offset, depth
4567        )?;
4568
4569            _prev_end_offset = cur_offset + envelope_size;
4570            if 11 > max_ordinal {
4571                return Ok(());
4572            }
4573
4574            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4575            // are envelope_size bytes.
4576            let cur_offset: usize = (11 - 1) * envelope_size;
4577
4578            // Zero reserved fields.
4579            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4580
4581            // Safety:
4582            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4583            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4584            //   envelope_size bytes, there is always sufficient room.
4585            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
4586            self.component_id_index_path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
4587            encoder, offset + cur_offset, depth
4588        )?;
4589
4590            _prev_end_offset = cur_offset + envelope_size;
4591            if 12 > 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 = (12 - 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::<LogDestination, D>(
4607                self.log_destination
4608                    .as_ref()
4609                    .map(<LogDestination 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 13 > 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 = (13 - 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::<bool, D>(
4632                self.log_all_events.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4633                encoder,
4634                offset + cur_offset,
4635                depth,
4636            )?;
4637
4638            _prev_end_offset = cur_offset + envelope_size;
4639            if 14 > max_ordinal {
4640                return Ok(());
4641            }
4642
4643            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4644            // are envelope_size bytes.
4645            let cur_offset: usize = (14 - 1) * envelope_size;
4646
4647            // Zero reserved fields.
4648            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4649
4650            // Safety:
4651            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4652            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4653            //   envelope_size bytes, there is always sufficient room.
4654            fidl::encoding::encode_in_envelope_optional::<BuiltinBootResolver, D>(
4655                self.builtin_boot_resolver
4656                    .as_ref()
4657                    .map(<BuiltinBootResolver as fidl::encoding::ValueTypeMarker>::borrow),
4658                encoder,
4659                offset + cur_offset,
4660                depth,
4661            )?;
4662
4663            _prev_end_offset = cur_offset + envelope_size;
4664            if 16 > max_ordinal {
4665                return Ok(());
4666            }
4667
4668            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4669            // are envelope_size bytes.
4670            let cur_offset: usize = (16 - 1) * envelope_size;
4671
4672            // Zero reserved fields.
4673            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4674
4675            // Safety:
4676            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4677            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4678            //   envelope_size bytes, there is always sufficient room.
4679            fidl::encoding::encode_in_envelope_optional::<RealmBuilderResolverAndRunner, D>(
4680                self.realm_builder_resolver_and_runner.as_ref().map(
4681                    <RealmBuilderResolverAndRunner as fidl::encoding::ValueTypeMarker>::borrow,
4682                ),
4683                encoder,
4684                offset + cur_offset,
4685                depth,
4686            )?;
4687
4688            _prev_end_offset = cur_offset + envelope_size;
4689            if 17 > max_ordinal {
4690                return Ok(());
4691            }
4692
4693            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4694            // are envelope_size bytes.
4695            let cur_offset: usize = (17 - 1) * envelope_size;
4696
4697            // Zero reserved fields.
4698            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4699
4700            // Safety:
4701            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4702            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4703            //   envelope_size bytes, there is always sufficient room.
4704            fidl::encoding::encode_in_envelope_optional::<
4705                fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Capability>,
4706                D,
4707            >(
4708                self.builtin_capabilities.as_ref().map(
4709                    <fidl::encoding::UnboundedVector<
4710                        fidl_fuchsia_component_decl__common::Capability,
4711                    > as fidl::encoding::ValueTypeMarker>::borrow,
4712                ),
4713                encoder,
4714                offset + cur_offset,
4715                depth,
4716            )?;
4717
4718            _prev_end_offset = cur_offset + envelope_size;
4719            if 18 > max_ordinal {
4720                return Ok(());
4721            }
4722
4723            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4724            // are envelope_size bytes.
4725            let cur_offset: usize = (18 - 1) * envelope_size;
4726
4727            // Zero reserved fields.
4728            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4729
4730            // Safety:
4731            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4732            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4733            //   envelope_size bytes, there is always sufficient room.
4734            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4735                self.enable_introspection
4736                    .as_ref()
4737                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4738                encoder,
4739                offset + cur_offset,
4740                depth,
4741            )?;
4742
4743            _prev_end_offset = cur_offset + envelope_size;
4744            if 19 > max_ordinal {
4745                return Ok(());
4746            }
4747
4748            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4749            // are envelope_size bytes.
4750            let cur_offset: usize = (19 - 1) * envelope_size;
4751
4752            // Zero reserved fields.
4753            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4754
4755            // Safety:
4756            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4757            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4758            //   envelope_size bytes, there is always sufficient room.
4759            fidl::encoding::encode_in_envelope_optional::<AbiRevisionPolicy, D>(
4760                self.abi_revision_policy
4761                    .as_ref()
4762                    .map(<AbiRevisionPolicy as fidl::encoding::ValueTypeMarker>::borrow),
4763                encoder,
4764                offset + cur_offset,
4765                depth,
4766            )?;
4767
4768            _prev_end_offset = cur_offset + envelope_size;
4769            if 20 > max_ordinal {
4770                return Ok(());
4771            }
4772
4773            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4774            // are envelope_size bytes.
4775            let cur_offset: usize = (20 - 1) * envelope_size;
4776
4777            // Zero reserved fields.
4778            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4779
4780            // Safety:
4781            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4782            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4783            //   envelope_size bytes, there is always sufficient room.
4784            fidl::encoding::encode_in_envelope_optional::<VmexSource, D>(
4785                self.vmex_source
4786                    .as_ref()
4787                    .map(<VmexSource as fidl::encoding::ValueTypeMarker>::borrow),
4788                encoder,
4789                offset + cur_offset,
4790                depth,
4791            )?;
4792
4793            _prev_end_offset = cur_offset + envelope_size;
4794            if 21 > max_ordinal {
4795                return Ok(());
4796            }
4797
4798            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4799            // are envelope_size bytes.
4800            let cur_offset: usize = (21 - 1) * envelope_size;
4801
4802            // Zero reserved fields.
4803            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4804
4805            // Safety:
4806            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4807            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4808            //   envelope_size bytes, there is always sufficient room.
4809            fidl::encoding::encode_in_envelope_optional::<HealthCheck, D>(
4810                self.health_check
4811                    .as_ref()
4812                    .map(<HealthCheck as fidl::encoding::ValueTypeMarker>::borrow),
4813                encoder,
4814                offset + cur_offset,
4815                depth,
4816            )?;
4817
4818            _prev_end_offset = cur_offset + envelope_size;
4819            if 22 > max_ordinal {
4820                return Ok(());
4821            }
4822
4823            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4824            // are envelope_size bytes.
4825            let cur_offset: usize = (22 - 1) * envelope_size;
4826
4827            // Zero reserved fields.
4828            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4829
4830            // Safety:
4831            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4832            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4833            //   envelope_size bytes, there is always sufficient room.
4834            fidl::encoding::encode_in_envelope_optional::<TraceProvider, D>(
4835                self.trace_provider
4836                    .as_ref()
4837                    .map(<TraceProvider as fidl::encoding::ValueTypeMarker>::borrow),
4838                encoder,
4839                offset + cur_offset,
4840                depth,
4841            )?;
4842
4843            _prev_end_offset = cur_offset + envelope_size;
4844            if 23 > max_ordinal {
4845                return Ok(());
4846            }
4847
4848            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4849            // are envelope_size bytes.
4850            let cur_offset: usize = (23 - 1) * envelope_size;
4851
4852            // Zero reserved fields.
4853            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4854
4855            // Safety:
4856            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4857            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4858            //   envelope_size bytes, there is always sufficient room.
4859            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<InjectedCapabilities>, D>(
4860            self.inject_capabilities.as_ref().map(<fidl::encoding::UnboundedVector<InjectedCapabilities> as fidl::encoding::ValueTypeMarker>::borrow),
4861            encoder, offset + cur_offset, depth
4862        )?;
4863
4864            _prev_end_offset = cur_offset + envelope_size;
4865            if 24 > max_ordinal {
4866                return Ok(());
4867            }
4868
4869            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4870            // are envelope_size bytes.
4871            let cur_offset: usize = (24 - 1) * envelope_size;
4872
4873            // Zero reserved fields.
4874            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4875
4876            // Safety:
4877            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4878            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4879            //   envelope_size bytes, there is always sufficient room.
4880            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
4881                self.scudo_options.as_ref().map(
4882                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
4883                ),
4884                encoder,
4885                offset + cur_offset,
4886                depth,
4887            )?;
4888
4889            _prev_end_offset = cur_offset + envelope_size;
4890
4891            Ok(())
4892        }
4893    }
4894
4895    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Config {
4896        #[inline(always)]
4897        fn new_empty() -> Self {
4898            Self::default()
4899        }
4900
4901        unsafe fn decode(
4902            &mut self,
4903            decoder: &mut fidl::encoding::Decoder<'_, D>,
4904            offset: usize,
4905            mut depth: fidl::encoding::Depth,
4906        ) -> fidl::Result<()> {
4907            decoder.debug_check_bounds::<Self>(offset);
4908            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4909                None => return Err(fidl::Error::NotNullable),
4910                Some(len) => len,
4911            };
4912            // Calling decoder.out_of_line_offset(0) is not allowed.
4913            if len == 0 {
4914                return Ok(());
4915            };
4916            depth.increment()?;
4917            let envelope_size = 8;
4918            let bytes_len = len * envelope_size;
4919            let offset = decoder.out_of_line_offset(bytes_len)?;
4920            // Decode the envelope for each type.
4921            let mut _next_ordinal_to_read = 0;
4922            let mut next_offset = offset;
4923            let end_offset = offset + bytes_len;
4924            _next_ordinal_to_read += 1;
4925            if next_offset >= end_offset {
4926                return Ok(());
4927            }
4928
4929            // Decode unknown envelopes for gaps in ordinals.
4930            while _next_ordinal_to_read < 1 {
4931                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4932                _next_ordinal_to_read += 1;
4933                next_offset += envelope_size;
4934            }
4935
4936            let next_out_of_line = decoder.next_out_of_line();
4937            let handles_before = decoder.remaining_handles();
4938            if let Some((inlined, num_bytes, num_handles)) =
4939                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4940            {
4941                let member_inline_size =
4942                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4943                if inlined != (member_inline_size <= 4) {
4944                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4945                }
4946                let inner_offset;
4947                let mut inner_depth = depth.clone();
4948                if inlined {
4949                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4950                    inner_offset = next_offset;
4951                } else {
4952                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4953                    inner_depth.increment()?;
4954                }
4955                let val_ref = self.debug.get_or_insert_with(|| fidl::new_empty!(bool, D));
4956                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4957                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4958                {
4959                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4960                }
4961                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4962                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4963                }
4964            }
4965
4966            next_offset += envelope_size;
4967            _next_ordinal_to_read += 1;
4968            if next_offset >= end_offset {
4969                return Ok(());
4970            }
4971
4972            // Decode unknown envelopes for gaps in ordinals.
4973            while _next_ordinal_to_read < 2 {
4974                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4975                _next_ordinal_to_read += 1;
4976                next_offset += envelope_size;
4977            }
4978
4979            let next_out_of_line = decoder.next_out_of_line();
4980            let handles_before = decoder.remaining_handles();
4981            if let Some((inlined, num_bytes, num_handles)) =
4982                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4983            {
4984                let member_inline_size =
4985                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4986                if inlined != (member_inline_size <= 4) {
4987                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4988                }
4989                let inner_offset;
4990                let mut inner_depth = depth.clone();
4991                if inlined {
4992                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4993                    inner_offset = next_offset;
4994                } else {
4995                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4996                    inner_depth.increment()?;
4997                }
4998                let val_ref =
4999                    self.list_children_batch_size.get_or_insert_with(|| fidl::new_empty!(u32, D));
5000                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5001                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5002                {
5003                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5004                }
5005                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5006                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5007                }
5008            }
5009
5010            next_offset += envelope_size;
5011            _next_ordinal_to_read += 1;
5012            if next_offset >= end_offset {
5013                return Ok(());
5014            }
5015
5016            // Decode unknown envelopes for gaps in ordinals.
5017            while _next_ordinal_to_read < 3 {
5018                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5019                _next_ordinal_to_read += 1;
5020                next_offset += envelope_size;
5021            }
5022
5023            let next_out_of_line = decoder.next_out_of_line();
5024            let handles_before = decoder.remaining_handles();
5025            if let Some((inlined, num_bytes, num_handles)) =
5026                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5027            {
5028                let member_inline_size =
5029                    <SecurityPolicy as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5030                if inlined != (member_inline_size <= 4) {
5031                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5032                }
5033                let inner_offset;
5034                let mut inner_depth = depth.clone();
5035                if inlined {
5036                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5037                    inner_offset = next_offset;
5038                } else {
5039                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5040                    inner_depth.increment()?;
5041                }
5042                let val_ref =
5043                    self.security_policy.get_or_insert_with(|| fidl::new_empty!(SecurityPolicy, D));
5044                fidl::decode!(SecurityPolicy, D, val_ref, decoder, inner_offset, inner_depth)?;
5045                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5046                {
5047                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5048                }
5049                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5050                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5051                }
5052            }
5053
5054            next_offset += envelope_size;
5055            _next_ordinal_to_read += 1;
5056            if next_offset >= end_offset {
5057                return Ok(());
5058            }
5059
5060            // Decode unknown envelopes for gaps in ordinals.
5061            while _next_ordinal_to_read < 4 {
5062                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5063                _next_ordinal_to_read += 1;
5064                next_offset += envelope_size;
5065            }
5066
5067            let next_out_of_line = decoder.next_out_of_line();
5068            let handles_before = decoder.remaining_handles();
5069            if let Some((inlined, num_bytes, num_handles)) =
5070                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5071            {
5072                let member_inline_size = <fidl::encoding::UnboundedVector<
5073                    fidl_fuchsia_component_decl__common::Capability,
5074                > as fidl::encoding::TypeMarker>::inline_size(
5075                    decoder.context
5076                );
5077                if inlined != (member_inline_size <= 4) {
5078                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5079                }
5080                let inner_offset;
5081                let mut inner_depth = depth.clone();
5082                if inlined {
5083                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5084                    inner_offset = next_offset;
5085                } else {
5086                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5087                    inner_depth.increment()?;
5088                }
5089                let val_ref = self.namespace_capabilities.get_or_insert_with(|| {
5090                    fidl::new_empty!(
5091                        fidl::encoding::UnboundedVector<
5092                            fidl_fuchsia_component_decl__common::Capability,
5093                        >,
5094                        D
5095                    )
5096                });
5097                fidl::decode!(
5098                    fidl::encoding::UnboundedVector<
5099                        fidl_fuchsia_component_decl__common::Capability,
5100                    >,
5101                    D,
5102                    val_ref,
5103                    decoder,
5104                    inner_offset,
5105                    inner_depth
5106                )?;
5107                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5108                {
5109                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5110                }
5111                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5112                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5113                }
5114            }
5115
5116            next_offset += envelope_size;
5117            _next_ordinal_to_read += 1;
5118            if next_offset >= end_offset {
5119                return Ok(());
5120            }
5121
5122            // Decode unknown envelopes for gaps in ordinals.
5123            while _next_ordinal_to_read < 5 {
5124                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5125                _next_ordinal_to_read += 1;
5126                next_offset += envelope_size;
5127            }
5128
5129            let next_out_of_line = decoder.next_out_of_line();
5130            let handles_before = decoder.remaining_handles();
5131            if let Some((inlined, num_bytes, num_handles)) =
5132                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5133            {
5134                let member_inline_size =
5135                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5136                if inlined != (member_inline_size <= 4) {
5137                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5138                }
5139                let inner_offset;
5140                let mut inner_depth = depth.clone();
5141                if inlined {
5142                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5143                    inner_offset = next_offset;
5144                } else {
5145                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5146                    inner_depth.increment()?;
5147                }
5148                let val_ref = self
5149                    .use_builtin_process_launcher
5150                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
5151                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5152                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5153                {
5154                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5155                }
5156                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5157                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5158                }
5159            }
5160
5161            next_offset += envelope_size;
5162            _next_ordinal_to_read += 1;
5163            if next_offset >= end_offset {
5164                return Ok(());
5165            }
5166
5167            // Decode unknown envelopes for gaps in ordinals.
5168            while _next_ordinal_to_read < 6 {
5169                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5170                _next_ordinal_to_read += 1;
5171                next_offset += envelope_size;
5172            }
5173
5174            let next_out_of_line = decoder.next_out_of_line();
5175            let handles_before = decoder.remaining_handles();
5176            if let Some((inlined, num_bytes, num_handles)) =
5177                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5178            {
5179                let member_inline_size =
5180                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5181                if inlined != (member_inline_size <= 4) {
5182                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5183                }
5184                let inner_offset;
5185                let mut inner_depth = depth.clone();
5186                if inlined {
5187                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5188                    inner_offset = next_offset;
5189                } else {
5190                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5191                    inner_depth.increment()?;
5192                }
5193                let val_ref =
5194                    self.maintain_utc_clock.get_or_insert_with(|| fidl::new_empty!(bool, D));
5195                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5196                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5197                {
5198                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5199                }
5200                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5201                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5202                }
5203            }
5204
5205            next_offset += envelope_size;
5206            _next_ordinal_to_read += 1;
5207            if next_offset >= end_offset {
5208                return Ok(());
5209            }
5210
5211            // Decode unknown envelopes for gaps in ordinals.
5212            while _next_ordinal_to_read < 7 {
5213                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5214                _next_ordinal_to_read += 1;
5215                next_offset += envelope_size;
5216            }
5217
5218            let next_out_of_line = decoder.next_out_of_line();
5219            let handles_before = decoder.remaining_handles();
5220            if let Some((inlined, num_bytes, num_handles)) =
5221                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5222            {
5223                let member_inline_size =
5224                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5225                if inlined != (member_inline_size <= 4) {
5226                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5227                }
5228                let inner_offset;
5229                let mut inner_depth = depth.clone();
5230                if inlined {
5231                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5232                    inner_offset = next_offset;
5233                } else {
5234                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5235                    inner_depth.increment()?;
5236                }
5237                let val_ref = self.num_threads.get_or_insert_with(|| fidl::new_empty!(u8, D));
5238                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
5239                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5240                {
5241                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5242                }
5243                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5244                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5245                }
5246            }
5247
5248            next_offset += envelope_size;
5249            _next_ordinal_to_read += 1;
5250            if next_offset >= end_offset {
5251                return Ok(());
5252            }
5253
5254            // Decode unknown envelopes for gaps in ordinals.
5255            while _next_ordinal_to_read < 10 {
5256                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5257                _next_ordinal_to_read += 1;
5258                next_offset += envelope_size;
5259            }
5260
5261            let next_out_of_line = decoder.next_out_of_line();
5262            let handles_before = decoder.remaining_handles();
5263            if let Some((inlined, num_bytes, num_handles)) =
5264                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5265            {
5266                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5267                if inlined != (member_inline_size <= 4) {
5268                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5269                }
5270                let inner_offset;
5271                let mut inner_depth = depth.clone();
5272                if inlined {
5273                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5274                    inner_offset = next_offset;
5275                } else {
5276                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5277                    inner_depth.increment()?;
5278                }
5279                let val_ref = self.root_component_url.get_or_insert_with(|| {
5280                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
5281                });
5282                fidl::decode!(
5283                    fidl::encoding::BoundedString<4096>,
5284                    D,
5285                    val_ref,
5286                    decoder,
5287                    inner_offset,
5288                    inner_depth
5289                )?;
5290                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5291                {
5292                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5293                }
5294                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5295                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5296                }
5297            }
5298
5299            next_offset += envelope_size;
5300            _next_ordinal_to_read += 1;
5301            if next_offset >= end_offset {
5302                return Ok(());
5303            }
5304
5305            // Decode unknown envelopes for gaps in ordinals.
5306            while _next_ordinal_to_read < 11 {
5307                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5308                _next_ordinal_to_read += 1;
5309                next_offset += envelope_size;
5310            }
5311
5312            let next_out_of_line = decoder.next_out_of_line();
5313            let handles_before = decoder.remaining_handles();
5314            if let Some((inlined, num_bytes, num_handles)) =
5315                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5316            {
5317                let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5318                if inlined != (member_inline_size <= 4) {
5319                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5320                }
5321                let inner_offset;
5322                let mut inner_depth = depth.clone();
5323                if inlined {
5324                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5325                    inner_offset = next_offset;
5326                } else {
5327                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5328                    inner_depth.increment()?;
5329                }
5330                let val_ref = self.component_id_index_path.get_or_insert_with(|| {
5331                    fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
5332                });
5333                fidl::decode!(
5334                    fidl::encoding::BoundedString<4095>,
5335                    D,
5336                    val_ref,
5337                    decoder,
5338                    inner_offset,
5339                    inner_depth
5340                )?;
5341                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5342                {
5343                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5344                }
5345                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5346                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5347                }
5348            }
5349
5350            next_offset += envelope_size;
5351            _next_ordinal_to_read += 1;
5352            if next_offset >= end_offset {
5353                return Ok(());
5354            }
5355
5356            // Decode unknown envelopes for gaps in ordinals.
5357            while _next_ordinal_to_read < 12 {
5358                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5359                _next_ordinal_to_read += 1;
5360                next_offset += envelope_size;
5361            }
5362
5363            let next_out_of_line = decoder.next_out_of_line();
5364            let handles_before = decoder.remaining_handles();
5365            if let Some((inlined, num_bytes, num_handles)) =
5366                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5367            {
5368                let member_inline_size =
5369                    <LogDestination as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5370                if inlined != (member_inline_size <= 4) {
5371                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5372                }
5373                let inner_offset;
5374                let mut inner_depth = depth.clone();
5375                if inlined {
5376                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5377                    inner_offset = next_offset;
5378                } else {
5379                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5380                    inner_depth.increment()?;
5381                }
5382                let val_ref =
5383                    self.log_destination.get_or_insert_with(|| fidl::new_empty!(LogDestination, D));
5384                fidl::decode!(LogDestination, D, val_ref, decoder, inner_offset, inner_depth)?;
5385                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5386                {
5387                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5388                }
5389                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5390                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5391                }
5392            }
5393
5394            next_offset += envelope_size;
5395            _next_ordinal_to_read += 1;
5396            if next_offset >= end_offset {
5397                return Ok(());
5398            }
5399
5400            // Decode unknown envelopes for gaps in ordinals.
5401            while _next_ordinal_to_read < 13 {
5402                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5403                _next_ordinal_to_read += 1;
5404                next_offset += envelope_size;
5405            }
5406
5407            let next_out_of_line = decoder.next_out_of_line();
5408            let handles_before = decoder.remaining_handles();
5409            if let Some((inlined, num_bytes, num_handles)) =
5410                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5411            {
5412                let member_inline_size =
5413                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5414                if inlined != (member_inline_size <= 4) {
5415                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5416                }
5417                let inner_offset;
5418                let mut inner_depth = depth.clone();
5419                if inlined {
5420                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5421                    inner_offset = next_offset;
5422                } else {
5423                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5424                    inner_depth.increment()?;
5425                }
5426                let val_ref = self.log_all_events.get_or_insert_with(|| fidl::new_empty!(bool, D));
5427                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5428                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5429                {
5430                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5431                }
5432                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5433                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5434                }
5435            }
5436
5437            next_offset += envelope_size;
5438            _next_ordinal_to_read += 1;
5439            if next_offset >= end_offset {
5440                return Ok(());
5441            }
5442
5443            // Decode unknown envelopes for gaps in ordinals.
5444            while _next_ordinal_to_read < 14 {
5445                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5446                _next_ordinal_to_read += 1;
5447                next_offset += envelope_size;
5448            }
5449
5450            let next_out_of_line = decoder.next_out_of_line();
5451            let handles_before = decoder.remaining_handles();
5452            if let Some((inlined, num_bytes, num_handles)) =
5453                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5454            {
5455                let member_inline_size =
5456                    <BuiltinBootResolver as fidl::encoding::TypeMarker>::inline_size(
5457                        decoder.context,
5458                    );
5459                if inlined != (member_inline_size <= 4) {
5460                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5461                }
5462                let inner_offset;
5463                let mut inner_depth = depth.clone();
5464                if inlined {
5465                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5466                    inner_offset = next_offset;
5467                } else {
5468                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5469                    inner_depth.increment()?;
5470                }
5471                let val_ref = self
5472                    .builtin_boot_resolver
5473                    .get_or_insert_with(|| fidl::new_empty!(BuiltinBootResolver, D));
5474                fidl::decode!(BuiltinBootResolver, D, val_ref, decoder, inner_offset, inner_depth)?;
5475                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5476                {
5477                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5478                }
5479                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5480                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5481                }
5482            }
5483
5484            next_offset += envelope_size;
5485            _next_ordinal_to_read += 1;
5486            if next_offset >= end_offset {
5487                return Ok(());
5488            }
5489
5490            // Decode unknown envelopes for gaps in ordinals.
5491            while _next_ordinal_to_read < 16 {
5492                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5493                _next_ordinal_to_read += 1;
5494                next_offset += envelope_size;
5495            }
5496
5497            let next_out_of_line = decoder.next_out_of_line();
5498            let handles_before = decoder.remaining_handles();
5499            if let Some((inlined, num_bytes, num_handles)) =
5500                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5501            {
5502                let member_inline_size =
5503                    <RealmBuilderResolverAndRunner as fidl::encoding::TypeMarker>::inline_size(
5504                        decoder.context,
5505                    );
5506                if inlined != (member_inline_size <= 4) {
5507                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5508                }
5509                let inner_offset;
5510                let mut inner_depth = depth.clone();
5511                if inlined {
5512                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5513                    inner_offset = next_offset;
5514                } else {
5515                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5516                    inner_depth.increment()?;
5517                }
5518                let val_ref = self
5519                    .realm_builder_resolver_and_runner
5520                    .get_or_insert_with(|| fidl::new_empty!(RealmBuilderResolverAndRunner, D));
5521                fidl::decode!(
5522                    RealmBuilderResolverAndRunner,
5523                    D,
5524                    val_ref,
5525                    decoder,
5526                    inner_offset,
5527                    inner_depth
5528                )?;
5529                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5530                {
5531                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5532                }
5533                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5534                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5535                }
5536            }
5537
5538            next_offset += envelope_size;
5539            _next_ordinal_to_read += 1;
5540            if next_offset >= end_offset {
5541                return Ok(());
5542            }
5543
5544            // Decode unknown envelopes for gaps in ordinals.
5545            while _next_ordinal_to_read < 17 {
5546                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5547                _next_ordinal_to_read += 1;
5548                next_offset += envelope_size;
5549            }
5550
5551            let next_out_of_line = decoder.next_out_of_line();
5552            let handles_before = decoder.remaining_handles();
5553            if let Some((inlined, num_bytes, num_handles)) =
5554                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5555            {
5556                let member_inline_size = <fidl::encoding::UnboundedVector<
5557                    fidl_fuchsia_component_decl__common::Capability,
5558                > as fidl::encoding::TypeMarker>::inline_size(
5559                    decoder.context
5560                );
5561                if inlined != (member_inline_size <= 4) {
5562                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5563                }
5564                let inner_offset;
5565                let mut inner_depth = depth.clone();
5566                if inlined {
5567                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5568                    inner_offset = next_offset;
5569                } else {
5570                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5571                    inner_depth.increment()?;
5572                }
5573                let val_ref = self.builtin_capabilities.get_or_insert_with(|| {
5574                    fidl::new_empty!(
5575                        fidl::encoding::UnboundedVector<
5576                            fidl_fuchsia_component_decl__common::Capability,
5577                        >,
5578                        D
5579                    )
5580                });
5581                fidl::decode!(
5582                    fidl::encoding::UnboundedVector<
5583                        fidl_fuchsia_component_decl__common::Capability,
5584                    >,
5585                    D,
5586                    val_ref,
5587                    decoder,
5588                    inner_offset,
5589                    inner_depth
5590                )?;
5591                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5592                {
5593                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5594                }
5595                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5596                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5597                }
5598            }
5599
5600            next_offset += envelope_size;
5601            _next_ordinal_to_read += 1;
5602            if next_offset >= end_offset {
5603                return Ok(());
5604            }
5605
5606            // Decode unknown envelopes for gaps in ordinals.
5607            while _next_ordinal_to_read < 18 {
5608                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5609                _next_ordinal_to_read += 1;
5610                next_offset += envelope_size;
5611            }
5612
5613            let next_out_of_line = decoder.next_out_of_line();
5614            let handles_before = decoder.remaining_handles();
5615            if let Some((inlined, num_bytes, num_handles)) =
5616                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5617            {
5618                let member_inline_size =
5619                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5620                if inlined != (member_inline_size <= 4) {
5621                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5622                }
5623                let inner_offset;
5624                let mut inner_depth = depth.clone();
5625                if inlined {
5626                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5627                    inner_offset = next_offset;
5628                } else {
5629                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5630                    inner_depth.increment()?;
5631                }
5632                let val_ref =
5633                    self.enable_introspection.get_or_insert_with(|| fidl::new_empty!(bool, D));
5634                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5635                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5636                {
5637                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5638                }
5639                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5640                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5641                }
5642            }
5643
5644            next_offset += envelope_size;
5645            _next_ordinal_to_read += 1;
5646            if next_offset >= end_offset {
5647                return Ok(());
5648            }
5649
5650            // Decode unknown envelopes for gaps in ordinals.
5651            while _next_ordinal_to_read < 19 {
5652                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5653                _next_ordinal_to_read += 1;
5654                next_offset += envelope_size;
5655            }
5656
5657            let next_out_of_line = decoder.next_out_of_line();
5658            let handles_before = decoder.remaining_handles();
5659            if let Some((inlined, num_bytes, num_handles)) =
5660                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5661            {
5662                let member_inline_size =
5663                    <AbiRevisionPolicy as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5664                if inlined != (member_inline_size <= 4) {
5665                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5666                }
5667                let inner_offset;
5668                let mut inner_depth = depth.clone();
5669                if inlined {
5670                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5671                    inner_offset = next_offset;
5672                } else {
5673                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5674                    inner_depth.increment()?;
5675                }
5676                let val_ref = self
5677                    .abi_revision_policy
5678                    .get_or_insert_with(|| fidl::new_empty!(AbiRevisionPolicy, D));
5679                fidl::decode!(AbiRevisionPolicy, D, val_ref, decoder, inner_offset, inner_depth)?;
5680                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5681                {
5682                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5683                }
5684                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5685                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5686                }
5687            }
5688
5689            next_offset += envelope_size;
5690            _next_ordinal_to_read += 1;
5691            if next_offset >= end_offset {
5692                return Ok(());
5693            }
5694
5695            // Decode unknown envelopes for gaps in ordinals.
5696            while _next_ordinal_to_read < 20 {
5697                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5698                _next_ordinal_to_read += 1;
5699                next_offset += envelope_size;
5700            }
5701
5702            let next_out_of_line = decoder.next_out_of_line();
5703            let handles_before = decoder.remaining_handles();
5704            if let Some((inlined, num_bytes, num_handles)) =
5705                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5706            {
5707                let member_inline_size =
5708                    <VmexSource as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5709                if inlined != (member_inline_size <= 4) {
5710                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5711                }
5712                let inner_offset;
5713                let mut inner_depth = depth.clone();
5714                if inlined {
5715                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5716                    inner_offset = next_offset;
5717                } else {
5718                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5719                    inner_depth.increment()?;
5720                }
5721                let val_ref =
5722                    self.vmex_source.get_or_insert_with(|| fidl::new_empty!(VmexSource, D));
5723                fidl::decode!(VmexSource, D, val_ref, decoder, inner_offset, inner_depth)?;
5724                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5725                {
5726                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5727                }
5728                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5729                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5730                }
5731            }
5732
5733            next_offset += envelope_size;
5734            _next_ordinal_to_read += 1;
5735            if next_offset >= end_offset {
5736                return Ok(());
5737            }
5738
5739            // Decode unknown envelopes for gaps in ordinals.
5740            while _next_ordinal_to_read < 21 {
5741                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5742                _next_ordinal_to_read += 1;
5743                next_offset += envelope_size;
5744            }
5745
5746            let next_out_of_line = decoder.next_out_of_line();
5747            let handles_before = decoder.remaining_handles();
5748            if let Some((inlined, num_bytes, num_handles)) =
5749                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5750            {
5751                let member_inline_size =
5752                    <HealthCheck as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5753                if inlined != (member_inline_size <= 4) {
5754                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5755                }
5756                let inner_offset;
5757                let mut inner_depth = depth.clone();
5758                if inlined {
5759                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5760                    inner_offset = next_offset;
5761                } else {
5762                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5763                    inner_depth.increment()?;
5764                }
5765                let val_ref =
5766                    self.health_check.get_or_insert_with(|| fidl::new_empty!(HealthCheck, D));
5767                fidl::decode!(HealthCheck, D, val_ref, decoder, inner_offset, inner_depth)?;
5768                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5769                {
5770                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5771                }
5772                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5773                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5774                }
5775            }
5776
5777            next_offset += envelope_size;
5778            _next_ordinal_to_read += 1;
5779            if next_offset >= end_offset {
5780                return Ok(());
5781            }
5782
5783            // Decode unknown envelopes for gaps in ordinals.
5784            while _next_ordinal_to_read < 22 {
5785                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5786                _next_ordinal_to_read += 1;
5787                next_offset += envelope_size;
5788            }
5789
5790            let next_out_of_line = decoder.next_out_of_line();
5791            let handles_before = decoder.remaining_handles();
5792            if let Some((inlined, num_bytes, num_handles)) =
5793                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5794            {
5795                let member_inline_size =
5796                    <TraceProvider as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5797                if inlined != (member_inline_size <= 4) {
5798                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5799                }
5800                let inner_offset;
5801                let mut inner_depth = depth.clone();
5802                if inlined {
5803                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5804                    inner_offset = next_offset;
5805                } else {
5806                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5807                    inner_depth.increment()?;
5808                }
5809                let val_ref =
5810                    self.trace_provider.get_or_insert_with(|| fidl::new_empty!(TraceProvider, D));
5811                fidl::decode!(TraceProvider, D, val_ref, decoder, inner_offset, inner_depth)?;
5812                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5813                {
5814                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5815                }
5816                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5817                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5818                }
5819            }
5820
5821            next_offset += envelope_size;
5822            _next_ordinal_to_read += 1;
5823            if next_offset >= end_offset {
5824                return Ok(());
5825            }
5826
5827            // Decode unknown envelopes for gaps in ordinals.
5828            while _next_ordinal_to_read < 23 {
5829                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5830                _next_ordinal_to_read += 1;
5831                next_offset += envelope_size;
5832            }
5833
5834            let next_out_of_line = decoder.next_out_of_line();
5835            let handles_before = decoder.remaining_handles();
5836            if let Some((inlined, num_bytes, num_handles)) =
5837                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5838            {
5839                let member_inline_size = <fidl::encoding::UnboundedVector<InjectedCapabilities> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5840                if inlined != (member_inline_size <= 4) {
5841                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5842                }
5843                let inner_offset;
5844                let mut inner_depth = depth.clone();
5845                if inlined {
5846                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5847                    inner_offset = next_offset;
5848                } else {
5849                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5850                    inner_depth.increment()?;
5851                }
5852                let val_ref = self.inject_capabilities.get_or_insert_with(|| {
5853                    fidl::new_empty!(fidl::encoding::UnboundedVector<InjectedCapabilities>, D)
5854                });
5855                fidl::decode!(
5856                    fidl::encoding::UnboundedVector<InjectedCapabilities>,
5857                    D,
5858                    val_ref,
5859                    decoder,
5860                    inner_offset,
5861                    inner_depth
5862                )?;
5863                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5864                {
5865                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5866                }
5867                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5868                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5869                }
5870            }
5871
5872            next_offset += envelope_size;
5873            _next_ordinal_to_read += 1;
5874            if next_offset >= end_offset {
5875                return Ok(());
5876            }
5877
5878            // Decode unknown envelopes for gaps in ordinals.
5879            while _next_ordinal_to_read < 24 {
5880                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5881                _next_ordinal_to_read += 1;
5882                next_offset += envelope_size;
5883            }
5884
5885            let next_out_of_line = decoder.next_out_of_line();
5886            let handles_before = decoder.remaining_handles();
5887            if let Some((inlined, num_bytes, num_handles)) =
5888                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5889            {
5890                let member_inline_size =
5891                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
5892                        decoder.context,
5893                    );
5894                if inlined != (member_inline_size <= 4) {
5895                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5896                }
5897                let inner_offset;
5898                let mut inner_depth = depth.clone();
5899                if inlined {
5900                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5901                    inner_offset = next_offset;
5902                } else {
5903                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5904                    inner_depth.increment()?;
5905                }
5906                let val_ref = self
5907                    .scudo_options
5908                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
5909                fidl::decode!(
5910                    fidl::encoding::UnboundedString,
5911                    D,
5912                    val_ref,
5913                    decoder,
5914                    inner_offset,
5915                    inner_depth
5916                )?;
5917                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5918                {
5919                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5920                }
5921                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5922                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5923                }
5924            }
5925
5926            next_offset += envelope_size;
5927
5928            // Decode the remaining unknown envelopes.
5929            while next_offset < end_offset {
5930                _next_ordinal_to_read += 1;
5931                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5932                next_offset += envelope_size;
5933            }
5934
5935            Ok(())
5936        }
5937    }
5938
5939    impl DebugRegistrationAllowlistEntry {
5940        #[inline(always)]
5941        fn max_ordinal_present(&self) -> u64 {
5942            if let Some(_) = self.environment_name {
5943                return 4;
5944            }
5945            if let Some(_) = self.moniker {
5946                return 3;
5947            }
5948            if let Some(_) = self.debug {
5949                return 2;
5950            }
5951            if let Some(_) = self.name {
5952                return 1;
5953            }
5954            0
5955        }
5956    }
5957
5958    impl fidl::encoding::ValueTypeMarker for DebugRegistrationAllowlistEntry {
5959        type Borrowed<'a> = &'a Self;
5960        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5961            value
5962        }
5963    }
5964
5965    unsafe impl fidl::encoding::TypeMarker for DebugRegistrationAllowlistEntry {
5966        type Owned = Self;
5967
5968        #[inline(always)]
5969        fn inline_align(_context: fidl::encoding::Context) -> usize {
5970            8
5971        }
5972
5973        #[inline(always)]
5974        fn inline_size(_context: fidl::encoding::Context) -> usize {
5975            16
5976        }
5977    }
5978
5979    unsafe impl<D: fidl::encoding::ResourceDialect>
5980        fidl::encoding::Encode<DebugRegistrationAllowlistEntry, D>
5981        for &DebugRegistrationAllowlistEntry
5982    {
5983        unsafe fn encode(
5984            self,
5985            encoder: &mut fidl::encoding::Encoder<'_, D>,
5986            offset: usize,
5987            mut depth: fidl::encoding::Depth,
5988        ) -> fidl::Result<()> {
5989            encoder.debug_check_bounds::<DebugRegistrationAllowlistEntry>(offset);
5990            // Vector header
5991            let max_ordinal: u64 = self.max_ordinal_present();
5992            encoder.write_num(max_ordinal, offset);
5993            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5994            // Calling encoder.out_of_line_offset(0) is not allowed.
5995            if max_ordinal == 0 {
5996                return Ok(());
5997            }
5998            depth.increment()?;
5999            let envelope_size = 8;
6000            let bytes_len = max_ordinal as usize * envelope_size;
6001            #[allow(unused_variables)]
6002            let offset = encoder.out_of_line_offset(bytes_len);
6003            let mut _prev_end_offset: usize = 0;
6004            if 1 > max_ordinal {
6005                return Ok(());
6006            }
6007
6008            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6009            // are envelope_size bytes.
6010            let cur_offset: usize = (1 - 1) * envelope_size;
6011
6012            // Zero reserved fields.
6013            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6014
6015            // Safety:
6016            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6017            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6018            //   envelope_size bytes, there is always sufficient room.
6019            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
6020                self.name.as_ref().map(
6021                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
6022                ),
6023                encoder,
6024                offset + cur_offset,
6025                depth,
6026            )?;
6027
6028            _prev_end_offset = cur_offset + envelope_size;
6029            if 2 > max_ordinal {
6030                return Ok(());
6031            }
6032
6033            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6034            // are envelope_size bytes.
6035            let cur_offset: usize = (2 - 1) * envelope_size;
6036
6037            // Zero reserved fields.
6038            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6039
6040            // Safety:
6041            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6042            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6043            //   envelope_size bytes, there is always sufficient room.
6044            fidl::encoding::encode_in_envelope_optional::<AllowlistedDebugRegistration, D>(
6045                self.debug
6046                    .as_ref()
6047                    .map(<AllowlistedDebugRegistration as fidl::encoding::ValueTypeMarker>::borrow),
6048                encoder,
6049                offset + cur_offset,
6050                depth,
6051            )?;
6052
6053            _prev_end_offset = cur_offset + envelope_size;
6054            if 3 > max_ordinal {
6055                return Ok(());
6056            }
6057
6058            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6059            // are envelope_size bytes.
6060            let cur_offset: usize = (3 - 1) * envelope_size;
6061
6062            // Zero reserved fields.
6063            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6064
6065            // Safety:
6066            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6067            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6068            //   envelope_size bytes, there is always sufficient room.
6069            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6070            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6071            encoder, offset + cur_offset, depth
6072        )?;
6073
6074            _prev_end_offset = cur_offset + envelope_size;
6075            if 4 > max_ordinal {
6076                return Ok(());
6077            }
6078
6079            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6080            // are envelope_size bytes.
6081            let cur_offset: usize = (4 - 1) * envelope_size;
6082
6083            // Zero reserved fields.
6084            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6085
6086            // Safety:
6087            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6088            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6089            //   envelope_size bytes, there is always sufficient room.
6090            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
6091                self.environment_name.as_ref().map(
6092                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
6093                ),
6094                encoder,
6095                offset + cur_offset,
6096                depth,
6097            )?;
6098
6099            _prev_end_offset = cur_offset + envelope_size;
6100
6101            Ok(())
6102        }
6103    }
6104
6105    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6106        for DebugRegistrationAllowlistEntry
6107    {
6108        #[inline(always)]
6109        fn new_empty() -> Self {
6110            Self::default()
6111        }
6112
6113        unsafe fn decode(
6114            &mut self,
6115            decoder: &mut fidl::encoding::Decoder<'_, D>,
6116            offset: usize,
6117            mut depth: fidl::encoding::Depth,
6118        ) -> fidl::Result<()> {
6119            decoder.debug_check_bounds::<Self>(offset);
6120            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6121                None => return Err(fidl::Error::NotNullable),
6122                Some(len) => len,
6123            };
6124            // Calling decoder.out_of_line_offset(0) is not allowed.
6125            if len == 0 {
6126                return Ok(());
6127            };
6128            depth.increment()?;
6129            let envelope_size = 8;
6130            let bytes_len = len * envelope_size;
6131            let offset = decoder.out_of_line_offset(bytes_len)?;
6132            // Decode the envelope for each type.
6133            let mut _next_ordinal_to_read = 0;
6134            let mut next_offset = offset;
6135            let end_offset = offset + bytes_len;
6136            _next_ordinal_to_read += 1;
6137            if next_offset >= end_offset {
6138                return Ok(());
6139            }
6140
6141            // Decode unknown envelopes for gaps in ordinals.
6142            while _next_ordinal_to_read < 1 {
6143                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6144                _next_ordinal_to_read += 1;
6145                next_offset += envelope_size;
6146            }
6147
6148            let next_out_of_line = decoder.next_out_of_line();
6149            let handles_before = decoder.remaining_handles();
6150            if let Some((inlined, num_bytes, num_handles)) =
6151                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6152            {
6153                let member_inline_size =
6154                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6155                        decoder.context,
6156                    );
6157                if inlined != (member_inline_size <= 4) {
6158                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6159                }
6160                let inner_offset;
6161                let mut inner_depth = depth.clone();
6162                if inlined {
6163                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6164                    inner_offset = next_offset;
6165                } else {
6166                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6167                    inner_depth.increment()?;
6168                }
6169                let val_ref = self
6170                    .name
6171                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6172                fidl::decode!(
6173                    fidl::encoding::BoundedString<255>,
6174                    D,
6175                    val_ref,
6176                    decoder,
6177                    inner_offset,
6178                    inner_depth
6179                )?;
6180                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6181                {
6182                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6183                }
6184                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6185                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6186                }
6187            }
6188
6189            next_offset += envelope_size;
6190            _next_ordinal_to_read += 1;
6191            if next_offset >= end_offset {
6192                return Ok(());
6193            }
6194
6195            // Decode unknown envelopes for gaps in ordinals.
6196            while _next_ordinal_to_read < 2 {
6197                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6198                _next_ordinal_to_read += 1;
6199                next_offset += envelope_size;
6200            }
6201
6202            let next_out_of_line = decoder.next_out_of_line();
6203            let handles_before = decoder.remaining_handles();
6204            if let Some((inlined, num_bytes, num_handles)) =
6205                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6206            {
6207                let member_inline_size =
6208                    <AllowlistedDebugRegistration as fidl::encoding::TypeMarker>::inline_size(
6209                        decoder.context,
6210                    );
6211                if inlined != (member_inline_size <= 4) {
6212                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6213                }
6214                let inner_offset;
6215                let mut inner_depth = depth.clone();
6216                if inlined {
6217                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6218                    inner_offset = next_offset;
6219                } else {
6220                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6221                    inner_depth.increment()?;
6222                }
6223                let val_ref = self
6224                    .debug
6225                    .get_or_insert_with(|| fidl::new_empty!(AllowlistedDebugRegistration, D));
6226                fidl::decode!(
6227                    AllowlistedDebugRegistration,
6228                    D,
6229                    val_ref,
6230                    decoder,
6231                    inner_offset,
6232                    inner_depth
6233                )?;
6234                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6235                {
6236                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6237                }
6238                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6239                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6240                }
6241            }
6242
6243            next_offset += envelope_size;
6244            _next_ordinal_to_read += 1;
6245            if next_offset >= end_offset {
6246                return Ok(());
6247            }
6248
6249            // Decode unknown envelopes for gaps in ordinals.
6250            while _next_ordinal_to_read < 3 {
6251                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6252                _next_ordinal_to_read += 1;
6253                next_offset += envelope_size;
6254            }
6255
6256            let next_out_of_line = decoder.next_out_of_line();
6257            let handles_before = decoder.remaining_handles();
6258            if let Some((inlined, num_bytes, num_handles)) =
6259                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6260            {
6261                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6262                if inlined != (member_inline_size <= 4) {
6263                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6264                }
6265                let inner_offset;
6266                let mut inner_depth = depth.clone();
6267                if inlined {
6268                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6269                    inner_offset = next_offset;
6270                } else {
6271                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6272                    inner_depth.increment()?;
6273                }
6274                let val_ref = self.moniker.get_or_insert_with(|| {
6275                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
6276                });
6277                fidl::decode!(
6278                    fidl::encoding::BoundedString<4096>,
6279                    D,
6280                    val_ref,
6281                    decoder,
6282                    inner_offset,
6283                    inner_depth
6284                )?;
6285                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6286                {
6287                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6288                }
6289                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6290                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6291                }
6292            }
6293
6294            next_offset += envelope_size;
6295            _next_ordinal_to_read += 1;
6296            if next_offset >= end_offset {
6297                return Ok(());
6298            }
6299
6300            // Decode unknown envelopes for gaps in ordinals.
6301            while _next_ordinal_to_read < 4 {
6302                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6303                _next_ordinal_to_read += 1;
6304                next_offset += envelope_size;
6305            }
6306
6307            let next_out_of_line = decoder.next_out_of_line();
6308            let handles_before = decoder.remaining_handles();
6309            if let Some((inlined, num_bytes, num_handles)) =
6310                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6311            {
6312                let member_inline_size =
6313                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6314                        decoder.context,
6315                    );
6316                if inlined != (member_inline_size <= 4) {
6317                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6318                }
6319                let inner_offset;
6320                let mut inner_depth = depth.clone();
6321                if inlined {
6322                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6323                    inner_offset = next_offset;
6324                } else {
6325                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6326                    inner_depth.increment()?;
6327                }
6328                let val_ref = self
6329                    .environment_name
6330                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6331                fidl::decode!(
6332                    fidl::encoding::BoundedString<255>,
6333                    D,
6334                    val_ref,
6335                    decoder,
6336                    inner_offset,
6337                    inner_depth
6338                )?;
6339                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6340                {
6341                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6342                }
6343                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6344                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6345                }
6346            }
6347
6348            next_offset += envelope_size;
6349
6350            // Decode the remaining unknown envelopes.
6351            while next_offset < end_offset {
6352                _next_ordinal_to_read += 1;
6353                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6354                next_offset += envelope_size;
6355            }
6356
6357            Ok(())
6358        }
6359    }
6360
6361    impl DebugRegistrationPolicyAllowlists {
6362        #[inline(always)]
6363        fn max_ordinal_present(&self) -> u64 {
6364            if let Some(_) = self.allowlist {
6365                return 1;
6366            }
6367            0
6368        }
6369    }
6370
6371    impl fidl::encoding::ValueTypeMarker for DebugRegistrationPolicyAllowlists {
6372        type Borrowed<'a> = &'a Self;
6373        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6374            value
6375        }
6376    }
6377
6378    unsafe impl fidl::encoding::TypeMarker for DebugRegistrationPolicyAllowlists {
6379        type Owned = Self;
6380
6381        #[inline(always)]
6382        fn inline_align(_context: fidl::encoding::Context) -> usize {
6383            8
6384        }
6385
6386        #[inline(always)]
6387        fn inline_size(_context: fidl::encoding::Context) -> usize {
6388            16
6389        }
6390    }
6391
6392    unsafe impl<D: fidl::encoding::ResourceDialect>
6393        fidl::encoding::Encode<DebugRegistrationPolicyAllowlists, D>
6394        for &DebugRegistrationPolicyAllowlists
6395    {
6396        unsafe fn encode(
6397            self,
6398            encoder: &mut fidl::encoding::Encoder<'_, D>,
6399            offset: usize,
6400            mut depth: fidl::encoding::Depth,
6401        ) -> fidl::Result<()> {
6402            encoder.debug_check_bounds::<DebugRegistrationPolicyAllowlists>(offset);
6403            // Vector header
6404            let max_ordinal: u64 = self.max_ordinal_present();
6405            encoder.write_num(max_ordinal, offset);
6406            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6407            // Calling encoder.out_of_line_offset(0) is not allowed.
6408            if max_ordinal == 0 {
6409                return Ok(());
6410            }
6411            depth.increment()?;
6412            let envelope_size = 8;
6413            let bytes_len = max_ordinal as usize * envelope_size;
6414            #[allow(unused_variables)]
6415            let offset = encoder.out_of_line_offset(bytes_len);
6416            let mut _prev_end_offset: usize = 0;
6417            if 1 > max_ordinal {
6418                return Ok(());
6419            }
6420
6421            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6422            // are envelope_size bytes.
6423            let cur_offset: usize = (1 - 1) * envelope_size;
6424
6425            // Zero reserved fields.
6426            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6427
6428            // Safety:
6429            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6430            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6431            //   envelope_size bytes, there is always sufficient room.
6432            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128>, D>(
6433            self.allowlist.as_ref().map(<fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128> as fidl::encoding::ValueTypeMarker>::borrow),
6434            encoder, offset + cur_offset, depth
6435        )?;
6436
6437            _prev_end_offset = cur_offset + envelope_size;
6438
6439            Ok(())
6440        }
6441    }
6442
6443    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6444        for DebugRegistrationPolicyAllowlists
6445    {
6446        #[inline(always)]
6447        fn new_empty() -> Self {
6448            Self::default()
6449        }
6450
6451        unsafe fn decode(
6452            &mut self,
6453            decoder: &mut fidl::encoding::Decoder<'_, D>,
6454            offset: usize,
6455            mut depth: fidl::encoding::Depth,
6456        ) -> fidl::Result<()> {
6457            decoder.debug_check_bounds::<Self>(offset);
6458            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6459                None => return Err(fidl::Error::NotNullable),
6460                Some(len) => len,
6461            };
6462            // Calling decoder.out_of_line_offset(0) is not allowed.
6463            if len == 0 {
6464                return Ok(());
6465            };
6466            depth.increment()?;
6467            let envelope_size = 8;
6468            let bytes_len = len * envelope_size;
6469            let offset = decoder.out_of_line_offset(bytes_len)?;
6470            // Decode the envelope for each type.
6471            let mut _next_ordinal_to_read = 0;
6472            let mut next_offset = offset;
6473            let end_offset = offset + bytes_len;
6474            _next_ordinal_to_read += 1;
6475            if next_offset >= end_offset {
6476                return Ok(());
6477            }
6478
6479            // Decode unknown envelopes for gaps in ordinals.
6480            while _next_ordinal_to_read < 1 {
6481                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6482                _next_ordinal_to_read += 1;
6483                next_offset += envelope_size;
6484            }
6485
6486            let next_out_of_line = decoder.next_out_of_line();
6487            let handles_before = decoder.remaining_handles();
6488            if let Some((inlined, num_bytes, num_handles)) =
6489                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6490            {
6491                let member_inline_size = <fidl::encoding::Vector<
6492                    DebugRegistrationAllowlistEntry,
6493                    128,
6494                > as fidl::encoding::TypeMarker>::inline_size(
6495                    decoder.context
6496                );
6497                if inlined != (member_inline_size <= 4) {
6498                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6499                }
6500                let inner_offset;
6501                let mut inner_depth = depth.clone();
6502                if inlined {
6503                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6504                    inner_offset = next_offset;
6505                } else {
6506                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6507                    inner_depth.increment()?;
6508                }
6509                let val_ref =
6510                self.allowlist.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128>, D));
6511                fidl::decode!(fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128>, D, val_ref, decoder, inner_offset, inner_depth)?;
6512                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6513                {
6514                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6515                }
6516                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6517                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6518                }
6519            }
6520
6521            next_offset += envelope_size;
6522
6523            // Decode the remaining unknown envelopes.
6524            while next_offset < end_offset {
6525                _next_ordinal_to_read += 1;
6526                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6527                next_offset += envelope_size;
6528            }
6529
6530            Ok(())
6531        }
6532    }
6533
6534    impl Environment {
6535        #[inline(always)]
6536        fn max_ordinal_present(&self) -> u64 {
6537            if let Some(_) = self.moniker {
6538                return 2;
6539            }
6540            if let Some(_) = self.capability {
6541                return 1;
6542            }
6543            0
6544        }
6545    }
6546
6547    impl fidl::encoding::ValueTypeMarker for Environment {
6548        type Borrowed<'a> = &'a Self;
6549        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6550            value
6551        }
6552    }
6553
6554    unsafe impl fidl::encoding::TypeMarker for Environment {
6555        type Owned = Self;
6556
6557        #[inline(always)]
6558        fn inline_align(_context: fidl::encoding::Context) -> usize {
6559            8
6560        }
6561
6562        #[inline(always)]
6563        fn inline_size(_context: fidl::encoding::Context) -> usize {
6564            16
6565        }
6566    }
6567
6568    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Environment, D>
6569        for &Environment
6570    {
6571        unsafe fn encode(
6572            self,
6573            encoder: &mut fidl::encoding::Encoder<'_, D>,
6574            offset: usize,
6575            mut depth: fidl::encoding::Depth,
6576        ) -> fidl::Result<()> {
6577            encoder.debug_check_bounds::<Environment>(offset);
6578            // Vector header
6579            let max_ordinal: u64 = self.max_ordinal_present();
6580            encoder.write_num(max_ordinal, offset);
6581            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6582            // Calling encoder.out_of_line_offset(0) is not allowed.
6583            if max_ordinal == 0 {
6584                return Ok(());
6585            }
6586            depth.increment()?;
6587            let envelope_size = 8;
6588            let bytes_len = max_ordinal as usize * envelope_size;
6589            #[allow(unused_variables)]
6590            let offset = encoder.out_of_line_offset(bytes_len);
6591            let mut _prev_end_offset: usize = 0;
6592            if 1 > max_ordinal {
6593                return Ok(());
6594            }
6595
6596            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6597            // are envelope_size bytes.
6598            let cur_offset: usize = (1 - 1) * envelope_size;
6599
6600            // Zero reserved fields.
6601            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6602
6603            // Safety:
6604            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6605            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6606            //   envelope_size bytes, there is always sufficient room.
6607            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
6608                self.capability
6609                    .as_ref()
6610                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
6611                encoder,
6612                offset + cur_offset,
6613                depth,
6614            )?;
6615
6616            _prev_end_offset = cur_offset + envelope_size;
6617            if 2 > max_ordinal {
6618                return Ok(());
6619            }
6620
6621            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6622            // are envelope_size bytes.
6623            let cur_offset: usize = (2 - 1) * envelope_size;
6624
6625            // Zero reserved fields.
6626            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6627
6628            // Safety:
6629            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6630            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6631            //   envelope_size bytes, there is always sufficient room.
6632            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6633            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6634            encoder, offset + cur_offset, depth
6635        )?;
6636
6637            _prev_end_offset = cur_offset + envelope_size;
6638
6639            Ok(())
6640        }
6641    }
6642
6643    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Environment {
6644        #[inline(always)]
6645        fn new_empty() -> Self {
6646            Self::default()
6647        }
6648
6649        unsafe fn decode(
6650            &mut self,
6651            decoder: &mut fidl::encoding::Decoder<'_, D>,
6652            offset: usize,
6653            mut depth: fidl::encoding::Depth,
6654        ) -> fidl::Result<()> {
6655            decoder.debug_check_bounds::<Self>(offset);
6656            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6657                None => return Err(fidl::Error::NotNullable),
6658                Some(len) => len,
6659            };
6660            // Calling decoder.out_of_line_offset(0) is not allowed.
6661            if len == 0 {
6662                return Ok(());
6663            };
6664            depth.increment()?;
6665            let envelope_size = 8;
6666            let bytes_len = len * envelope_size;
6667            let offset = decoder.out_of_line_offset(bytes_len)?;
6668            // Decode the envelope for each type.
6669            let mut _next_ordinal_to_read = 0;
6670            let mut next_offset = offset;
6671            let end_offset = offset + bytes_len;
6672            _next_ordinal_to_read += 1;
6673            if next_offset >= end_offset {
6674                return Ok(());
6675            }
6676
6677            // Decode unknown envelopes for gaps in ordinals.
6678            while _next_ordinal_to_read < 1 {
6679                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6680                _next_ordinal_to_read += 1;
6681                next_offset += envelope_size;
6682            }
6683
6684            let next_out_of_line = decoder.next_out_of_line();
6685            let handles_before = decoder.remaining_handles();
6686            if let Some((inlined, num_bytes, num_handles)) =
6687                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6688            {
6689                let member_inline_size =
6690                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
6691                        decoder.context,
6692                    );
6693                if inlined != (member_inline_size <= 4) {
6694                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6695                }
6696                let inner_offset;
6697                let mut inner_depth = depth.clone();
6698                if inlined {
6699                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6700                    inner_offset = next_offset;
6701                } else {
6702                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6703                    inner_depth.increment()?;
6704                }
6705                let val_ref =
6706                    self.capability.get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
6707                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
6708                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6709                {
6710                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6711                }
6712                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6713                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6714                }
6715            }
6716
6717            next_offset += envelope_size;
6718            _next_ordinal_to_read += 1;
6719            if next_offset >= end_offset {
6720                return Ok(());
6721            }
6722
6723            // Decode unknown envelopes for gaps in ordinals.
6724            while _next_ordinal_to_read < 2 {
6725                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6726                _next_ordinal_to_read += 1;
6727                next_offset += envelope_size;
6728            }
6729
6730            let next_out_of_line = decoder.next_out_of_line();
6731            let handles_before = decoder.remaining_handles();
6732            if let Some((inlined, num_bytes, num_handles)) =
6733                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6734            {
6735                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6736                if inlined != (member_inline_size <= 4) {
6737                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6738                }
6739                let inner_offset;
6740                let mut inner_depth = depth.clone();
6741                if inlined {
6742                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6743                    inner_offset = next_offset;
6744                } else {
6745                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6746                    inner_depth.increment()?;
6747                }
6748                let val_ref = self.moniker.get_or_insert_with(|| {
6749                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
6750                });
6751                fidl::decode!(
6752                    fidl::encoding::BoundedString<4096>,
6753                    D,
6754                    val_ref,
6755                    decoder,
6756                    inner_offset,
6757                    inner_depth
6758                )?;
6759                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6760                {
6761                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6762                }
6763                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6764                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6765                }
6766            }
6767
6768            next_offset += envelope_size;
6769
6770            // Decode the remaining unknown envelopes.
6771            while next_offset < end_offset {
6772                _next_ordinal_to_read += 1;
6773                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6774                next_offset += envelope_size;
6775            }
6776
6777            Ok(())
6778        }
6779    }
6780
6781    impl EnvironmentSource {
6782        #[inline(always)]
6783        fn max_ordinal_present(&self) -> u64 {
6784            if let Some(_) = self.source {
6785                return 2;
6786            }
6787            if let Some(_) = self.source_name {
6788                return 1;
6789            }
6790            0
6791        }
6792    }
6793
6794    impl fidl::encoding::ValueTypeMarker for EnvironmentSource {
6795        type Borrowed<'a> = &'a Self;
6796        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6797            value
6798        }
6799    }
6800
6801    unsafe impl fidl::encoding::TypeMarker for EnvironmentSource {
6802        type Owned = Self;
6803
6804        #[inline(always)]
6805        fn inline_align(_context: fidl::encoding::Context) -> usize {
6806            8
6807        }
6808
6809        #[inline(always)]
6810        fn inline_size(_context: fidl::encoding::Context) -> usize {
6811            16
6812        }
6813    }
6814
6815    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnvironmentSource, D>
6816        for &EnvironmentSource
6817    {
6818        unsafe fn encode(
6819            self,
6820            encoder: &mut fidl::encoding::Encoder<'_, D>,
6821            offset: usize,
6822            mut depth: fidl::encoding::Depth,
6823        ) -> fidl::Result<()> {
6824            encoder.debug_check_bounds::<EnvironmentSource>(offset);
6825            // Vector header
6826            let max_ordinal: u64 = self.max_ordinal_present();
6827            encoder.write_num(max_ordinal, offset);
6828            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6829            // Calling encoder.out_of_line_offset(0) is not allowed.
6830            if max_ordinal == 0 {
6831                return Ok(());
6832            }
6833            depth.increment()?;
6834            let envelope_size = 8;
6835            let bytes_len = max_ordinal as usize * envelope_size;
6836            #[allow(unused_variables)]
6837            let offset = encoder.out_of_line_offset(bytes_len);
6838            let mut _prev_end_offset: usize = 0;
6839            if 1 > 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 = (1 - 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<1024>, D>(
6855            self.source_name.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
6856            encoder, offset + cur_offset, depth
6857        )?;
6858
6859            _prev_end_offset = cur_offset + envelope_size;
6860            if 2 > 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 = (2 - 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::<fidl_fuchsia_component_decl__common::Ref, D>(
6876            self.source.as_ref().map(<fidl_fuchsia_component_decl__common::Ref as fidl::encoding::ValueTypeMarker>::borrow),
6877            encoder, offset + cur_offset, depth
6878        )?;
6879
6880            _prev_end_offset = cur_offset + envelope_size;
6881
6882            Ok(())
6883        }
6884    }
6885
6886    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnvironmentSource {
6887        #[inline(always)]
6888        fn new_empty() -> Self {
6889            Self::default()
6890        }
6891
6892        unsafe fn decode(
6893            &mut self,
6894            decoder: &mut fidl::encoding::Decoder<'_, D>,
6895            offset: usize,
6896            mut depth: fidl::encoding::Depth,
6897        ) -> fidl::Result<()> {
6898            decoder.debug_check_bounds::<Self>(offset);
6899            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6900                None => return Err(fidl::Error::NotNullable),
6901                Some(len) => len,
6902            };
6903            // Calling decoder.out_of_line_offset(0) is not allowed.
6904            if len == 0 {
6905                return Ok(());
6906            };
6907            depth.increment()?;
6908            let envelope_size = 8;
6909            let bytes_len = len * envelope_size;
6910            let offset = decoder.out_of_line_offset(bytes_len)?;
6911            // Decode the envelope for each type.
6912            let mut _next_ordinal_to_read = 0;
6913            let mut next_offset = offset;
6914            let end_offset = offset + bytes_len;
6915            _next_ordinal_to_read += 1;
6916            if next_offset >= end_offset {
6917                return Ok(());
6918            }
6919
6920            // Decode unknown envelopes for gaps in ordinals.
6921            while _next_ordinal_to_read < 1 {
6922                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6923                _next_ordinal_to_read += 1;
6924                next_offset += envelope_size;
6925            }
6926
6927            let next_out_of_line = decoder.next_out_of_line();
6928            let handles_before = decoder.remaining_handles();
6929            if let Some((inlined, num_bytes, num_handles)) =
6930                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6931            {
6932                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6933                if inlined != (member_inline_size <= 4) {
6934                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6935                }
6936                let inner_offset;
6937                let mut inner_depth = depth.clone();
6938                if inlined {
6939                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6940                    inner_offset = next_offset;
6941                } else {
6942                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6943                    inner_depth.increment()?;
6944                }
6945                let val_ref = self.source_name.get_or_insert_with(|| {
6946                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
6947                });
6948                fidl::decode!(
6949                    fidl::encoding::BoundedString<1024>,
6950                    D,
6951                    val_ref,
6952                    decoder,
6953                    inner_offset,
6954                    inner_depth
6955                )?;
6956                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6957                {
6958                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6959                }
6960                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6961                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6962                }
6963            }
6964
6965            next_offset += envelope_size;
6966            _next_ordinal_to_read += 1;
6967            if next_offset >= end_offset {
6968                return Ok(());
6969            }
6970
6971            // Decode unknown envelopes for gaps in ordinals.
6972            while _next_ordinal_to_read < 2 {
6973                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6974                _next_ordinal_to_read += 1;
6975                next_offset += envelope_size;
6976            }
6977
6978            let next_out_of_line = decoder.next_out_of_line();
6979            let handles_before = decoder.remaining_handles();
6980            if let Some((inlined, num_bytes, num_handles)) =
6981                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6982            {
6983                let member_inline_size = <fidl_fuchsia_component_decl__common::Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6984                if inlined != (member_inline_size <= 4) {
6985                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6986                }
6987                let inner_offset;
6988                let mut inner_depth = depth.clone();
6989                if inlined {
6990                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6991                    inner_offset = next_offset;
6992                } else {
6993                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6994                    inner_depth.increment()?;
6995                }
6996                let val_ref = self.source.get_or_insert_with(|| {
6997                    fidl::new_empty!(fidl_fuchsia_component_decl__common::Ref, D)
6998                });
6999                fidl::decode!(
7000                    fidl_fuchsia_component_decl__common::Ref,
7001                    D,
7002                    val_ref,
7003                    decoder,
7004                    inner_offset,
7005                    inner_depth
7006                )?;
7007                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7008                {
7009                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7010                }
7011                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7012                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7013                }
7014            }
7015
7016            next_offset += envelope_size;
7017
7018            // Decode the remaining unknown envelopes.
7019            while next_offset < end_offset {
7020                _next_ordinal_to_read += 1;
7021                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7022                next_offset += envelope_size;
7023            }
7024
7025            Ok(())
7026        }
7027    }
7028
7029    impl EventStreamRouteMetadata {
7030        #[inline(always)]
7031        fn max_ordinal_present(&self) -> u64 {
7032            if let Some(_) = self.scope {
7033                return 2;
7034            }
7035            if let Some(_) = self.scope_moniker {
7036                return 1;
7037            }
7038            0
7039        }
7040    }
7041
7042    impl fidl::encoding::ValueTypeMarker for EventStreamRouteMetadata {
7043        type Borrowed<'a> = &'a Self;
7044        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7045            value
7046        }
7047    }
7048
7049    unsafe impl fidl::encoding::TypeMarker for EventStreamRouteMetadata {
7050        type Owned = Self;
7051
7052        #[inline(always)]
7053        fn inline_align(_context: fidl::encoding::Context) -> usize {
7054            8
7055        }
7056
7057        #[inline(always)]
7058        fn inline_size(_context: fidl::encoding::Context) -> usize {
7059            16
7060        }
7061    }
7062
7063    unsafe impl<D: fidl::encoding::ResourceDialect>
7064        fidl::encoding::Encode<EventStreamRouteMetadata, D> for &EventStreamRouteMetadata
7065    {
7066        unsafe fn encode(
7067            self,
7068            encoder: &mut fidl::encoding::Encoder<'_, D>,
7069            offset: usize,
7070            mut depth: fidl::encoding::Depth,
7071        ) -> fidl::Result<()> {
7072            encoder.debug_check_bounds::<EventStreamRouteMetadata>(offset);
7073            // Vector header
7074            let max_ordinal: u64 = self.max_ordinal_present();
7075            encoder.write_num(max_ordinal, offset);
7076            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7077            // Calling encoder.out_of_line_offset(0) is not allowed.
7078            if max_ordinal == 0 {
7079                return Ok(());
7080            }
7081            depth.increment()?;
7082            let envelope_size = 8;
7083            let bytes_len = max_ordinal as usize * envelope_size;
7084            #[allow(unused_variables)]
7085            let offset = encoder.out_of_line_offset(bytes_len);
7086            let mut _prev_end_offset: usize = 0;
7087            if 1 > max_ordinal {
7088                return Ok(());
7089            }
7090
7091            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7092            // are envelope_size bytes.
7093            let cur_offset: usize = (1 - 1) * envelope_size;
7094
7095            // Zero reserved fields.
7096            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7097
7098            // Safety:
7099            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7100            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7101            //   envelope_size bytes, there is always sufficient room.
7102            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
7103            self.scope_moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
7104            encoder, offset + cur_offset, depth
7105        )?;
7106
7107            _prev_end_offset = cur_offset + envelope_size;
7108            if 2 > max_ordinal {
7109                return Ok(());
7110            }
7111
7112            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7113            // are envelope_size bytes.
7114            let cur_offset: usize = (2 - 1) * envelope_size;
7115
7116            // Zero reserved fields.
7117            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7118
7119            // Safety:
7120            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7121            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7122            //   envelope_size bytes, there is always sufficient room.
7123            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>, D>(
7124            self.scope.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref> as fidl::encoding::ValueTypeMarker>::borrow),
7125            encoder, offset + cur_offset, depth
7126        )?;
7127
7128            _prev_end_offset = cur_offset + envelope_size;
7129
7130            Ok(())
7131        }
7132    }
7133
7134    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7135        for EventStreamRouteMetadata
7136    {
7137        #[inline(always)]
7138        fn new_empty() -> Self {
7139            Self::default()
7140        }
7141
7142        unsafe fn decode(
7143            &mut self,
7144            decoder: &mut fidl::encoding::Decoder<'_, D>,
7145            offset: usize,
7146            mut depth: fidl::encoding::Depth,
7147        ) -> fidl::Result<()> {
7148            decoder.debug_check_bounds::<Self>(offset);
7149            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7150                None => return Err(fidl::Error::NotNullable),
7151                Some(len) => len,
7152            };
7153            // Calling decoder.out_of_line_offset(0) is not allowed.
7154            if len == 0 {
7155                return Ok(());
7156            };
7157            depth.increment()?;
7158            let envelope_size = 8;
7159            let bytes_len = len * envelope_size;
7160            let offset = decoder.out_of_line_offset(bytes_len)?;
7161            // Decode the envelope for each type.
7162            let mut _next_ordinal_to_read = 0;
7163            let mut next_offset = offset;
7164            let end_offset = offset + bytes_len;
7165            _next_ordinal_to_read += 1;
7166            if next_offset >= end_offset {
7167                return Ok(());
7168            }
7169
7170            // Decode unknown envelopes for gaps in ordinals.
7171            while _next_ordinal_to_read < 1 {
7172                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7173                _next_ordinal_to_read += 1;
7174                next_offset += envelope_size;
7175            }
7176
7177            let next_out_of_line = decoder.next_out_of_line();
7178            let handles_before = decoder.remaining_handles();
7179            if let Some((inlined, num_bytes, num_handles)) =
7180                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7181            {
7182                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7183                if inlined != (member_inline_size <= 4) {
7184                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7185                }
7186                let inner_offset;
7187                let mut inner_depth = depth.clone();
7188                if inlined {
7189                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7190                    inner_offset = next_offset;
7191                } else {
7192                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7193                    inner_depth.increment()?;
7194                }
7195                let val_ref = self.scope_moniker.get_or_insert_with(|| {
7196                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
7197                });
7198                fidl::decode!(
7199                    fidl::encoding::BoundedString<4096>,
7200                    D,
7201                    val_ref,
7202                    decoder,
7203                    inner_offset,
7204                    inner_depth
7205                )?;
7206                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7207                {
7208                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7209                }
7210                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7211                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7212                }
7213            }
7214
7215            next_offset += envelope_size;
7216            _next_ordinal_to_read += 1;
7217            if next_offset >= end_offset {
7218                return Ok(());
7219            }
7220
7221            // Decode unknown envelopes for gaps in ordinals.
7222            while _next_ordinal_to_read < 2 {
7223                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7224                _next_ordinal_to_read += 1;
7225                next_offset += envelope_size;
7226            }
7227
7228            let next_out_of_line = decoder.next_out_of_line();
7229            let handles_before = decoder.remaining_handles();
7230            if let Some((inlined, num_bytes, num_handles)) =
7231                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7232            {
7233                let member_inline_size = <fidl::encoding::UnboundedVector<
7234                    fidl_fuchsia_component_decl__common::Ref,
7235                > as fidl::encoding::TypeMarker>::inline_size(
7236                    decoder.context
7237                );
7238                if inlined != (member_inline_size <= 4) {
7239                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7240                }
7241                let inner_offset;
7242                let mut inner_depth = depth.clone();
7243                if inlined {
7244                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7245                    inner_offset = next_offset;
7246                } else {
7247                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7248                    inner_depth.increment()?;
7249                }
7250                let val_ref = self.scope.get_or_insert_with(|| {
7251                    fidl::new_empty!(
7252                        fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>,
7253                        D
7254                    )
7255                });
7256                fidl::decode!(
7257                    fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>,
7258                    D,
7259                    val_ref,
7260                    decoder,
7261                    inner_offset,
7262                    inner_depth
7263                )?;
7264                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7265                {
7266                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7267                }
7268                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7269                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7270                }
7271            }
7272
7273            next_offset += envelope_size;
7274
7275            // Decode the remaining unknown envelopes.
7276            while next_offset < end_offset {
7277                _next_ordinal_to_read += 1;
7278                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7279                next_offset += envelope_size;
7280            }
7281
7282            Ok(())
7283        }
7284    }
7285
7286    impl FilteredAggregateProvider {
7287        #[inline(always)]
7288        fn max_ordinal_present(&self) -> u64 {
7289            if let Some(_) = self.sources {
7290                return 4;
7291            }
7292            if let Some(_) = self.offer_service_decls {
7293                return 3;
7294            }
7295            if let Some(_) = self.moniker {
7296                return 2;
7297            }
7298            if let Some(_) = self.capability {
7299                return 1;
7300            }
7301            0
7302        }
7303    }
7304
7305    impl fidl::encoding::ValueTypeMarker for FilteredAggregateProvider {
7306        type Borrowed<'a> = &'a Self;
7307        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7308            value
7309        }
7310    }
7311
7312    unsafe impl fidl::encoding::TypeMarker for FilteredAggregateProvider {
7313        type Owned = Self;
7314
7315        #[inline(always)]
7316        fn inline_align(_context: fidl::encoding::Context) -> usize {
7317            8
7318        }
7319
7320        #[inline(always)]
7321        fn inline_size(_context: fidl::encoding::Context) -> usize {
7322            16
7323        }
7324    }
7325
7326    unsafe impl<D: fidl::encoding::ResourceDialect>
7327        fidl::encoding::Encode<FilteredAggregateProvider, D> for &FilteredAggregateProvider
7328    {
7329        unsafe fn encode(
7330            self,
7331            encoder: &mut fidl::encoding::Encoder<'_, D>,
7332            offset: usize,
7333            mut depth: fidl::encoding::Depth,
7334        ) -> fidl::Result<()> {
7335            encoder.debug_check_bounds::<FilteredAggregateProvider>(offset);
7336            // Vector header
7337            let max_ordinal: u64 = self.max_ordinal_present();
7338            encoder.write_num(max_ordinal, offset);
7339            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7340            // Calling encoder.out_of_line_offset(0) is not allowed.
7341            if max_ordinal == 0 {
7342                return Ok(());
7343            }
7344            depth.increment()?;
7345            let envelope_size = 8;
7346            let bytes_len = max_ordinal as usize * envelope_size;
7347            #[allow(unused_variables)]
7348            let offset = encoder.out_of_line_offset(bytes_len);
7349            let mut _prev_end_offset: usize = 0;
7350            if 1 > max_ordinal {
7351                return Ok(());
7352            }
7353
7354            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7355            // are envelope_size bytes.
7356            let cur_offset: usize = (1 - 1) * envelope_size;
7357
7358            // Zero reserved fields.
7359            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7360
7361            // Safety:
7362            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7363            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7364            //   envelope_size bytes, there is always sufficient room.
7365            fidl::encoding::encode_in_envelope_optional::<AggregateCapability, D>(
7366                self.capability
7367                    .as_ref()
7368                    .map(<AggregateCapability as fidl::encoding::ValueTypeMarker>::borrow),
7369                encoder,
7370                offset + cur_offset,
7371                depth,
7372            )?;
7373
7374            _prev_end_offset = cur_offset + envelope_size;
7375            if 2 > max_ordinal {
7376                return Ok(());
7377            }
7378
7379            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7380            // are envelope_size bytes.
7381            let cur_offset: usize = (2 - 1) * envelope_size;
7382
7383            // Zero reserved fields.
7384            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7385
7386            // Safety:
7387            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7388            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7389            //   envelope_size bytes, there is always sufficient room.
7390            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
7391            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
7392            encoder, offset + cur_offset, depth
7393        )?;
7394
7395            _prev_end_offset = cur_offset + envelope_size;
7396            if 3 > max_ordinal {
7397                return Ok(());
7398            }
7399
7400            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7401            // are envelope_size bytes.
7402            let cur_offset: usize = (3 - 1) * envelope_size;
7403
7404            // Zero reserved fields.
7405            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7406
7407            // Safety:
7408            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7409            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7410            //   envelope_size bytes, there is always sufficient room.
7411            fidl::encoding::encode_in_envelope_optional::<
7412                fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::OfferService>,
7413                D,
7414            >(
7415                self.offer_service_decls.as_ref().map(
7416                    <fidl::encoding::UnboundedVector<
7417                        fidl_fuchsia_component_decl__common::OfferService,
7418                    > as fidl::encoding::ValueTypeMarker>::borrow,
7419                ),
7420                encoder,
7421                offset + cur_offset,
7422                depth,
7423            )?;
7424
7425            _prev_end_offset = cur_offset + envelope_size;
7426            if 4 > max_ordinal {
7427                return Ok(());
7428            }
7429
7430            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7431            // are envelope_size bytes.
7432            let cur_offset: usize = (4 - 1) * envelope_size;
7433
7434            // Zero reserved fields.
7435            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7436
7437            // Safety:
7438            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7439            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7440            //   envelope_size bytes, there is always sufficient room.
7441            fidl::encoding::encode_in_envelope_optional::<Sources, D>(
7442                self.sources.as_ref().map(<Sources as fidl::encoding::ValueTypeMarker>::borrow),
7443                encoder,
7444                offset + cur_offset,
7445                depth,
7446            )?;
7447
7448            _prev_end_offset = cur_offset + envelope_size;
7449
7450            Ok(())
7451        }
7452    }
7453
7454    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7455        for FilteredAggregateProvider
7456    {
7457        #[inline(always)]
7458        fn new_empty() -> Self {
7459            Self::default()
7460        }
7461
7462        unsafe fn decode(
7463            &mut self,
7464            decoder: &mut fidl::encoding::Decoder<'_, D>,
7465            offset: usize,
7466            mut depth: fidl::encoding::Depth,
7467        ) -> fidl::Result<()> {
7468            decoder.debug_check_bounds::<Self>(offset);
7469            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7470                None => return Err(fidl::Error::NotNullable),
7471                Some(len) => len,
7472            };
7473            // Calling decoder.out_of_line_offset(0) is not allowed.
7474            if len == 0 {
7475                return Ok(());
7476            };
7477            depth.increment()?;
7478            let envelope_size = 8;
7479            let bytes_len = len * envelope_size;
7480            let offset = decoder.out_of_line_offset(bytes_len)?;
7481            // Decode the envelope for each type.
7482            let mut _next_ordinal_to_read = 0;
7483            let mut next_offset = offset;
7484            let end_offset = offset + bytes_len;
7485            _next_ordinal_to_read += 1;
7486            if next_offset >= end_offset {
7487                return Ok(());
7488            }
7489
7490            // Decode unknown envelopes for gaps in ordinals.
7491            while _next_ordinal_to_read < 1 {
7492                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7493                _next_ordinal_to_read += 1;
7494                next_offset += envelope_size;
7495            }
7496
7497            let next_out_of_line = decoder.next_out_of_line();
7498            let handles_before = decoder.remaining_handles();
7499            if let Some((inlined, num_bytes, num_handles)) =
7500                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7501            {
7502                let member_inline_size =
7503                    <AggregateCapability as fidl::encoding::TypeMarker>::inline_size(
7504                        decoder.context,
7505                    );
7506                if inlined != (member_inline_size <= 4) {
7507                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7508                }
7509                let inner_offset;
7510                let mut inner_depth = depth.clone();
7511                if inlined {
7512                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7513                    inner_offset = next_offset;
7514                } else {
7515                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7516                    inner_depth.increment()?;
7517                }
7518                let val_ref =
7519                    self.capability.get_or_insert_with(|| fidl::new_empty!(AggregateCapability, D));
7520                fidl::decode!(AggregateCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
7521                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7522                {
7523                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7524                }
7525                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7526                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7527                }
7528            }
7529
7530            next_offset += envelope_size;
7531            _next_ordinal_to_read += 1;
7532            if next_offset >= end_offset {
7533                return Ok(());
7534            }
7535
7536            // Decode unknown envelopes for gaps in ordinals.
7537            while _next_ordinal_to_read < 2 {
7538                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7539                _next_ordinal_to_read += 1;
7540                next_offset += envelope_size;
7541            }
7542
7543            let next_out_of_line = decoder.next_out_of_line();
7544            let handles_before = decoder.remaining_handles();
7545            if let Some((inlined, num_bytes, num_handles)) =
7546                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7547            {
7548                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7549                if inlined != (member_inline_size <= 4) {
7550                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7551                }
7552                let inner_offset;
7553                let mut inner_depth = depth.clone();
7554                if inlined {
7555                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7556                    inner_offset = next_offset;
7557                } else {
7558                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7559                    inner_depth.increment()?;
7560                }
7561                let val_ref = self.moniker.get_or_insert_with(|| {
7562                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
7563                });
7564                fidl::decode!(
7565                    fidl::encoding::BoundedString<4096>,
7566                    D,
7567                    val_ref,
7568                    decoder,
7569                    inner_offset,
7570                    inner_depth
7571                )?;
7572                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7573                {
7574                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7575                }
7576                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7577                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7578                }
7579            }
7580
7581            next_offset += envelope_size;
7582            _next_ordinal_to_read += 1;
7583            if next_offset >= end_offset {
7584                return Ok(());
7585            }
7586
7587            // Decode unknown envelopes for gaps in ordinals.
7588            while _next_ordinal_to_read < 3 {
7589                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7590                _next_ordinal_to_read += 1;
7591                next_offset += envelope_size;
7592            }
7593
7594            let next_out_of_line = decoder.next_out_of_line();
7595            let handles_before = decoder.remaining_handles();
7596            if let Some((inlined, num_bytes, num_handles)) =
7597                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7598            {
7599                let member_inline_size = <fidl::encoding::UnboundedVector<
7600                    fidl_fuchsia_component_decl__common::OfferService,
7601                > as fidl::encoding::TypeMarker>::inline_size(
7602                    decoder.context
7603                );
7604                if inlined != (member_inline_size <= 4) {
7605                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7606                }
7607                let inner_offset;
7608                let mut inner_depth = depth.clone();
7609                if inlined {
7610                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7611                    inner_offset = next_offset;
7612                } else {
7613                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7614                    inner_depth.increment()?;
7615                }
7616                let val_ref = self.offer_service_decls.get_or_insert_with(|| {
7617                    fidl::new_empty!(
7618                        fidl::encoding::UnboundedVector<
7619                            fidl_fuchsia_component_decl__common::OfferService,
7620                        >,
7621                        D
7622                    )
7623                });
7624                fidl::decode!(
7625                    fidl::encoding::UnboundedVector<
7626                        fidl_fuchsia_component_decl__common::OfferService,
7627                    >,
7628                    D,
7629                    val_ref,
7630                    decoder,
7631                    inner_offset,
7632                    inner_depth
7633                )?;
7634                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7635                {
7636                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7637                }
7638                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7639                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7640                }
7641            }
7642
7643            next_offset += envelope_size;
7644            _next_ordinal_to_read += 1;
7645            if next_offset >= end_offset {
7646                return Ok(());
7647            }
7648
7649            // Decode unknown envelopes for gaps in ordinals.
7650            while _next_ordinal_to_read < 4 {
7651                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7652                _next_ordinal_to_read += 1;
7653                next_offset += envelope_size;
7654            }
7655
7656            let next_out_of_line = decoder.next_out_of_line();
7657            let handles_before = decoder.remaining_handles();
7658            if let Some((inlined, num_bytes, num_handles)) =
7659                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7660            {
7661                let member_inline_size =
7662                    <Sources as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7663                if inlined != (member_inline_size <= 4) {
7664                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7665                }
7666                let inner_offset;
7667                let mut inner_depth = depth.clone();
7668                if inlined {
7669                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7670                    inner_offset = next_offset;
7671                } else {
7672                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7673                    inner_depth.increment()?;
7674                }
7675                let val_ref = self.sources.get_or_insert_with(|| fidl::new_empty!(Sources, D));
7676                fidl::decode!(Sources, D, val_ref, decoder, inner_offset, inner_depth)?;
7677                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7678                {
7679                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7680                }
7681                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7682                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7683                }
7684            }
7685
7686            next_offset += envelope_size;
7687
7688            // Decode the remaining unknown envelopes.
7689            while next_offset < end_offset {
7690                _next_ordinal_to_read += 1;
7691                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7692                next_offset += envelope_size;
7693            }
7694
7695            Ok(())
7696        }
7697    }
7698
7699    impl FilteredProvider {
7700        #[inline(always)]
7701        fn max_ordinal_present(&self) -> u64 {
7702            if let Some(_) = self.offer_service_decl {
7703                return 4;
7704            }
7705            if let Some(_) = self.service_capability {
7706                return 3;
7707            }
7708            if let Some(_) = self.moniker {
7709                return 2;
7710            }
7711            if let Some(_) = self.capability {
7712                return 1;
7713            }
7714            0
7715        }
7716    }
7717
7718    impl fidl::encoding::ValueTypeMarker for FilteredProvider {
7719        type Borrowed<'a> = &'a Self;
7720        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7721            value
7722        }
7723    }
7724
7725    unsafe impl fidl::encoding::TypeMarker for FilteredProvider {
7726        type Owned = Self;
7727
7728        #[inline(always)]
7729        fn inline_align(_context: fidl::encoding::Context) -> usize {
7730            8
7731        }
7732
7733        #[inline(always)]
7734        fn inline_size(_context: fidl::encoding::Context) -> usize {
7735            16
7736        }
7737    }
7738
7739    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FilteredProvider, D>
7740        for &FilteredProvider
7741    {
7742        unsafe fn encode(
7743            self,
7744            encoder: &mut fidl::encoding::Encoder<'_, D>,
7745            offset: usize,
7746            mut depth: fidl::encoding::Depth,
7747        ) -> fidl::Result<()> {
7748            encoder.debug_check_bounds::<FilteredProvider>(offset);
7749            // Vector header
7750            let max_ordinal: u64 = self.max_ordinal_present();
7751            encoder.write_num(max_ordinal, offset);
7752            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7753            // Calling encoder.out_of_line_offset(0) is not allowed.
7754            if max_ordinal == 0 {
7755                return Ok(());
7756            }
7757            depth.increment()?;
7758            let envelope_size = 8;
7759            let bytes_len = max_ordinal as usize * envelope_size;
7760            #[allow(unused_variables)]
7761            let offset = encoder.out_of_line_offset(bytes_len);
7762            let mut _prev_end_offset: usize = 0;
7763            if 1 > max_ordinal {
7764                return Ok(());
7765            }
7766
7767            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7768            // are envelope_size bytes.
7769            let cur_offset: usize = (1 - 1) * envelope_size;
7770
7771            // Zero reserved fields.
7772            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7773
7774            // Safety:
7775            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7776            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7777            //   envelope_size bytes, there is always sufficient room.
7778            fidl::encoding::encode_in_envelope_optional::<AggregateCapability, D>(
7779                self.capability
7780                    .as_ref()
7781                    .map(<AggregateCapability as fidl::encoding::ValueTypeMarker>::borrow),
7782                encoder,
7783                offset + cur_offset,
7784                depth,
7785            )?;
7786
7787            _prev_end_offset = cur_offset + envelope_size;
7788            if 2 > max_ordinal {
7789                return Ok(());
7790            }
7791
7792            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7793            // are envelope_size bytes.
7794            let cur_offset: usize = (2 - 1) * envelope_size;
7795
7796            // Zero reserved fields.
7797            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7798
7799            // Safety:
7800            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7801            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7802            //   envelope_size bytes, there is always sufficient room.
7803            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
7804            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
7805            encoder, offset + cur_offset, depth
7806        )?;
7807
7808            _prev_end_offset = cur_offset + envelope_size;
7809            if 3 > max_ordinal {
7810                return Ok(());
7811            }
7812
7813            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7814            // are envelope_size bytes.
7815            let cur_offset: usize = (3 - 1) * envelope_size;
7816
7817            // Zero reserved fields.
7818            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7819
7820            // Safety:
7821            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7822            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7823            //   envelope_size bytes, there is always sufficient room.
7824            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
7825                self.service_capability
7826                    .as_ref()
7827                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
7828                encoder,
7829                offset + cur_offset,
7830                depth,
7831            )?;
7832
7833            _prev_end_offset = cur_offset + envelope_size;
7834            if 4 > max_ordinal {
7835                return Ok(());
7836            }
7837
7838            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7839            // are envelope_size bytes.
7840            let cur_offset: usize = (4 - 1) * envelope_size;
7841
7842            // Zero reserved fields.
7843            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7844
7845            // Safety:
7846            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7847            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7848            //   envelope_size bytes, there is always sufficient room.
7849            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::OfferService, D>(
7850            self.offer_service_decl.as_ref().map(<fidl_fuchsia_component_decl__common::OfferService as fidl::encoding::ValueTypeMarker>::borrow),
7851            encoder, offset + cur_offset, depth
7852        )?;
7853
7854            _prev_end_offset = cur_offset + envelope_size;
7855
7856            Ok(())
7857        }
7858    }
7859
7860    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FilteredProvider {
7861        #[inline(always)]
7862        fn new_empty() -> Self {
7863            Self::default()
7864        }
7865
7866        unsafe fn decode(
7867            &mut self,
7868            decoder: &mut fidl::encoding::Decoder<'_, D>,
7869            offset: usize,
7870            mut depth: fidl::encoding::Depth,
7871        ) -> fidl::Result<()> {
7872            decoder.debug_check_bounds::<Self>(offset);
7873            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7874                None => return Err(fidl::Error::NotNullable),
7875                Some(len) => len,
7876            };
7877            // Calling decoder.out_of_line_offset(0) is not allowed.
7878            if len == 0 {
7879                return Ok(());
7880            };
7881            depth.increment()?;
7882            let envelope_size = 8;
7883            let bytes_len = len * envelope_size;
7884            let offset = decoder.out_of_line_offset(bytes_len)?;
7885            // Decode the envelope for each type.
7886            let mut _next_ordinal_to_read = 0;
7887            let mut next_offset = offset;
7888            let end_offset = offset + bytes_len;
7889            _next_ordinal_to_read += 1;
7890            if next_offset >= end_offset {
7891                return Ok(());
7892            }
7893
7894            // Decode unknown envelopes for gaps in ordinals.
7895            while _next_ordinal_to_read < 1 {
7896                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7897                _next_ordinal_to_read += 1;
7898                next_offset += envelope_size;
7899            }
7900
7901            let next_out_of_line = decoder.next_out_of_line();
7902            let handles_before = decoder.remaining_handles();
7903            if let Some((inlined, num_bytes, num_handles)) =
7904                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7905            {
7906                let member_inline_size =
7907                    <AggregateCapability as fidl::encoding::TypeMarker>::inline_size(
7908                        decoder.context,
7909                    );
7910                if inlined != (member_inline_size <= 4) {
7911                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7912                }
7913                let inner_offset;
7914                let mut inner_depth = depth.clone();
7915                if inlined {
7916                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7917                    inner_offset = next_offset;
7918                } else {
7919                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7920                    inner_depth.increment()?;
7921                }
7922                let val_ref =
7923                    self.capability.get_or_insert_with(|| fidl::new_empty!(AggregateCapability, D));
7924                fidl::decode!(AggregateCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
7925                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7926                {
7927                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7928                }
7929                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7930                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7931                }
7932            }
7933
7934            next_offset += envelope_size;
7935            _next_ordinal_to_read += 1;
7936            if next_offset >= end_offset {
7937                return Ok(());
7938            }
7939
7940            // Decode unknown envelopes for gaps in ordinals.
7941            while _next_ordinal_to_read < 2 {
7942                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7943                _next_ordinal_to_read += 1;
7944                next_offset += envelope_size;
7945            }
7946
7947            let next_out_of_line = decoder.next_out_of_line();
7948            let handles_before = decoder.remaining_handles();
7949            if let Some((inlined, num_bytes, num_handles)) =
7950                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7951            {
7952                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7953                if inlined != (member_inline_size <= 4) {
7954                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7955                }
7956                let inner_offset;
7957                let mut inner_depth = depth.clone();
7958                if inlined {
7959                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7960                    inner_offset = next_offset;
7961                } else {
7962                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7963                    inner_depth.increment()?;
7964                }
7965                let val_ref = self.moniker.get_or_insert_with(|| {
7966                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
7967                });
7968                fidl::decode!(
7969                    fidl::encoding::BoundedString<4096>,
7970                    D,
7971                    val_ref,
7972                    decoder,
7973                    inner_offset,
7974                    inner_depth
7975                )?;
7976                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7977                {
7978                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7979                }
7980                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7981                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7982                }
7983            }
7984
7985            next_offset += envelope_size;
7986            _next_ordinal_to_read += 1;
7987            if next_offset >= end_offset {
7988                return Ok(());
7989            }
7990
7991            // Decode unknown envelopes for gaps in ordinals.
7992            while _next_ordinal_to_read < 3 {
7993                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7994                _next_ordinal_to_read += 1;
7995                next_offset += envelope_size;
7996            }
7997
7998            let next_out_of_line = decoder.next_out_of_line();
7999            let handles_before = decoder.remaining_handles();
8000            if let Some((inlined, num_bytes, num_handles)) =
8001                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8002            {
8003                let member_inline_size =
8004                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
8005                        decoder.context,
8006                    );
8007                if inlined != (member_inline_size <= 4) {
8008                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8009                }
8010                let inner_offset;
8011                let mut inner_depth = depth.clone();
8012                if inlined {
8013                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8014                    inner_offset = next_offset;
8015                } else {
8016                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8017                    inner_depth.increment()?;
8018                }
8019                let val_ref = self
8020                    .service_capability
8021                    .get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
8022                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
8023                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8024                {
8025                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8026                }
8027                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8028                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8029                }
8030            }
8031
8032            next_offset += envelope_size;
8033            _next_ordinal_to_read += 1;
8034            if next_offset >= end_offset {
8035                return Ok(());
8036            }
8037
8038            // Decode unknown envelopes for gaps in ordinals.
8039            while _next_ordinal_to_read < 4 {
8040                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8041                _next_ordinal_to_read += 1;
8042                next_offset += envelope_size;
8043            }
8044
8045            let next_out_of_line = decoder.next_out_of_line();
8046            let handles_before = decoder.remaining_handles();
8047            if let Some((inlined, num_bytes, num_handles)) =
8048                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8049            {
8050                let member_inline_size = <fidl_fuchsia_component_decl__common::OfferService as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8051                if inlined != (member_inline_size <= 4) {
8052                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8053                }
8054                let inner_offset;
8055                let mut inner_depth = depth.clone();
8056                if inlined {
8057                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8058                    inner_offset = next_offset;
8059                } else {
8060                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8061                    inner_depth.increment()?;
8062                }
8063                let val_ref = self.offer_service_decl.get_or_insert_with(|| {
8064                    fidl::new_empty!(fidl_fuchsia_component_decl__common::OfferService, D)
8065                });
8066                fidl::decode!(
8067                    fidl_fuchsia_component_decl__common::OfferService,
8068                    D,
8069                    val_ref,
8070                    decoder,
8071                    inner_offset,
8072                    inner_depth
8073                )?;
8074                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8075                {
8076                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8077                }
8078                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8079                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8080                }
8081            }
8082
8083            next_offset += envelope_size;
8084
8085            // Decode the remaining unknown envelopes.
8086            while next_offset < end_offset {
8087                _next_ordinal_to_read += 1;
8088                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8089                next_offset += envelope_size;
8090            }
8091
8092            Ok(())
8093        }
8094    }
8095
8096    impl Framework {
8097        #[inline(always)]
8098        fn max_ordinal_present(&self) -> u64 {
8099            if let Some(_) = self.moniker {
8100                return 2;
8101            }
8102            if let Some(_) = self.capability {
8103                return 1;
8104            }
8105            0
8106        }
8107    }
8108
8109    impl fidl::encoding::ValueTypeMarker for Framework {
8110        type Borrowed<'a> = &'a Self;
8111        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8112            value
8113        }
8114    }
8115
8116    unsafe impl fidl::encoding::TypeMarker for Framework {
8117        type Owned = Self;
8118
8119        #[inline(always)]
8120        fn inline_align(_context: fidl::encoding::Context) -> usize {
8121            8
8122        }
8123
8124        #[inline(always)]
8125        fn inline_size(_context: fidl::encoding::Context) -> usize {
8126            16
8127        }
8128    }
8129
8130    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Framework, D>
8131        for &Framework
8132    {
8133        unsafe fn encode(
8134            self,
8135            encoder: &mut fidl::encoding::Encoder<'_, D>,
8136            offset: usize,
8137            mut depth: fidl::encoding::Depth,
8138        ) -> fidl::Result<()> {
8139            encoder.debug_check_bounds::<Framework>(offset);
8140            // Vector header
8141            let max_ordinal: u64 = self.max_ordinal_present();
8142            encoder.write_num(max_ordinal, offset);
8143            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8144            // Calling encoder.out_of_line_offset(0) is not allowed.
8145            if max_ordinal == 0 {
8146                return Ok(());
8147            }
8148            depth.increment()?;
8149            let envelope_size = 8;
8150            let bytes_len = max_ordinal as usize * envelope_size;
8151            #[allow(unused_variables)]
8152            let offset = encoder.out_of_line_offset(bytes_len);
8153            let mut _prev_end_offset: usize = 0;
8154            if 1 > max_ordinal {
8155                return Ok(());
8156            }
8157
8158            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8159            // are envelope_size bytes.
8160            let cur_offset: usize = (1 - 1) * envelope_size;
8161
8162            // Zero reserved fields.
8163            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8164
8165            // Safety:
8166            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8167            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8168            //   envelope_size bytes, there is always sufficient room.
8169            fidl::encoding::encode_in_envelope_optional::<InternalCapability, D>(
8170                self.capability
8171                    .as_ref()
8172                    .map(<InternalCapability as fidl::encoding::ValueTypeMarker>::borrow),
8173                encoder,
8174                offset + cur_offset,
8175                depth,
8176            )?;
8177
8178            _prev_end_offset = cur_offset + envelope_size;
8179            if 2 > max_ordinal {
8180                return Ok(());
8181            }
8182
8183            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8184            // are envelope_size bytes.
8185            let cur_offset: usize = (2 - 1) * envelope_size;
8186
8187            // Zero reserved fields.
8188            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8189
8190            // Safety:
8191            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8192            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8193            //   envelope_size bytes, there is always sufficient room.
8194            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
8195            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
8196            encoder, offset + cur_offset, depth
8197        )?;
8198
8199            _prev_end_offset = cur_offset + envelope_size;
8200
8201            Ok(())
8202        }
8203    }
8204
8205    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Framework {
8206        #[inline(always)]
8207        fn new_empty() -> Self {
8208            Self::default()
8209        }
8210
8211        unsafe fn decode(
8212            &mut self,
8213            decoder: &mut fidl::encoding::Decoder<'_, D>,
8214            offset: usize,
8215            mut depth: fidl::encoding::Depth,
8216        ) -> fidl::Result<()> {
8217            decoder.debug_check_bounds::<Self>(offset);
8218            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8219                None => return Err(fidl::Error::NotNullable),
8220                Some(len) => len,
8221            };
8222            // Calling decoder.out_of_line_offset(0) is not allowed.
8223            if len == 0 {
8224                return Ok(());
8225            };
8226            depth.increment()?;
8227            let envelope_size = 8;
8228            let bytes_len = len * envelope_size;
8229            let offset = decoder.out_of_line_offset(bytes_len)?;
8230            // Decode the envelope for each type.
8231            let mut _next_ordinal_to_read = 0;
8232            let mut next_offset = offset;
8233            let end_offset = offset + bytes_len;
8234            _next_ordinal_to_read += 1;
8235            if next_offset >= end_offset {
8236                return Ok(());
8237            }
8238
8239            // Decode unknown envelopes for gaps in ordinals.
8240            while _next_ordinal_to_read < 1 {
8241                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8242                _next_ordinal_to_read += 1;
8243                next_offset += envelope_size;
8244            }
8245
8246            let next_out_of_line = decoder.next_out_of_line();
8247            let handles_before = decoder.remaining_handles();
8248            if let Some((inlined, num_bytes, num_handles)) =
8249                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8250            {
8251                let member_inline_size =
8252                    <InternalCapability as fidl::encoding::TypeMarker>::inline_size(
8253                        decoder.context,
8254                    );
8255                if inlined != (member_inline_size <= 4) {
8256                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8257                }
8258                let inner_offset;
8259                let mut inner_depth = depth.clone();
8260                if inlined {
8261                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8262                    inner_offset = next_offset;
8263                } else {
8264                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8265                    inner_depth.increment()?;
8266                }
8267                let val_ref =
8268                    self.capability.get_or_insert_with(|| fidl::new_empty!(InternalCapability, D));
8269                fidl::decode!(InternalCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
8270                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8271                {
8272                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8273                }
8274                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8275                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8276                }
8277            }
8278
8279            next_offset += envelope_size;
8280            _next_ordinal_to_read += 1;
8281            if next_offset >= end_offset {
8282                return Ok(());
8283            }
8284
8285            // Decode unknown envelopes for gaps in ordinals.
8286            while _next_ordinal_to_read < 2 {
8287                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8288                _next_ordinal_to_read += 1;
8289                next_offset += envelope_size;
8290            }
8291
8292            let next_out_of_line = decoder.next_out_of_line();
8293            let handles_before = decoder.remaining_handles();
8294            if let Some((inlined, num_bytes, num_handles)) =
8295                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8296            {
8297                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8298                if inlined != (member_inline_size <= 4) {
8299                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8300                }
8301                let inner_offset;
8302                let mut inner_depth = depth.clone();
8303                if inlined {
8304                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8305                    inner_offset = next_offset;
8306                } else {
8307                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8308                    inner_depth.increment()?;
8309                }
8310                let val_ref = self.moniker.get_or_insert_with(|| {
8311                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
8312                });
8313                fidl::decode!(
8314                    fidl::encoding::BoundedString<4096>,
8315                    D,
8316                    val_ref,
8317                    decoder,
8318                    inner_offset,
8319                    inner_depth
8320                )?;
8321                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8322                {
8323                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8324                }
8325                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8326                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8327                }
8328            }
8329
8330            next_offset += envelope_size;
8331
8332            // Decode the remaining unknown envelopes.
8333            while next_offset < end_offset {
8334                _next_ordinal_to_read += 1;
8335                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8336                next_offset += envelope_size;
8337            }
8338
8339            Ok(())
8340        }
8341    }
8342
8343    impl HealthCheck {
8344        #[inline(always)]
8345        fn max_ordinal_present(&self) -> u64 {
8346            if let Some(_) = self.monikers {
8347                return 1;
8348            }
8349            0
8350        }
8351    }
8352
8353    impl fidl::encoding::ValueTypeMarker for HealthCheck {
8354        type Borrowed<'a> = &'a Self;
8355        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8356            value
8357        }
8358    }
8359
8360    unsafe impl fidl::encoding::TypeMarker for HealthCheck {
8361        type Owned = Self;
8362
8363        #[inline(always)]
8364        fn inline_align(_context: fidl::encoding::Context) -> usize {
8365            8
8366        }
8367
8368        #[inline(always)]
8369        fn inline_size(_context: fidl::encoding::Context) -> usize {
8370            16
8371        }
8372    }
8373
8374    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HealthCheck, D>
8375        for &HealthCheck
8376    {
8377        unsafe fn encode(
8378            self,
8379            encoder: &mut fidl::encoding::Encoder<'_, D>,
8380            offset: usize,
8381            mut depth: fidl::encoding::Depth,
8382        ) -> fidl::Result<()> {
8383            encoder.debug_check_bounds::<HealthCheck>(offset);
8384            // Vector header
8385            let max_ordinal: u64 = self.max_ordinal_present();
8386            encoder.write_num(max_ordinal, offset);
8387            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8388            // Calling encoder.out_of_line_offset(0) is not allowed.
8389            if max_ordinal == 0 {
8390                return Ok(());
8391            }
8392            depth.increment()?;
8393            let envelope_size = 8;
8394            let bytes_len = max_ordinal as usize * envelope_size;
8395            #[allow(unused_variables)]
8396            let offset = encoder.out_of_line_offset(bytes_len);
8397            let mut _prev_end_offset: usize = 0;
8398            if 1 > max_ordinal {
8399                return Ok(());
8400            }
8401
8402            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8403            // are envelope_size bytes.
8404            let cur_offset: usize = (1 - 1) * envelope_size;
8405
8406            // Zero reserved fields.
8407            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8408
8409            // Safety:
8410            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8411            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8412            //   envelope_size bytes, there is always sufficient room.
8413            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>>, D>(
8414            self.monikers.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>> as fidl::encoding::ValueTypeMarker>::borrow),
8415            encoder, offset + cur_offset, depth
8416        )?;
8417
8418            _prev_end_offset = cur_offset + envelope_size;
8419
8420            Ok(())
8421        }
8422    }
8423
8424    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HealthCheck {
8425        #[inline(always)]
8426        fn new_empty() -> Self {
8427            Self::default()
8428        }
8429
8430        unsafe fn decode(
8431            &mut self,
8432            decoder: &mut fidl::encoding::Decoder<'_, D>,
8433            offset: usize,
8434            mut depth: fidl::encoding::Depth,
8435        ) -> fidl::Result<()> {
8436            decoder.debug_check_bounds::<Self>(offset);
8437            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8438                None => return Err(fidl::Error::NotNullable),
8439                Some(len) => len,
8440            };
8441            // Calling decoder.out_of_line_offset(0) is not allowed.
8442            if len == 0 {
8443                return Ok(());
8444            };
8445            depth.increment()?;
8446            let envelope_size = 8;
8447            let bytes_len = len * envelope_size;
8448            let offset = decoder.out_of_line_offset(bytes_len)?;
8449            // Decode the envelope for each type.
8450            let mut _next_ordinal_to_read = 0;
8451            let mut next_offset = offset;
8452            let end_offset = offset + bytes_len;
8453            _next_ordinal_to_read += 1;
8454            if next_offset >= end_offset {
8455                return Ok(());
8456            }
8457
8458            // Decode unknown envelopes for gaps in ordinals.
8459            while _next_ordinal_to_read < 1 {
8460                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8461                _next_ordinal_to_read += 1;
8462                next_offset += envelope_size;
8463            }
8464
8465            let next_out_of_line = decoder.next_out_of_line();
8466            let handles_before = decoder.remaining_handles();
8467            if let Some((inlined, num_bytes, num_handles)) =
8468                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8469            {
8470                let member_inline_size = <fidl::encoding::UnboundedVector<
8471                    fidl::encoding::BoundedString<255>,
8472                > as fidl::encoding::TypeMarker>::inline_size(
8473                    decoder.context
8474                );
8475                if inlined != (member_inline_size <= 4) {
8476                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8477                }
8478                let inner_offset;
8479                let mut inner_depth = depth.clone();
8480                if inlined {
8481                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8482                    inner_offset = next_offset;
8483                } else {
8484                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8485                    inner_depth.increment()?;
8486                }
8487                let val_ref = self.monikers.get_or_insert_with(|| {
8488                    fidl::new_empty!(
8489                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>>,
8490                        D
8491                    )
8492                });
8493                fidl::decode!(
8494                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>>,
8495                    D,
8496                    val_ref,
8497                    decoder,
8498                    inner_offset,
8499                    inner_depth
8500                )?;
8501                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8502                {
8503                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8504                }
8505                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8506                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8507                }
8508            }
8509
8510            next_offset += envelope_size;
8511
8512            // Decode the remaining unknown envelopes.
8513            while next_offset < end_offset {
8514                _next_ordinal_to_read += 1;
8515                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8516                next_offset += envelope_size;
8517            }
8518
8519            Ok(())
8520        }
8521    }
8522
8523    impl InjectedCapabilities {
8524        #[inline(always)]
8525        fn max_ordinal_present(&self) -> u64 {
8526            if let Some(_) = self.use_ {
8527                return 2;
8528            }
8529            if let Some(_) = self.components {
8530                return 1;
8531            }
8532            0
8533        }
8534    }
8535
8536    impl fidl::encoding::ValueTypeMarker for InjectedCapabilities {
8537        type Borrowed<'a> = &'a Self;
8538        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8539            value
8540        }
8541    }
8542
8543    unsafe impl fidl::encoding::TypeMarker for InjectedCapabilities {
8544        type Owned = Self;
8545
8546        #[inline(always)]
8547        fn inline_align(_context: fidl::encoding::Context) -> usize {
8548            8
8549        }
8550
8551        #[inline(always)]
8552        fn inline_size(_context: fidl::encoding::Context) -> usize {
8553            16
8554        }
8555    }
8556
8557    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InjectedCapabilities, D>
8558        for &InjectedCapabilities
8559    {
8560        unsafe fn encode(
8561            self,
8562            encoder: &mut fidl::encoding::Encoder<'_, D>,
8563            offset: usize,
8564            mut depth: fidl::encoding::Depth,
8565        ) -> fidl::Result<()> {
8566            encoder.debug_check_bounds::<InjectedCapabilities>(offset);
8567            // Vector header
8568            let max_ordinal: u64 = self.max_ordinal_present();
8569            encoder.write_num(max_ordinal, offset);
8570            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8571            // Calling encoder.out_of_line_offset(0) is not allowed.
8572            if max_ordinal == 0 {
8573                return Ok(());
8574            }
8575            depth.increment()?;
8576            let envelope_size = 8;
8577            let bytes_len = max_ordinal as usize * envelope_size;
8578            #[allow(unused_variables)]
8579            let offset = encoder.out_of_line_offset(bytes_len);
8580            let mut _prev_end_offset: usize = 0;
8581            if 1 > max_ordinal {
8582                return Ok(());
8583            }
8584
8585            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8586            // are envelope_size bytes.
8587            let cur_offset: usize = (1 - 1) * envelope_size;
8588
8589            // Zero reserved fields.
8590            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8591
8592            // Safety:
8593            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8594            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8595            //   envelope_size bytes, there is always sufficient room.
8596            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
8597            self.components.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
8598            encoder, offset + cur_offset, depth
8599        )?;
8600
8601            _prev_end_offset = cur_offset + envelope_size;
8602            if 2 > max_ordinal {
8603                return Ok(());
8604            }
8605
8606            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8607            // are envelope_size bytes.
8608            let cur_offset: usize = (2 - 1) * envelope_size;
8609
8610            // Zero reserved fields.
8611            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8612
8613            // Safety:
8614            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8615            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8616            //   envelope_size bytes, there is always sufficient room.
8617            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<InjectedUse>, D>(
8618            self.use_.as_ref().map(<fidl::encoding::UnboundedVector<InjectedUse> as fidl::encoding::ValueTypeMarker>::borrow),
8619            encoder, offset + cur_offset, depth
8620        )?;
8621
8622            _prev_end_offset = cur_offset + envelope_size;
8623
8624            Ok(())
8625        }
8626    }
8627
8628    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InjectedCapabilities {
8629        #[inline(always)]
8630        fn new_empty() -> Self {
8631            Self::default()
8632        }
8633
8634        unsafe fn decode(
8635            &mut self,
8636            decoder: &mut fidl::encoding::Decoder<'_, D>,
8637            offset: usize,
8638            mut depth: fidl::encoding::Depth,
8639        ) -> fidl::Result<()> {
8640            decoder.debug_check_bounds::<Self>(offset);
8641            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8642                None => return Err(fidl::Error::NotNullable),
8643                Some(len) => len,
8644            };
8645            // Calling decoder.out_of_line_offset(0) is not allowed.
8646            if len == 0 {
8647                return Ok(());
8648            };
8649            depth.increment()?;
8650            let envelope_size = 8;
8651            let bytes_len = len * envelope_size;
8652            let offset = decoder.out_of_line_offset(bytes_len)?;
8653            // Decode the envelope for each type.
8654            let mut _next_ordinal_to_read = 0;
8655            let mut next_offset = offset;
8656            let end_offset = offset + bytes_len;
8657            _next_ordinal_to_read += 1;
8658            if next_offset >= end_offset {
8659                return Ok(());
8660            }
8661
8662            // Decode unknown envelopes for gaps in ordinals.
8663            while _next_ordinal_to_read < 1 {
8664                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8665                _next_ordinal_to_read += 1;
8666                next_offset += envelope_size;
8667            }
8668
8669            let next_out_of_line = decoder.next_out_of_line();
8670            let handles_before = decoder.remaining_handles();
8671            if let Some((inlined, num_bytes, num_handles)) =
8672                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8673            {
8674                let member_inline_size = <fidl::encoding::Vector<
8675                    fidl::encoding::BoundedString<4096>,
8676                    128,
8677                > as fidl::encoding::TypeMarker>::inline_size(
8678                    decoder.context
8679                );
8680                if inlined != (member_inline_size <= 4) {
8681                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8682                }
8683                let inner_offset;
8684                let mut inner_depth = depth.clone();
8685                if inlined {
8686                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8687                    inner_offset = next_offset;
8688                } else {
8689                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8690                    inner_depth.increment()?;
8691                }
8692                let val_ref = self.components.get_or_insert_with(|| {
8693                    fidl::new_empty!(
8694                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8695                        D
8696                    )
8697                });
8698                fidl::decode!(
8699                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8700                    D,
8701                    val_ref,
8702                    decoder,
8703                    inner_offset,
8704                    inner_depth
8705                )?;
8706                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8707                {
8708                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8709                }
8710                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8711                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8712                }
8713            }
8714
8715            next_offset += envelope_size;
8716            _next_ordinal_to_read += 1;
8717            if next_offset >= end_offset {
8718                return Ok(());
8719            }
8720
8721            // Decode unknown envelopes for gaps in ordinals.
8722            while _next_ordinal_to_read < 2 {
8723                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8724                _next_ordinal_to_read += 1;
8725                next_offset += envelope_size;
8726            }
8727
8728            let next_out_of_line = decoder.next_out_of_line();
8729            let handles_before = decoder.remaining_handles();
8730            if let Some((inlined, num_bytes, num_handles)) =
8731                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8732            {
8733                let member_inline_size = <fidl::encoding::UnboundedVector<InjectedUse> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8734                if inlined != (member_inline_size <= 4) {
8735                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8736                }
8737                let inner_offset;
8738                let mut inner_depth = depth.clone();
8739                if inlined {
8740                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8741                    inner_offset = next_offset;
8742                } else {
8743                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8744                    inner_depth.increment()?;
8745                }
8746                let val_ref = self.use_.get_or_insert_with(|| {
8747                    fidl::new_empty!(fidl::encoding::UnboundedVector<InjectedUse>, D)
8748                });
8749                fidl::decode!(
8750                    fidl::encoding::UnboundedVector<InjectedUse>,
8751                    D,
8752                    val_ref,
8753                    decoder,
8754                    inner_offset,
8755                    inner_depth
8756                )?;
8757                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8758                {
8759                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8760                }
8761                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8762                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8763                }
8764            }
8765
8766            next_offset += envelope_size;
8767
8768            // Decode the remaining unknown envelopes.
8769            while next_offset < end_offset {
8770                _next_ordinal_to_read += 1;
8771                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8772                next_offset += envelope_size;
8773            }
8774
8775            Ok(())
8776        }
8777    }
8778
8779    impl InjectedUseProtocol {
8780        #[inline(always)]
8781        fn max_ordinal_present(&self) -> u64 {
8782            if let Some(_) = self.target_path {
8783                return 2;
8784            }
8785            if let Some(_) = self.source_name {
8786                return 1;
8787            }
8788            0
8789        }
8790    }
8791
8792    impl fidl::encoding::ValueTypeMarker for InjectedUseProtocol {
8793        type Borrowed<'a> = &'a Self;
8794        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8795            value
8796        }
8797    }
8798
8799    unsafe impl fidl::encoding::TypeMarker for InjectedUseProtocol {
8800        type Owned = Self;
8801
8802        #[inline(always)]
8803        fn inline_align(_context: fidl::encoding::Context) -> usize {
8804            8
8805        }
8806
8807        #[inline(always)]
8808        fn inline_size(_context: fidl::encoding::Context) -> usize {
8809            16
8810        }
8811    }
8812
8813    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InjectedUseProtocol, D>
8814        for &InjectedUseProtocol
8815    {
8816        unsafe fn encode(
8817            self,
8818            encoder: &mut fidl::encoding::Encoder<'_, D>,
8819            offset: usize,
8820            mut depth: fidl::encoding::Depth,
8821        ) -> fidl::Result<()> {
8822            encoder.debug_check_bounds::<InjectedUseProtocol>(offset);
8823            // Vector header
8824            let max_ordinal: u64 = self.max_ordinal_present();
8825            encoder.write_num(max_ordinal, offset);
8826            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8827            // Calling encoder.out_of_line_offset(0) is not allowed.
8828            if max_ordinal == 0 {
8829                return Ok(());
8830            }
8831            depth.increment()?;
8832            let envelope_size = 8;
8833            let bytes_len = max_ordinal as usize * envelope_size;
8834            #[allow(unused_variables)]
8835            let offset = encoder.out_of_line_offset(bytes_len);
8836            let mut _prev_end_offset: usize = 0;
8837            if 1 > max_ordinal {
8838                return Ok(());
8839            }
8840
8841            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8842            // are envelope_size bytes.
8843            let cur_offset: usize = (1 - 1) * envelope_size;
8844
8845            // Zero reserved fields.
8846            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8847
8848            // Safety:
8849            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8850            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8851            //   envelope_size bytes, there is always sufficient room.
8852            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
8853                self.source_name.as_ref().map(
8854                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
8855                ),
8856                encoder,
8857                offset + cur_offset,
8858                depth,
8859            )?;
8860
8861            _prev_end_offset = cur_offset + envelope_size;
8862            if 2 > max_ordinal {
8863                return Ok(());
8864            }
8865
8866            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8867            // are envelope_size bytes.
8868            let cur_offset: usize = (2 - 1) * envelope_size;
8869
8870            // Zero reserved fields.
8871            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8872
8873            // Safety:
8874            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8875            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8876            //   envelope_size bytes, there is always sufficient room.
8877            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
8878            self.target_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
8879            encoder, offset + cur_offset, depth
8880        )?;
8881
8882            _prev_end_offset = cur_offset + envelope_size;
8883
8884            Ok(())
8885        }
8886    }
8887
8888    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InjectedUseProtocol {
8889        #[inline(always)]
8890        fn new_empty() -> Self {
8891            Self::default()
8892        }
8893
8894        unsafe fn decode(
8895            &mut self,
8896            decoder: &mut fidl::encoding::Decoder<'_, D>,
8897            offset: usize,
8898            mut depth: fidl::encoding::Depth,
8899        ) -> fidl::Result<()> {
8900            decoder.debug_check_bounds::<Self>(offset);
8901            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8902                None => return Err(fidl::Error::NotNullable),
8903                Some(len) => len,
8904            };
8905            // Calling decoder.out_of_line_offset(0) is not allowed.
8906            if len == 0 {
8907                return Ok(());
8908            };
8909            depth.increment()?;
8910            let envelope_size = 8;
8911            let bytes_len = len * envelope_size;
8912            let offset = decoder.out_of_line_offset(bytes_len)?;
8913            // Decode the envelope for each type.
8914            let mut _next_ordinal_to_read = 0;
8915            let mut next_offset = offset;
8916            let end_offset = offset + bytes_len;
8917            _next_ordinal_to_read += 1;
8918            if next_offset >= end_offset {
8919                return Ok(());
8920            }
8921
8922            // Decode unknown envelopes for gaps in ordinals.
8923            while _next_ordinal_to_read < 1 {
8924                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8925                _next_ordinal_to_read += 1;
8926                next_offset += envelope_size;
8927            }
8928
8929            let next_out_of_line = decoder.next_out_of_line();
8930            let handles_before = decoder.remaining_handles();
8931            if let Some((inlined, num_bytes, num_handles)) =
8932                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8933            {
8934                let member_inline_size =
8935                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
8936                        decoder.context,
8937                    );
8938                if inlined != (member_inline_size <= 4) {
8939                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8940                }
8941                let inner_offset;
8942                let mut inner_depth = depth.clone();
8943                if inlined {
8944                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8945                    inner_offset = next_offset;
8946                } else {
8947                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8948                    inner_depth.increment()?;
8949                }
8950                let val_ref = self
8951                    .source_name
8952                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
8953                fidl::decode!(
8954                    fidl::encoding::BoundedString<100>,
8955                    D,
8956                    val_ref,
8957                    decoder,
8958                    inner_offset,
8959                    inner_depth
8960                )?;
8961                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8962                {
8963                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8964                }
8965                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8966                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8967                }
8968            }
8969
8970            next_offset += envelope_size;
8971            _next_ordinal_to_read += 1;
8972            if next_offset >= end_offset {
8973                return Ok(());
8974            }
8975
8976            // Decode unknown envelopes for gaps in ordinals.
8977            while _next_ordinal_to_read < 2 {
8978                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8979                _next_ordinal_to_read += 1;
8980                next_offset += envelope_size;
8981            }
8982
8983            let next_out_of_line = decoder.next_out_of_line();
8984            let handles_before = decoder.remaining_handles();
8985            if let Some((inlined, num_bytes, num_handles)) =
8986                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8987            {
8988                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8989                if inlined != (member_inline_size <= 4) {
8990                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8991                }
8992                let inner_offset;
8993                let mut inner_depth = depth.clone();
8994                if inlined {
8995                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8996                    inner_offset = next_offset;
8997                } else {
8998                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8999                    inner_depth.increment()?;
9000                }
9001                let val_ref = self.target_path.get_or_insert_with(|| {
9002                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
9003                });
9004                fidl::decode!(
9005                    fidl::encoding::BoundedString<1024>,
9006                    D,
9007                    val_ref,
9008                    decoder,
9009                    inner_offset,
9010                    inner_depth
9011                )?;
9012                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9013                {
9014                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9015                }
9016                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9017                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9018                }
9019            }
9020
9021            next_offset += envelope_size;
9022
9023            // Decode the remaining unknown envelopes.
9024            while next_offset < end_offset {
9025                _next_ordinal_to_read += 1;
9026                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9027                next_offset += envelope_size;
9028            }
9029
9030            Ok(())
9031        }
9032    }
9033
9034    impl InstanceIdEntry {
9035        #[inline(always)]
9036        fn max_ordinal_present(&self) -> u64 {
9037            if let Some(_) = self.moniker {
9038                return 3;
9039            }
9040            if let Some(_) = self.instance_id {
9041                return 1;
9042            }
9043            0
9044        }
9045    }
9046
9047    impl fidl::encoding::ValueTypeMarker for InstanceIdEntry {
9048        type Borrowed<'a> = &'a Self;
9049        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9050            value
9051        }
9052    }
9053
9054    unsafe impl fidl::encoding::TypeMarker for InstanceIdEntry {
9055        type Owned = Self;
9056
9057        #[inline(always)]
9058        fn inline_align(_context: fidl::encoding::Context) -> usize {
9059            8
9060        }
9061
9062        #[inline(always)]
9063        fn inline_size(_context: fidl::encoding::Context) -> usize {
9064            16
9065        }
9066    }
9067
9068    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InstanceIdEntry, D>
9069        for &InstanceIdEntry
9070    {
9071        unsafe fn encode(
9072            self,
9073            encoder: &mut fidl::encoding::Encoder<'_, D>,
9074            offset: usize,
9075            mut depth: fidl::encoding::Depth,
9076        ) -> fidl::Result<()> {
9077            encoder.debug_check_bounds::<InstanceIdEntry>(offset);
9078            // Vector header
9079            let max_ordinal: u64 = self.max_ordinal_present();
9080            encoder.write_num(max_ordinal, offset);
9081            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9082            // Calling encoder.out_of_line_offset(0) is not allowed.
9083            if max_ordinal == 0 {
9084                return Ok(());
9085            }
9086            depth.increment()?;
9087            let envelope_size = 8;
9088            let bytes_len = max_ordinal as usize * envelope_size;
9089            #[allow(unused_variables)]
9090            let offset = encoder.out_of_line_offset(bytes_len);
9091            let mut _prev_end_offset: usize = 0;
9092            if 1 > max_ordinal {
9093                return Ok(());
9094            }
9095
9096            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9097            // are envelope_size bytes.
9098            let cur_offset: usize = (1 - 1) * envelope_size;
9099
9100            // Zero reserved fields.
9101            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9102
9103            // Safety:
9104            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9105            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9106            //   envelope_size bytes, there is always sufficient room.
9107            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
9108                self.instance_id.as_ref().map(
9109                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
9110                ),
9111                encoder,
9112                offset + cur_offset,
9113                depth,
9114            )?;
9115
9116            _prev_end_offset = cur_offset + envelope_size;
9117            if 3 > max_ordinal {
9118                return Ok(());
9119            }
9120
9121            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9122            // are envelope_size bytes.
9123            let cur_offset: usize = (3 - 1) * envelope_size;
9124
9125            // Zero reserved fields.
9126            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9127
9128            // Safety:
9129            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9130            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9131            //   envelope_size bytes, there is always sufficient room.
9132            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
9133            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
9134            encoder, offset + cur_offset, depth
9135        )?;
9136
9137            _prev_end_offset = cur_offset + envelope_size;
9138
9139            Ok(())
9140        }
9141    }
9142
9143    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InstanceIdEntry {
9144        #[inline(always)]
9145        fn new_empty() -> Self {
9146            Self::default()
9147        }
9148
9149        unsafe fn decode(
9150            &mut self,
9151            decoder: &mut fidl::encoding::Decoder<'_, D>,
9152            offset: usize,
9153            mut depth: fidl::encoding::Depth,
9154        ) -> fidl::Result<()> {
9155            decoder.debug_check_bounds::<Self>(offset);
9156            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9157                None => return Err(fidl::Error::NotNullable),
9158                Some(len) => len,
9159            };
9160            // Calling decoder.out_of_line_offset(0) is not allowed.
9161            if len == 0 {
9162                return Ok(());
9163            };
9164            depth.increment()?;
9165            let envelope_size = 8;
9166            let bytes_len = len * envelope_size;
9167            let offset = decoder.out_of_line_offset(bytes_len)?;
9168            // Decode the envelope for each type.
9169            let mut _next_ordinal_to_read = 0;
9170            let mut next_offset = offset;
9171            let end_offset = offset + bytes_len;
9172            _next_ordinal_to_read += 1;
9173            if next_offset >= end_offset {
9174                return Ok(());
9175            }
9176
9177            // Decode unknown envelopes for gaps in ordinals.
9178            while _next_ordinal_to_read < 1 {
9179                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9180                _next_ordinal_to_read += 1;
9181                next_offset += envelope_size;
9182            }
9183
9184            let next_out_of_line = decoder.next_out_of_line();
9185            let handles_before = decoder.remaining_handles();
9186            if let Some((inlined, num_bytes, num_handles)) =
9187                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9188            {
9189                let member_inline_size =
9190                    <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
9191                        decoder.context,
9192                    );
9193                if inlined != (member_inline_size <= 4) {
9194                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9195                }
9196                let inner_offset;
9197                let mut inner_depth = depth.clone();
9198                if inlined {
9199                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9200                    inner_offset = next_offset;
9201                } else {
9202                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9203                    inner_depth.increment()?;
9204                }
9205                let val_ref = self
9206                    .instance_id
9207                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
9208                fidl::decode!(
9209                    fidl::encoding::BoundedString<64>,
9210                    D,
9211                    val_ref,
9212                    decoder,
9213                    inner_offset,
9214                    inner_depth
9215                )?;
9216                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9217                {
9218                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9219                }
9220                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9221                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9222                }
9223            }
9224
9225            next_offset += envelope_size;
9226            _next_ordinal_to_read += 1;
9227            if next_offset >= end_offset {
9228                return Ok(());
9229            }
9230
9231            // Decode unknown envelopes for gaps in ordinals.
9232            while _next_ordinal_to_read < 3 {
9233                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9234                _next_ordinal_to_read += 1;
9235                next_offset += envelope_size;
9236            }
9237
9238            let next_out_of_line = decoder.next_out_of_line();
9239            let handles_before = decoder.remaining_handles();
9240            if let Some((inlined, num_bytes, num_handles)) =
9241                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9242            {
9243                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9244                if inlined != (member_inline_size <= 4) {
9245                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9246                }
9247                let inner_offset;
9248                let mut inner_depth = depth.clone();
9249                if inlined {
9250                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9251                    inner_offset = next_offset;
9252                } else {
9253                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9254                    inner_depth.increment()?;
9255                }
9256                let val_ref = self.moniker.get_or_insert_with(|| {
9257                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
9258                });
9259                fidl::decode!(
9260                    fidl::encoding::BoundedString<4096>,
9261                    D,
9262                    val_ref,
9263                    decoder,
9264                    inner_offset,
9265                    inner_depth
9266                )?;
9267                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9268                {
9269                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9270                }
9271                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9272                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9273                }
9274            }
9275
9276            next_offset += envelope_size;
9277
9278            // Decode the remaining unknown envelopes.
9279            while next_offset < end_offset {
9280                _next_ordinal_to_read += 1;
9281                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9282                next_offset += envelope_size;
9283            }
9284
9285            Ok(())
9286        }
9287    }
9288
9289    impl JobPolicyAllowlists {
9290        #[inline(always)]
9291        fn max_ordinal_present(&self) -> u64 {
9292            if let Some(_) = self.create_raw_processes {
9293                return 3;
9294            }
9295            if let Some(_) = self.main_process_critical {
9296                return 2;
9297            }
9298            if let Some(_) = self.ambient_mark_vmo_exec {
9299                return 1;
9300            }
9301            0
9302        }
9303    }
9304
9305    impl fidl::encoding::ValueTypeMarker for JobPolicyAllowlists {
9306        type Borrowed<'a> = &'a Self;
9307        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9308            value
9309        }
9310    }
9311
9312    unsafe impl fidl::encoding::TypeMarker for JobPolicyAllowlists {
9313        type Owned = Self;
9314
9315        #[inline(always)]
9316        fn inline_align(_context: fidl::encoding::Context) -> usize {
9317            8
9318        }
9319
9320        #[inline(always)]
9321        fn inline_size(_context: fidl::encoding::Context) -> usize {
9322            16
9323        }
9324    }
9325
9326    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<JobPolicyAllowlists, D>
9327        for &JobPolicyAllowlists
9328    {
9329        unsafe fn encode(
9330            self,
9331            encoder: &mut fidl::encoding::Encoder<'_, D>,
9332            offset: usize,
9333            mut depth: fidl::encoding::Depth,
9334        ) -> fidl::Result<()> {
9335            encoder.debug_check_bounds::<JobPolicyAllowlists>(offset);
9336            // Vector header
9337            let max_ordinal: u64 = self.max_ordinal_present();
9338            encoder.write_num(max_ordinal, offset);
9339            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9340            // Calling encoder.out_of_line_offset(0) is not allowed.
9341            if max_ordinal == 0 {
9342                return Ok(());
9343            }
9344            depth.increment()?;
9345            let envelope_size = 8;
9346            let bytes_len = max_ordinal as usize * envelope_size;
9347            #[allow(unused_variables)]
9348            let offset = encoder.out_of_line_offset(bytes_len);
9349            let mut _prev_end_offset: usize = 0;
9350            if 1 > max_ordinal {
9351                return Ok(());
9352            }
9353
9354            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9355            // are envelope_size bytes.
9356            let cur_offset: usize = (1 - 1) * envelope_size;
9357
9358            // Zero reserved fields.
9359            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9360
9361            // Safety:
9362            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9363            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9364            //   envelope_size bytes, there is always sufficient room.
9365            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
9366            self.ambient_mark_vmo_exec.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
9367            encoder, offset + cur_offset, depth
9368        )?;
9369
9370            _prev_end_offset = cur_offset + envelope_size;
9371            if 2 > max_ordinal {
9372                return Ok(());
9373            }
9374
9375            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9376            // are envelope_size bytes.
9377            let cur_offset: usize = (2 - 1) * envelope_size;
9378
9379            // Zero reserved fields.
9380            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9381
9382            // Safety:
9383            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9384            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9385            //   envelope_size bytes, there is always sufficient room.
9386            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
9387            self.main_process_critical.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
9388            encoder, offset + cur_offset, depth
9389        )?;
9390
9391            _prev_end_offset = cur_offset + envelope_size;
9392            if 3 > max_ordinal {
9393                return Ok(());
9394            }
9395
9396            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9397            // are envelope_size bytes.
9398            let cur_offset: usize = (3 - 1) * envelope_size;
9399
9400            // Zero reserved fields.
9401            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9402
9403            // Safety:
9404            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9405            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9406            //   envelope_size bytes, there is always sufficient room.
9407            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
9408            self.create_raw_processes.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
9409            encoder, offset + cur_offset, 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 JobPolicyAllowlists {
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 = <fidl::encoding::Vector<
9465                    fidl::encoding::BoundedString<4096>,
9466                    128,
9467                > as fidl::encoding::TypeMarker>::inline_size(
9468                    decoder.context
9469                );
9470                if inlined != (member_inline_size <= 4) {
9471                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9472                }
9473                let inner_offset;
9474                let mut inner_depth = depth.clone();
9475                if inlined {
9476                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9477                    inner_offset = next_offset;
9478                } else {
9479                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9480                    inner_depth.increment()?;
9481                }
9482                let val_ref = self.ambient_mark_vmo_exec.get_or_insert_with(|| {
9483                    fidl::new_empty!(
9484                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
9485                        D
9486                    )
9487                });
9488                fidl::decode!(
9489                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
9490                    D,
9491                    val_ref,
9492                    decoder,
9493                    inner_offset,
9494                    inner_depth
9495                )?;
9496                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9497                {
9498                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9499                }
9500                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9501                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9502                }
9503            }
9504
9505            next_offset += envelope_size;
9506            _next_ordinal_to_read += 1;
9507            if next_offset >= end_offset {
9508                return Ok(());
9509            }
9510
9511            // Decode unknown envelopes for gaps in ordinals.
9512            while _next_ordinal_to_read < 2 {
9513                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9514                _next_ordinal_to_read += 1;
9515                next_offset += envelope_size;
9516            }
9517
9518            let next_out_of_line = decoder.next_out_of_line();
9519            let handles_before = decoder.remaining_handles();
9520            if let Some((inlined, num_bytes, num_handles)) =
9521                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9522            {
9523                let member_inline_size = <fidl::encoding::Vector<
9524                    fidl::encoding::BoundedString<4096>,
9525                    128,
9526                > as fidl::encoding::TypeMarker>::inline_size(
9527                    decoder.context
9528                );
9529                if inlined != (member_inline_size <= 4) {
9530                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9531                }
9532                let inner_offset;
9533                let mut inner_depth = depth.clone();
9534                if inlined {
9535                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9536                    inner_offset = next_offset;
9537                } else {
9538                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9539                    inner_depth.increment()?;
9540                }
9541                let val_ref = self.main_process_critical.get_or_insert_with(|| {
9542                    fidl::new_empty!(
9543                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
9544                        D
9545                    )
9546                });
9547                fidl::decode!(
9548                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
9549                    D,
9550                    val_ref,
9551                    decoder,
9552                    inner_offset,
9553                    inner_depth
9554                )?;
9555                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9556                {
9557                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9558                }
9559                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9560                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9561                }
9562            }
9563
9564            next_offset += envelope_size;
9565            _next_ordinal_to_read += 1;
9566            if next_offset >= end_offset {
9567                return Ok(());
9568            }
9569
9570            // Decode unknown envelopes for gaps in ordinals.
9571            while _next_ordinal_to_read < 3 {
9572                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9573                _next_ordinal_to_read += 1;
9574                next_offset += envelope_size;
9575            }
9576
9577            let next_out_of_line = decoder.next_out_of_line();
9578            let handles_before = decoder.remaining_handles();
9579            if let Some((inlined, num_bytes, num_handles)) =
9580                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9581            {
9582                let member_inline_size = <fidl::encoding::Vector<
9583                    fidl::encoding::BoundedString<4096>,
9584                    128,
9585                > as fidl::encoding::TypeMarker>::inline_size(
9586                    decoder.context
9587                );
9588                if inlined != (member_inline_size <= 4) {
9589                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9590                }
9591                let inner_offset;
9592                let mut inner_depth = depth.clone();
9593                if inlined {
9594                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9595                    inner_offset = next_offset;
9596                } else {
9597                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9598                    inner_depth.increment()?;
9599                }
9600                let val_ref = self.create_raw_processes.get_or_insert_with(|| {
9601                    fidl::new_empty!(
9602                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
9603                        D
9604                    )
9605                });
9606                fidl::decode!(
9607                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
9608                    D,
9609                    val_ref,
9610                    decoder,
9611                    inner_offset,
9612                    inner_depth
9613                )?;
9614                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9615                {
9616                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9617                }
9618                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9619                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9620                }
9621            }
9622
9623            next_offset += envelope_size;
9624
9625            // Decode the remaining unknown envelopes.
9626            while next_offset < end_offset {
9627                _next_ordinal_to_read += 1;
9628                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9629                next_offset += envelope_size;
9630            }
9631
9632            Ok(())
9633        }
9634    }
9635
9636    impl Namespace {
9637        #[inline(always)]
9638        fn max_ordinal_present(&self) -> u64 {
9639            if let Some(_) = self.capability {
9640                return 1;
9641            }
9642            0
9643        }
9644    }
9645
9646    impl fidl::encoding::ValueTypeMarker for Namespace {
9647        type Borrowed<'a> = &'a Self;
9648        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9649            value
9650        }
9651    }
9652
9653    unsafe impl fidl::encoding::TypeMarker for Namespace {
9654        type Owned = Self;
9655
9656        #[inline(always)]
9657        fn inline_align(_context: fidl::encoding::Context) -> usize {
9658            8
9659        }
9660
9661        #[inline(always)]
9662        fn inline_size(_context: fidl::encoding::Context) -> usize {
9663            16
9664        }
9665    }
9666
9667    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Namespace, D>
9668        for &Namespace
9669    {
9670        unsafe fn encode(
9671            self,
9672            encoder: &mut fidl::encoding::Encoder<'_, D>,
9673            offset: usize,
9674            mut depth: fidl::encoding::Depth,
9675        ) -> fidl::Result<()> {
9676            encoder.debug_check_bounds::<Namespace>(offset);
9677            // Vector header
9678            let max_ordinal: u64 = self.max_ordinal_present();
9679            encoder.write_num(max_ordinal, offset);
9680            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9681            // Calling encoder.out_of_line_offset(0) is not allowed.
9682            if max_ordinal == 0 {
9683                return Ok(());
9684            }
9685            depth.increment()?;
9686            let envelope_size = 8;
9687            let bytes_len = max_ordinal as usize * envelope_size;
9688            #[allow(unused_variables)]
9689            let offset = encoder.out_of_line_offset(bytes_len);
9690            let mut _prev_end_offset: usize = 0;
9691            if 1 > max_ordinal {
9692                return Ok(());
9693            }
9694
9695            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9696            // are envelope_size bytes.
9697            let cur_offset: usize = (1 - 1) * envelope_size;
9698
9699            // Zero reserved fields.
9700            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9701
9702            // Safety:
9703            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9704            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9705            //   envelope_size bytes, there is always sufficient room.
9706            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
9707                self.capability
9708                    .as_ref()
9709                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
9710                encoder,
9711                offset + cur_offset,
9712                depth,
9713            )?;
9714
9715            _prev_end_offset = cur_offset + envelope_size;
9716
9717            Ok(())
9718        }
9719    }
9720
9721    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Namespace {
9722        #[inline(always)]
9723        fn new_empty() -> Self {
9724            Self::default()
9725        }
9726
9727        unsafe fn decode(
9728            &mut self,
9729            decoder: &mut fidl::encoding::Decoder<'_, D>,
9730            offset: usize,
9731            mut depth: fidl::encoding::Depth,
9732        ) -> fidl::Result<()> {
9733            decoder.debug_check_bounds::<Self>(offset);
9734            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9735                None => return Err(fidl::Error::NotNullable),
9736                Some(len) => len,
9737            };
9738            // Calling decoder.out_of_line_offset(0) is not allowed.
9739            if len == 0 {
9740                return Ok(());
9741            };
9742            depth.increment()?;
9743            let envelope_size = 8;
9744            let bytes_len = len * envelope_size;
9745            let offset = decoder.out_of_line_offset(bytes_len)?;
9746            // Decode the envelope for each type.
9747            let mut _next_ordinal_to_read = 0;
9748            let mut next_offset = offset;
9749            let end_offset = offset + bytes_len;
9750            _next_ordinal_to_read += 1;
9751            if next_offset >= end_offset {
9752                return Ok(());
9753            }
9754
9755            // Decode unknown envelopes for gaps in ordinals.
9756            while _next_ordinal_to_read < 1 {
9757                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9758                _next_ordinal_to_read += 1;
9759                next_offset += envelope_size;
9760            }
9761
9762            let next_out_of_line = decoder.next_out_of_line();
9763            let handles_before = decoder.remaining_handles();
9764            if let Some((inlined, num_bytes, num_handles)) =
9765                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9766            {
9767                let member_inline_size =
9768                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
9769                        decoder.context,
9770                    );
9771                if inlined != (member_inline_size <= 4) {
9772                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9773                }
9774                let inner_offset;
9775                let mut inner_depth = depth.clone();
9776                if inlined {
9777                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9778                    inner_offset = next_offset;
9779                } else {
9780                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9781                    inner_depth.increment()?;
9782                }
9783                let val_ref =
9784                    self.capability.get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
9785                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
9786                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9787                {
9788                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9789                }
9790                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9791                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9792                }
9793            }
9794
9795            next_offset += envelope_size;
9796
9797            // Decode the remaining unknown envelopes.
9798            while next_offset < end_offset {
9799                _next_ordinal_to_read += 1;
9800                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9801                next_offset += envelope_size;
9802            }
9803
9804            Ok(())
9805        }
9806    }
9807
9808    impl SecurityPolicy {
9809        #[inline(always)]
9810        fn max_ordinal_present(&self) -> u64 {
9811            if let Some(_) = self.child_policy {
9812                return 4;
9813            }
9814            if let Some(_) = self.debug_registration_policy {
9815                return 3;
9816            }
9817            if let Some(_) = self.capability_policy {
9818                return 2;
9819            }
9820            if let Some(_) = self.job_policy {
9821                return 1;
9822            }
9823            0
9824        }
9825    }
9826
9827    impl fidl::encoding::ValueTypeMarker for SecurityPolicy {
9828        type Borrowed<'a> = &'a Self;
9829        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9830            value
9831        }
9832    }
9833
9834    unsafe impl fidl::encoding::TypeMarker for SecurityPolicy {
9835        type Owned = Self;
9836
9837        #[inline(always)]
9838        fn inline_align(_context: fidl::encoding::Context) -> usize {
9839            8
9840        }
9841
9842        #[inline(always)]
9843        fn inline_size(_context: fidl::encoding::Context) -> usize {
9844            16
9845        }
9846    }
9847
9848    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SecurityPolicy, D>
9849        for &SecurityPolicy
9850    {
9851        unsafe fn encode(
9852            self,
9853            encoder: &mut fidl::encoding::Encoder<'_, D>,
9854            offset: usize,
9855            mut depth: fidl::encoding::Depth,
9856        ) -> fidl::Result<()> {
9857            encoder.debug_check_bounds::<SecurityPolicy>(offset);
9858            // Vector header
9859            let max_ordinal: u64 = self.max_ordinal_present();
9860            encoder.write_num(max_ordinal, offset);
9861            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9862            // Calling encoder.out_of_line_offset(0) is not allowed.
9863            if max_ordinal == 0 {
9864                return Ok(());
9865            }
9866            depth.increment()?;
9867            let envelope_size = 8;
9868            let bytes_len = max_ordinal as usize * envelope_size;
9869            #[allow(unused_variables)]
9870            let offset = encoder.out_of_line_offset(bytes_len);
9871            let mut _prev_end_offset: usize = 0;
9872            if 1 > max_ordinal {
9873                return Ok(());
9874            }
9875
9876            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9877            // are envelope_size bytes.
9878            let cur_offset: usize = (1 - 1) * envelope_size;
9879
9880            // Zero reserved fields.
9881            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9882
9883            // Safety:
9884            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9885            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9886            //   envelope_size bytes, there is always sufficient room.
9887            fidl::encoding::encode_in_envelope_optional::<JobPolicyAllowlists, D>(
9888                self.job_policy
9889                    .as_ref()
9890                    .map(<JobPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow),
9891                encoder,
9892                offset + cur_offset,
9893                depth,
9894            )?;
9895
9896            _prev_end_offset = cur_offset + envelope_size;
9897            if 2 > max_ordinal {
9898                return Ok(());
9899            }
9900
9901            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9902            // are envelope_size bytes.
9903            let cur_offset: usize = (2 - 1) * envelope_size;
9904
9905            // Zero reserved fields.
9906            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9907
9908            // Safety:
9909            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9910            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9911            //   envelope_size bytes, there is always sufficient room.
9912            fidl::encoding::encode_in_envelope_optional::<CapabilityPolicyAllowlists, D>(
9913                self.capability_policy
9914                    .as_ref()
9915                    .map(<CapabilityPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow),
9916                encoder,
9917                offset + cur_offset,
9918                depth,
9919            )?;
9920
9921            _prev_end_offset = cur_offset + envelope_size;
9922            if 3 > max_ordinal {
9923                return Ok(());
9924            }
9925
9926            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9927            // are envelope_size bytes.
9928            let cur_offset: usize = (3 - 1) * envelope_size;
9929
9930            // Zero reserved fields.
9931            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9932
9933            // Safety:
9934            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9935            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9936            //   envelope_size bytes, there is always sufficient room.
9937            fidl::encoding::encode_in_envelope_optional::<DebugRegistrationPolicyAllowlists, D>(
9938                self.debug_registration_policy.as_ref().map(
9939                    <DebugRegistrationPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow,
9940                ),
9941                encoder,
9942                offset + cur_offset,
9943                depth,
9944            )?;
9945
9946            _prev_end_offset = cur_offset + envelope_size;
9947            if 4 > max_ordinal {
9948                return Ok(());
9949            }
9950
9951            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9952            // are envelope_size bytes.
9953            let cur_offset: usize = (4 - 1) * envelope_size;
9954
9955            // Zero reserved fields.
9956            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9957
9958            // Safety:
9959            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9960            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9961            //   envelope_size bytes, there is always sufficient room.
9962            fidl::encoding::encode_in_envelope_optional::<ChildPolicyAllowlists, D>(
9963                self.child_policy
9964                    .as_ref()
9965                    .map(<ChildPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow),
9966                encoder,
9967                offset + cur_offset,
9968                depth,
9969            )?;
9970
9971            _prev_end_offset = cur_offset + envelope_size;
9972
9973            Ok(())
9974        }
9975    }
9976
9977    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SecurityPolicy {
9978        #[inline(always)]
9979        fn new_empty() -> Self {
9980            Self::default()
9981        }
9982
9983        unsafe fn decode(
9984            &mut self,
9985            decoder: &mut fidl::encoding::Decoder<'_, D>,
9986            offset: usize,
9987            mut depth: fidl::encoding::Depth,
9988        ) -> fidl::Result<()> {
9989            decoder.debug_check_bounds::<Self>(offset);
9990            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9991                None => return Err(fidl::Error::NotNullable),
9992                Some(len) => len,
9993            };
9994            // Calling decoder.out_of_line_offset(0) is not allowed.
9995            if len == 0 {
9996                return Ok(());
9997            };
9998            depth.increment()?;
9999            let envelope_size = 8;
10000            let bytes_len = len * envelope_size;
10001            let offset = decoder.out_of_line_offset(bytes_len)?;
10002            // Decode the envelope for each type.
10003            let mut _next_ordinal_to_read = 0;
10004            let mut next_offset = offset;
10005            let end_offset = offset + bytes_len;
10006            _next_ordinal_to_read += 1;
10007            if next_offset >= end_offset {
10008                return Ok(());
10009            }
10010
10011            // Decode unknown envelopes for gaps in ordinals.
10012            while _next_ordinal_to_read < 1 {
10013                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10014                _next_ordinal_to_read += 1;
10015                next_offset += envelope_size;
10016            }
10017
10018            let next_out_of_line = decoder.next_out_of_line();
10019            let handles_before = decoder.remaining_handles();
10020            if let Some((inlined, num_bytes, num_handles)) =
10021                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10022            {
10023                let member_inline_size =
10024                    <JobPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
10025                        decoder.context,
10026                    );
10027                if inlined != (member_inline_size <= 4) {
10028                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10029                }
10030                let inner_offset;
10031                let mut inner_depth = depth.clone();
10032                if inlined {
10033                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10034                    inner_offset = next_offset;
10035                } else {
10036                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10037                    inner_depth.increment()?;
10038                }
10039                let val_ref =
10040                    self.job_policy.get_or_insert_with(|| fidl::new_empty!(JobPolicyAllowlists, D));
10041                fidl::decode!(JobPolicyAllowlists, D, val_ref, decoder, inner_offset, inner_depth)?;
10042                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10043                {
10044                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10045                }
10046                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10047                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10048                }
10049            }
10050
10051            next_offset += envelope_size;
10052            _next_ordinal_to_read += 1;
10053            if next_offset >= end_offset {
10054                return Ok(());
10055            }
10056
10057            // Decode unknown envelopes for gaps in ordinals.
10058            while _next_ordinal_to_read < 2 {
10059                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10060                _next_ordinal_to_read += 1;
10061                next_offset += envelope_size;
10062            }
10063
10064            let next_out_of_line = decoder.next_out_of_line();
10065            let handles_before = decoder.remaining_handles();
10066            if let Some((inlined, num_bytes, num_handles)) =
10067                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10068            {
10069                let member_inline_size =
10070                    <CapabilityPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
10071                        decoder.context,
10072                    );
10073                if inlined != (member_inline_size <= 4) {
10074                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10075                }
10076                let inner_offset;
10077                let mut inner_depth = depth.clone();
10078                if inlined {
10079                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10080                    inner_offset = next_offset;
10081                } else {
10082                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10083                    inner_depth.increment()?;
10084                }
10085                let val_ref = self
10086                    .capability_policy
10087                    .get_or_insert_with(|| fidl::new_empty!(CapabilityPolicyAllowlists, D));
10088                fidl::decode!(
10089                    CapabilityPolicyAllowlists,
10090                    D,
10091                    val_ref,
10092                    decoder,
10093                    inner_offset,
10094                    inner_depth
10095                )?;
10096                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10097                {
10098                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10099                }
10100                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10101                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10102                }
10103            }
10104
10105            next_offset += envelope_size;
10106            _next_ordinal_to_read += 1;
10107            if next_offset >= end_offset {
10108                return Ok(());
10109            }
10110
10111            // Decode unknown envelopes for gaps in ordinals.
10112            while _next_ordinal_to_read < 3 {
10113                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10114                _next_ordinal_to_read += 1;
10115                next_offset += envelope_size;
10116            }
10117
10118            let next_out_of_line = decoder.next_out_of_line();
10119            let handles_before = decoder.remaining_handles();
10120            if let Some((inlined, num_bytes, num_handles)) =
10121                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10122            {
10123                let member_inline_size =
10124                    <DebugRegistrationPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
10125                        decoder.context,
10126                    );
10127                if inlined != (member_inline_size <= 4) {
10128                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10129                }
10130                let inner_offset;
10131                let mut inner_depth = depth.clone();
10132                if inlined {
10133                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10134                    inner_offset = next_offset;
10135                } else {
10136                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10137                    inner_depth.increment()?;
10138                }
10139                let val_ref = self
10140                    .debug_registration_policy
10141                    .get_or_insert_with(|| fidl::new_empty!(DebugRegistrationPolicyAllowlists, D));
10142                fidl::decode!(
10143                    DebugRegistrationPolicyAllowlists,
10144                    D,
10145                    val_ref,
10146                    decoder,
10147                    inner_offset,
10148                    inner_depth
10149                )?;
10150                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10151                {
10152                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10153                }
10154                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10155                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10156                }
10157            }
10158
10159            next_offset += envelope_size;
10160            _next_ordinal_to_read += 1;
10161            if next_offset >= end_offset {
10162                return Ok(());
10163            }
10164
10165            // Decode unknown envelopes for gaps in ordinals.
10166            while _next_ordinal_to_read < 4 {
10167                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10168                _next_ordinal_to_read += 1;
10169                next_offset += envelope_size;
10170            }
10171
10172            let next_out_of_line = decoder.next_out_of_line();
10173            let handles_before = decoder.remaining_handles();
10174            if let Some((inlined, num_bytes, num_handles)) =
10175                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10176            {
10177                let member_inline_size =
10178                    <ChildPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
10179                        decoder.context,
10180                    );
10181                if inlined != (member_inline_size <= 4) {
10182                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10183                }
10184                let inner_offset;
10185                let mut inner_depth = depth.clone();
10186                if inlined {
10187                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10188                    inner_offset = next_offset;
10189                } else {
10190                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10191                    inner_depth.increment()?;
10192                }
10193                let val_ref = self
10194                    .child_policy
10195                    .get_or_insert_with(|| fidl::new_empty!(ChildPolicyAllowlists, D));
10196                fidl::decode!(
10197                    ChildPolicyAllowlists,
10198                    D,
10199                    val_ref,
10200                    decoder,
10201                    inner_offset,
10202                    inner_depth
10203                )?;
10204                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10205                {
10206                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10207                }
10208                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10209                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10210                }
10211            }
10212
10213            next_offset += envelope_size;
10214
10215            // Decode the remaining unknown envelopes.
10216            while next_offset < end_offset {
10217                _next_ordinal_to_read += 1;
10218                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10219                next_offset += envelope_size;
10220            }
10221
10222            Ok(())
10223        }
10224    }
10225
10226    impl Sources {
10227        #[inline(always)]
10228        fn max_ordinal_present(&self) -> u64 {
10229            if let Some(_) = self.capability_type {
10230                return 7;
10231            }
10232            if let Some(_) = self.component {
10233                return 6;
10234            }
10235            if let Some(_) = self.namespace {
10236                return 5;
10237            }
10238            if let Some(_) = self.collection {
10239                return 4;
10240            }
10241            if let Some(_) = self.capability {
10242                return 3;
10243            }
10244            if let Some(_) = self.builtin {
10245                return 2;
10246            }
10247            if let Some(_) = self.framework {
10248                return 1;
10249            }
10250            0
10251        }
10252    }
10253
10254    impl fidl::encoding::ValueTypeMarker for Sources {
10255        type Borrowed<'a> = &'a Self;
10256        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10257            value
10258        }
10259    }
10260
10261    unsafe impl fidl::encoding::TypeMarker for Sources {
10262        type Owned = Self;
10263
10264        #[inline(always)]
10265        fn inline_align(_context: fidl::encoding::Context) -> usize {
10266            8
10267        }
10268
10269        #[inline(always)]
10270        fn inline_size(_context: fidl::encoding::Context) -> usize {
10271            16
10272        }
10273    }
10274
10275    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Sources, D> for &Sources {
10276        unsafe fn encode(
10277            self,
10278            encoder: &mut fidl::encoding::Encoder<'_, D>,
10279            offset: usize,
10280            mut depth: fidl::encoding::Depth,
10281        ) -> fidl::Result<()> {
10282            encoder.debug_check_bounds::<Sources>(offset);
10283            // Vector header
10284            let max_ordinal: u64 = self.max_ordinal_present();
10285            encoder.write_num(max_ordinal, offset);
10286            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10287            // Calling encoder.out_of_line_offset(0) is not allowed.
10288            if max_ordinal == 0 {
10289                return Ok(());
10290            }
10291            depth.increment()?;
10292            let envelope_size = 8;
10293            let bytes_len = max_ordinal as usize * envelope_size;
10294            #[allow(unused_variables)]
10295            let offset = encoder.out_of_line_offset(bytes_len);
10296            let mut _prev_end_offset: usize = 0;
10297            if 1 > max_ordinal {
10298                return Ok(());
10299            }
10300
10301            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10302            // are envelope_size bytes.
10303            let cur_offset: usize = (1 - 1) * envelope_size;
10304
10305            // Zero reserved fields.
10306            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10307
10308            // Safety:
10309            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10310            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10311            //   envelope_size bytes, there is always sufficient room.
10312            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10313                self.framework.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10314                encoder,
10315                offset + cur_offset,
10316                depth,
10317            )?;
10318
10319            _prev_end_offset = cur_offset + envelope_size;
10320            if 2 > max_ordinal {
10321                return Ok(());
10322            }
10323
10324            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10325            // are envelope_size bytes.
10326            let cur_offset: usize = (2 - 1) * envelope_size;
10327
10328            // Zero reserved fields.
10329            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10330
10331            // Safety:
10332            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10333            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10334            //   envelope_size bytes, there is always sufficient room.
10335            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10336                self.builtin.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10337                encoder,
10338                offset + cur_offset,
10339                depth,
10340            )?;
10341
10342            _prev_end_offset = cur_offset + envelope_size;
10343            if 3 > max_ordinal {
10344                return Ok(());
10345            }
10346
10347            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10348            // are envelope_size bytes.
10349            let cur_offset: usize = (3 - 1) * envelope_size;
10350
10351            // Zero reserved fields.
10352            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10353
10354            // Safety:
10355            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10356            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10357            //   envelope_size bytes, there is always sufficient room.
10358            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10359                self.capability.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10360                encoder,
10361                offset + cur_offset,
10362                depth,
10363            )?;
10364
10365            _prev_end_offset = cur_offset + envelope_size;
10366            if 4 > max_ordinal {
10367                return Ok(());
10368            }
10369
10370            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10371            // are envelope_size bytes.
10372            let cur_offset: usize = (4 - 1) * envelope_size;
10373
10374            // Zero reserved fields.
10375            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10376
10377            // Safety:
10378            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10379            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10380            //   envelope_size bytes, there is always sufficient room.
10381            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10382                self.collection.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10383                encoder,
10384                offset + cur_offset,
10385                depth,
10386            )?;
10387
10388            _prev_end_offset = cur_offset + envelope_size;
10389            if 5 > max_ordinal {
10390                return Ok(());
10391            }
10392
10393            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10394            // are envelope_size bytes.
10395            let cur_offset: usize = (5 - 1) * envelope_size;
10396
10397            // Zero reserved fields.
10398            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10399
10400            // Safety:
10401            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10402            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10403            //   envelope_size bytes, there is always sufficient room.
10404            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10405                self.namespace.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10406                encoder,
10407                offset + cur_offset,
10408                depth,
10409            )?;
10410
10411            _prev_end_offset = cur_offset + envelope_size;
10412            if 6 > max_ordinal {
10413                return Ok(());
10414            }
10415
10416            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10417            // are envelope_size bytes.
10418            let cur_offset: usize = (6 - 1) * envelope_size;
10419
10420            // Zero reserved fields.
10421            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10422
10423            // Safety:
10424            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10425            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10426            //   envelope_size bytes, there is always sufficient room.
10427            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10428                self.component.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10429                encoder,
10430                offset + cur_offset,
10431                depth,
10432            )?;
10433
10434            _prev_end_offset = cur_offset + envelope_size;
10435            if 7 > max_ordinal {
10436                return Ok(());
10437            }
10438
10439            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10440            // are envelope_size bytes.
10441            let cur_offset: usize = (7 - 1) * envelope_size;
10442
10443            // Zero reserved fields.
10444            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10445
10446            // Safety:
10447            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10448            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10449            //   envelope_size bytes, there is always sufficient room.
10450            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
10451                self.capability_type.as_ref().map(
10452                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
10453                ),
10454                encoder,
10455                offset + cur_offset,
10456                depth,
10457            )?;
10458
10459            _prev_end_offset = cur_offset + envelope_size;
10460
10461            Ok(())
10462        }
10463    }
10464
10465    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Sources {
10466        #[inline(always)]
10467        fn new_empty() -> Self {
10468            Self::default()
10469        }
10470
10471        unsafe fn decode(
10472            &mut self,
10473            decoder: &mut fidl::encoding::Decoder<'_, D>,
10474            offset: usize,
10475            mut depth: fidl::encoding::Depth,
10476        ) -> fidl::Result<()> {
10477            decoder.debug_check_bounds::<Self>(offset);
10478            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10479                None => return Err(fidl::Error::NotNullable),
10480                Some(len) => len,
10481            };
10482            // Calling decoder.out_of_line_offset(0) is not allowed.
10483            if len == 0 {
10484                return Ok(());
10485            };
10486            depth.increment()?;
10487            let envelope_size = 8;
10488            let bytes_len = len * envelope_size;
10489            let offset = decoder.out_of_line_offset(bytes_len)?;
10490            // Decode the envelope for each type.
10491            let mut _next_ordinal_to_read = 0;
10492            let mut next_offset = offset;
10493            let end_offset = offset + bytes_len;
10494            _next_ordinal_to_read += 1;
10495            if next_offset >= end_offset {
10496                return Ok(());
10497            }
10498
10499            // Decode unknown envelopes for gaps in ordinals.
10500            while _next_ordinal_to_read < 1 {
10501                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10502                _next_ordinal_to_read += 1;
10503                next_offset += envelope_size;
10504            }
10505
10506            let next_out_of_line = decoder.next_out_of_line();
10507            let handles_before = decoder.remaining_handles();
10508            if let Some((inlined, num_bytes, num_handles)) =
10509                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10510            {
10511                let member_inline_size =
10512                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10513                if inlined != (member_inline_size <= 4) {
10514                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10515                }
10516                let inner_offset;
10517                let mut inner_depth = depth.clone();
10518                if inlined {
10519                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10520                    inner_offset = next_offset;
10521                } else {
10522                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10523                    inner_depth.increment()?;
10524                }
10525                let val_ref = self.framework.get_or_insert_with(|| fidl::new_empty!(bool, D));
10526                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10527                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10528                {
10529                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10530                }
10531                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10532                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10533                }
10534            }
10535
10536            next_offset += envelope_size;
10537            _next_ordinal_to_read += 1;
10538            if next_offset >= end_offset {
10539                return Ok(());
10540            }
10541
10542            // Decode unknown envelopes for gaps in ordinals.
10543            while _next_ordinal_to_read < 2 {
10544                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10545                _next_ordinal_to_read += 1;
10546                next_offset += envelope_size;
10547            }
10548
10549            let next_out_of_line = decoder.next_out_of_line();
10550            let handles_before = decoder.remaining_handles();
10551            if let Some((inlined, num_bytes, num_handles)) =
10552                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10553            {
10554                let member_inline_size =
10555                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10556                if inlined != (member_inline_size <= 4) {
10557                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10558                }
10559                let inner_offset;
10560                let mut inner_depth = depth.clone();
10561                if inlined {
10562                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10563                    inner_offset = next_offset;
10564                } else {
10565                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10566                    inner_depth.increment()?;
10567                }
10568                let val_ref = self.builtin.get_or_insert_with(|| fidl::new_empty!(bool, D));
10569                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10570                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10571                {
10572                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10573                }
10574                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10575                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10576                }
10577            }
10578
10579            next_offset += envelope_size;
10580            _next_ordinal_to_read += 1;
10581            if next_offset >= end_offset {
10582                return Ok(());
10583            }
10584
10585            // Decode unknown envelopes for gaps in ordinals.
10586            while _next_ordinal_to_read < 3 {
10587                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10588                _next_ordinal_to_read += 1;
10589                next_offset += envelope_size;
10590            }
10591
10592            let next_out_of_line = decoder.next_out_of_line();
10593            let handles_before = decoder.remaining_handles();
10594            if let Some((inlined, num_bytes, num_handles)) =
10595                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10596            {
10597                let member_inline_size =
10598                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10599                if inlined != (member_inline_size <= 4) {
10600                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10601                }
10602                let inner_offset;
10603                let mut inner_depth = depth.clone();
10604                if inlined {
10605                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10606                    inner_offset = next_offset;
10607                } else {
10608                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10609                    inner_depth.increment()?;
10610                }
10611                let val_ref = self.capability.get_or_insert_with(|| fidl::new_empty!(bool, D));
10612                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10613                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10614                {
10615                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10616                }
10617                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10618                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10619                }
10620            }
10621
10622            next_offset += envelope_size;
10623            _next_ordinal_to_read += 1;
10624            if next_offset >= end_offset {
10625                return Ok(());
10626            }
10627
10628            // Decode unknown envelopes for gaps in ordinals.
10629            while _next_ordinal_to_read < 4 {
10630                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10631                _next_ordinal_to_read += 1;
10632                next_offset += envelope_size;
10633            }
10634
10635            let next_out_of_line = decoder.next_out_of_line();
10636            let handles_before = decoder.remaining_handles();
10637            if let Some((inlined, num_bytes, num_handles)) =
10638                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10639            {
10640                let member_inline_size =
10641                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10642                if inlined != (member_inline_size <= 4) {
10643                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10644                }
10645                let inner_offset;
10646                let mut inner_depth = depth.clone();
10647                if inlined {
10648                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10649                    inner_offset = next_offset;
10650                } else {
10651                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10652                    inner_depth.increment()?;
10653                }
10654                let val_ref = self.collection.get_or_insert_with(|| fidl::new_empty!(bool, D));
10655                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10656                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10657                {
10658                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10659                }
10660                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10661                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10662                }
10663            }
10664
10665            next_offset += envelope_size;
10666            _next_ordinal_to_read += 1;
10667            if next_offset >= end_offset {
10668                return Ok(());
10669            }
10670
10671            // Decode unknown envelopes for gaps in ordinals.
10672            while _next_ordinal_to_read < 5 {
10673                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10674                _next_ordinal_to_read += 1;
10675                next_offset += envelope_size;
10676            }
10677
10678            let next_out_of_line = decoder.next_out_of_line();
10679            let handles_before = decoder.remaining_handles();
10680            if let Some((inlined, num_bytes, num_handles)) =
10681                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10682            {
10683                let member_inline_size =
10684                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10685                if inlined != (member_inline_size <= 4) {
10686                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10687                }
10688                let inner_offset;
10689                let mut inner_depth = depth.clone();
10690                if inlined {
10691                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10692                    inner_offset = next_offset;
10693                } else {
10694                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10695                    inner_depth.increment()?;
10696                }
10697                let val_ref = self.namespace.get_or_insert_with(|| fidl::new_empty!(bool, D));
10698                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10699                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10700                {
10701                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10702                }
10703                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10704                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10705                }
10706            }
10707
10708            next_offset += envelope_size;
10709            _next_ordinal_to_read += 1;
10710            if next_offset >= end_offset {
10711                return Ok(());
10712            }
10713
10714            // Decode unknown envelopes for gaps in ordinals.
10715            while _next_ordinal_to_read < 6 {
10716                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10717                _next_ordinal_to_read += 1;
10718                next_offset += envelope_size;
10719            }
10720
10721            let next_out_of_line = decoder.next_out_of_line();
10722            let handles_before = decoder.remaining_handles();
10723            if let Some((inlined, num_bytes, num_handles)) =
10724                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10725            {
10726                let member_inline_size =
10727                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10728                if inlined != (member_inline_size <= 4) {
10729                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10730                }
10731                let inner_offset;
10732                let mut inner_depth = depth.clone();
10733                if inlined {
10734                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10735                    inner_offset = next_offset;
10736                } else {
10737                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10738                    inner_depth.increment()?;
10739                }
10740                let val_ref = self.component.get_or_insert_with(|| fidl::new_empty!(bool, D));
10741                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10742                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10743                {
10744                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10745                }
10746                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10747                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10748                }
10749            }
10750
10751            next_offset += envelope_size;
10752            _next_ordinal_to_read += 1;
10753            if next_offset >= end_offset {
10754                return Ok(());
10755            }
10756
10757            // Decode unknown envelopes for gaps in ordinals.
10758            while _next_ordinal_to_read < 7 {
10759                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10760                _next_ordinal_to_read += 1;
10761                next_offset += envelope_size;
10762            }
10763
10764            let next_out_of_line = decoder.next_out_of_line();
10765            let handles_before = decoder.remaining_handles();
10766            if let Some((inlined, num_bytes, num_handles)) =
10767                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10768            {
10769                let member_inline_size =
10770                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
10771                        decoder.context,
10772                    );
10773                if inlined != (member_inline_size <= 4) {
10774                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10775                }
10776                let inner_offset;
10777                let mut inner_depth = depth.clone();
10778                if inlined {
10779                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10780                    inner_offset = next_offset;
10781                } else {
10782                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10783                    inner_depth.increment()?;
10784                }
10785                let val_ref = self
10786                    .capability_type
10787                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
10788                fidl::decode!(
10789                    fidl::encoding::BoundedString<100>,
10790                    D,
10791                    val_ref,
10792                    decoder,
10793                    inner_offset,
10794                    inner_depth
10795                )?;
10796                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10797                {
10798                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10799                }
10800                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10801                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10802                }
10803            }
10804
10805            next_offset += envelope_size;
10806
10807            // Decode the remaining unknown envelopes.
10808            while next_offset < end_offset {
10809                _next_ordinal_to_read += 1;
10810                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10811                next_offset += envelope_size;
10812            }
10813
10814            Ok(())
10815        }
10816    }
10817
10818    impl StorageBackingDirectory {
10819        #[inline(always)]
10820        fn max_ordinal_present(&self) -> u64 {
10821            if let Some(_) = self.storage_source_moniker {
10822                return 5;
10823            }
10824            if let Some(_) = self.storage_subdir {
10825                return 4;
10826            }
10827            if let Some(_) = self.backing_dir_subdir {
10828                return 3;
10829            }
10830            if let Some(_) = self.moniker {
10831                return 2;
10832            }
10833            if let Some(_) = self.capability {
10834                return 1;
10835            }
10836            0
10837        }
10838    }
10839
10840    impl fidl::encoding::ValueTypeMarker for StorageBackingDirectory {
10841        type Borrowed<'a> = &'a Self;
10842        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10843            value
10844        }
10845    }
10846
10847    unsafe impl fidl::encoding::TypeMarker for StorageBackingDirectory {
10848        type Owned = Self;
10849
10850        #[inline(always)]
10851        fn inline_align(_context: fidl::encoding::Context) -> usize {
10852            8
10853        }
10854
10855        #[inline(always)]
10856        fn inline_size(_context: fidl::encoding::Context) -> usize {
10857            16
10858        }
10859    }
10860
10861    unsafe impl<D: fidl::encoding::ResourceDialect>
10862        fidl::encoding::Encode<StorageBackingDirectory, D> for &StorageBackingDirectory
10863    {
10864        unsafe fn encode(
10865            self,
10866            encoder: &mut fidl::encoding::Encoder<'_, D>,
10867            offset: usize,
10868            mut depth: fidl::encoding::Depth,
10869        ) -> fidl::Result<()> {
10870            encoder.debug_check_bounds::<StorageBackingDirectory>(offset);
10871            // Vector header
10872            let max_ordinal: u64 = self.max_ordinal_present();
10873            encoder.write_num(max_ordinal, offset);
10874            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10875            // Calling encoder.out_of_line_offset(0) is not allowed.
10876            if max_ordinal == 0 {
10877                return Ok(());
10878            }
10879            depth.increment()?;
10880            let envelope_size = 8;
10881            let bytes_len = max_ordinal as usize * envelope_size;
10882            #[allow(unused_variables)]
10883            let offset = encoder.out_of_line_offset(bytes_len);
10884            let mut _prev_end_offset: usize = 0;
10885            if 1 > max_ordinal {
10886                return Ok(());
10887            }
10888
10889            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10890            // are envelope_size bytes.
10891            let cur_offset: usize = (1 - 1) * envelope_size;
10892
10893            // Zero reserved fields.
10894            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10895
10896            // Safety:
10897            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10898            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10899            //   envelope_size bytes, there is always sufficient room.
10900            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
10901                self.capability
10902                    .as_ref()
10903                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
10904                encoder,
10905                offset + cur_offset,
10906                depth,
10907            )?;
10908
10909            _prev_end_offset = cur_offset + envelope_size;
10910            if 2 > max_ordinal {
10911                return Ok(());
10912            }
10913
10914            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10915            // are envelope_size bytes.
10916            let cur_offset: usize = (2 - 1) * envelope_size;
10917
10918            // Zero reserved fields.
10919            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10920
10921            // Safety:
10922            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10923            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10924            //   envelope_size bytes, there is always sufficient room.
10925            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
10926            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
10927            encoder, offset + cur_offset, depth
10928        )?;
10929
10930            _prev_end_offset = cur_offset + envelope_size;
10931            if 3 > max_ordinal {
10932                return Ok(());
10933            }
10934
10935            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10936            // are envelope_size bytes.
10937            let cur_offset: usize = (3 - 1) * envelope_size;
10938
10939            // Zero reserved fields.
10940            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10941
10942            // Safety:
10943            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10944            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10945            //   envelope_size bytes, there is always sufficient room.
10946            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
10947            self.backing_dir_subdir.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
10948            encoder, offset + cur_offset, depth
10949        )?;
10950
10951            _prev_end_offset = cur_offset + envelope_size;
10952            if 4 > max_ordinal {
10953                return Ok(());
10954            }
10955
10956            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10957            // are envelope_size bytes.
10958            let cur_offset: usize = (4 - 1) * envelope_size;
10959
10960            // Zero reserved fields.
10961            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10962
10963            // Safety:
10964            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10965            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10966            //   envelope_size bytes, there is always sufficient room.
10967            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
10968            self.storage_subdir.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
10969            encoder, offset + cur_offset, depth
10970        )?;
10971
10972            _prev_end_offset = cur_offset + envelope_size;
10973            if 5 > max_ordinal {
10974                return Ok(());
10975            }
10976
10977            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10978            // are envelope_size bytes.
10979            let cur_offset: usize = (5 - 1) * envelope_size;
10980
10981            // Zero reserved fields.
10982            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10983
10984            // Safety:
10985            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10986            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10987            //   envelope_size bytes, there is always sufficient room.
10988            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
10989            self.storage_source_moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
10990            encoder, offset + cur_offset, depth
10991        )?;
10992
10993            _prev_end_offset = cur_offset + envelope_size;
10994
10995            Ok(())
10996        }
10997    }
10998
10999    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11000        for StorageBackingDirectory
11001    {
11002        #[inline(always)]
11003        fn new_empty() -> Self {
11004            Self::default()
11005        }
11006
11007        unsafe fn decode(
11008            &mut self,
11009            decoder: &mut fidl::encoding::Decoder<'_, D>,
11010            offset: usize,
11011            mut depth: fidl::encoding::Depth,
11012        ) -> fidl::Result<()> {
11013            decoder.debug_check_bounds::<Self>(offset);
11014            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11015                None => return Err(fidl::Error::NotNullable),
11016                Some(len) => len,
11017            };
11018            // Calling decoder.out_of_line_offset(0) is not allowed.
11019            if len == 0 {
11020                return Ok(());
11021            };
11022            depth.increment()?;
11023            let envelope_size = 8;
11024            let bytes_len = len * envelope_size;
11025            let offset = decoder.out_of_line_offset(bytes_len)?;
11026            // Decode the envelope for each type.
11027            let mut _next_ordinal_to_read = 0;
11028            let mut next_offset = offset;
11029            let end_offset = offset + bytes_len;
11030            _next_ordinal_to_read += 1;
11031            if next_offset >= end_offset {
11032                return Ok(());
11033            }
11034
11035            // Decode unknown envelopes for gaps in ordinals.
11036            while _next_ordinal_to_read < 1 {
11037                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11038                _next_ordinal_to_read += 1;
11039                next_offset += envelope_size;
11040            }
11041
11042            let next_out_of_line = decoder.next_out_of_line();
11043            let handles_before = decoder.remaining_handles();
11044            if let Some((inlined, num_bytes, num_handles)) =
11045                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11046            {
11047                let member_inline_size =
11048                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
11049                        decoder.context,
11050                    );
11051                if inlined != (member_inline_size <= 4) {
11052                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11053                }
11054                let inner_offset;
11055                let mut inner_depth = depth.clone();
11056                if inlined {
11057                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11058                    inner_offset = next_offset;
11059                } else {
11060                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11061                    inner_depth.increment()?;
11062                }
11063                let val_ref =
11064                    self.capability.get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
11065                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
11066                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11067                {
11068                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11069                }
11070                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11071                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11072                }
11073            }
11074
11075            next_offset += envelope_size;
11076            _next_ordinal_to_read += 1;
11077            if next_offset >= end_offset {
11078                return Ok(());
11079            }
11080
11081            // Decode unknown envelopes for gaps in ordinals.
11082            while _next_ordinal_to_read < 2 {
11083                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11084                _next_ordinal_to_read += 1;
11085                next_offset += envelope_size;
11086            }
11087
11088            let next_out_of_line = decoder.next_out_of_line();
11089            let handles_before = decoder.remaining_handles();
11090            if let Some((inlined, num_bytes, num_handles)) =
11091                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11092            {
11093                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11094                if inlined != (member_inline_size <= 4) {
11095                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11096                }
11097                let inner_offset;
11098                let mut inner_depth = depth.clone();
11099                if inlined {
11100                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11101                    inner_offset = next_offset;
11102                } else {
11103                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11104                    inner_depth.increment()?;
11105                }
11106                let val_ref = self.moniker.get_or_insert_with(|| {
11107                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
11108                });
11109                fidl::decode!(
11110                    fidl::encoding::BoundedString<4096>,
11111                    D,
11112                    val_ref,
11113                    decoder,
11114                    inner_offset,
11115                    inner_depth
11116                )?;
11117                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11118                {
11119                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11120                }
11121                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11122                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11123                }
11124            }
11125
11126            next_offset += envelope_size;
11127            _next_ordinal_to_read += 1;
11128            if next_offset >= end_offset {
11129                return Ok(());
11130            }
11131
11132            // Decode unknown envelopes for gaps in ordinals.
11133            while _next_ordinal_to_read < 3 {
11134                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11135                _next_ordinal_to_read += 1;
11136                next_offset += envelope_size;
11137            }
11138
11139            let next_out_of_line = decoder.next_out_of_line();
11140            let handles_before = decoder.remaining_handles();
11141            if let Some((inlined, num_bytes, num_handles)) =
11142                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11143            {
11144                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11145                if inlined != (member_inline_size <= 4) {
11146                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11147                }
11148                let inner_offset;
11149                let mut inner_depth = depth.clone();
11150                if inlined {
11151                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11152                    inner_offset = next_offset;
11153                } else {
11154                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11155                    inner_depth.increment()?;
11156                }
11157                let val_ref = self.backing_dir_subdir.get_or_insert_with(|| {
11158                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
11159                });
11160                fidl::decode!(
11161                    fidl::encoding::BoundedString<1024>,
11162                    D,
11163                    val_ref,
11164                    decoder,
11165                    inner_offset,
11166                    inner_depth
11167                )?;
11168                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11169                {
11170                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11171                }
11172                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11173                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11174                }
11175            }
11176
11177            next_offset += envelope_size;
11178            _next_ordinal_to_read += 1;
11179            if next_offset >= end_offset {
11180                return Ok(());
11181            }
11182
11183            // Decode unknown envelopes for gaps in ordinals.
11184            while _next_ordinal_to_read < 4 {
11185                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11186                _next_ordinal_to_read += 1;
11187                next_offset += envelope_size;
11188            }
11189
11190            let next_out_of_line = decoder.next_out_of_line();
11191            let handles_before = decoder.remaining_handles();
11192            if let Some((inlined, num_bytes, num_handles)) =
11193                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11194            {
11195                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11196                if inlined != (member_inline_size <= 4) {
11197                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11198                }
11199                let inner_offset;
11200                let mut inner_depth = depth.clone();
11201                if inlined {
11202                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11203                    inner_offset = next_offset;
11204                } else {
11205                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11206                    inner_depth.increment()?;
11207                }
11208                let val_ref = self.storage_subdir.get_or_insert_with(|| {
11209                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
11210                });
11211                fidl::decode!(
11212                    fidl::encoding::BoundedString<1024>,
11213                    D,
11214                    val_ref,
11215                    decoder,
11216                    inner_offset,
11217                    inner_depth
11218                )?;
11219                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11220                {
11221                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11222                }
11223                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11224                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11225                }
11226            }
11227
11228            next_offset += envelope_size;
11229            _next_ordinal_to_read += 1;
11230            if next_offset >= end_offset {
11231                return Ok(());
11232            }
11233
11234            // Decode unknown envelopes for gaps in ordinals.
11235            while _next_ordinal_to_read < 5 {
11236                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11237                _next_ordinal_to_read += 1;
11238                next_offset += envelope_size;
11239            }
11240
11241            let next_out_of_line = decoder.next_out_of_line();
11242            let handles_before = decoder.remaining_handles();
11243            if let Some((inlined, num_bytes, num_handles)) =
11244                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11245            {
11246                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11247                if inlined != (member_inline_size <= 4) {
11248                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11249                }
11250                let inner_offset;
11251                let mut inner_depth = depth.clone();
11252                if inlined {
11253                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11254                    inner_offset = next_offset;
11255                } else {
11256                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11257                    inner_depth.increment()?;
11258                }
11259                let val_ref = self.storage_source_moniker.get_or_insert_with(|| {
11260                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
11261                });
11262                fidl::decode!(
11263                    fidl::encoding::BoundedString<4096>,
11264                    D,
11265                    val_ref,
11266                    decoder,
11267                    inner_offset,
11268                    inner_depth
11269                )?;
11270                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11271                {
11272                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11273                }
11274                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11275                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11276                }
11277            }
11278
11279            next_offset += envelope_size;
11280
11281            // Decode the remaining unknown envelopes.
11282            while next_offset < end_offset {
11283                _next_ordinal_to_read += 1;
11284                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11285                next_offset += envelope_size;
11286            }
11287
11288            Ok(())
11289        }
11290    }
11291
11292    impl Void {
11293        #[inline(always)]
11294        fn max_ordinal_present(&self) -> u64 {
11295            if let Some(_) = self.moniker {
11296                return 2;
11297            }
11298            if let Some(_) = self.capability {
11299                return 1;
11300            }
11301            0
11302        }
11303    }
11304
11305    impl fidl::encoding::ValueTypeMarker for Void {
11306        type Borrowed<'a> = &'a Self;
11307        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11308            value
11309        }
11310    }
11311
11312    unsafe impl fidl::encoding::TypeMarker for Void {
11313        type Owned = Self;
11314
11315        #[inline(always)]
11316        fn inline_align(_context: fidl::encoding::Context) -> usize {
11317            8
11318        }
11319
11320        #[inline(always)]
11321        fn inline_size(_context: fidl::encoding::Context) -> usize {
11322            16
11323        }
11324    }
11325
11326    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Void, D> for &Void {
11327        unsafe fn encode(
11328            self,
11329            encoder: &mut fidl::encoding::Encoder<'_, D>,
11330            offset: usize,
11331            mut depth: fidl::encoding::Depth,
11332        ) -> fidl::Result<()> {
11333            encoder.debug_check_bounds::<Void>(offset);
11334            // Vector header
11335            let max_ordinal: u64 = self.max_ordinal_present();
11336            encoder.write_num(max_ordinal, offset);
11337            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11338            // Calling encoder.out_of_line_offset(0) is not allowed.
11339            if max_ordinal == 0 {
11340                return Ok(());
11341            }
11342            depth.increment()?;
11343            let envelope_size = 8;
11344            let bytes_len = max_ordinal as usize * envelope_size;
11345            #[allow(unused_variables)]
11346            let offset = encoder.out_of_line_offset(bytes_len);
11347            let mut _prev_end_offset: usize = 0;
11348            if 1 > max_ordinal {
11349                return Ok(());
11350            }
11351
11352            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11353            // are envelope_size bytes.
11354            let cur_offset: usize = (1 - 1) * envelope_size;
11355
11356            // Zero reserved fields.
11357            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11358
11359            // Safety:
11360            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11361            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11362            //   envelope_size bytes, there is always sufficient room.
11363            fidl::encoding::encode_in_envelope_optional::<InternalCapability, D>(
11364                self.capability
11365                    .as_ref()
11366                    .map(<InternalCapability as fidl::encoding::ValueTypeMarker>::borrow),
11367                encoder,
11368                offset + cur_offset,
11369                depth,
11370            )?;
11371
11372            _prev_end_offset = cur_offset + envelope_size;
11373            if 2 > max_ordinal {
11374                return Ok(());
11375            }
11376
11377            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11378            // are envelope_size bytes.
11379            let cur_offset: usize = (2 - 1) * envelope_size;
11380
11381            // Zero reserved fields.
11382            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11383
11384            // Safety:
11385            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11386            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11387            //   envelope_size bytes, there is always sufficient room.
11388            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
11389            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
11390            encoder, offset + cur_offset, depth
11391        )?;
11392
11393            _prev_end_offset = cur_offset + envelope_size;
11394
11395            Ok(())
11396        }
11397    }
11398
11399    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Void {
11400        #[inline(always)]
11401        fn new_empty() -> Self {
11402            Self::default()
11403        }
11404
11405        unsafe fn decode(
11406            &mut self,
11407            decoder: &mut fidl::encoding::Decoder<'_, D>,
11408            offset: usize,
11409            mut depth: fidl::encoding::Depth,
11410        ) -> fidl::Result<()> {
11411            decoder.debug_check_bounds::<Self>(offset);
11412            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11413                None => return Err(fidl::Error::NotNullable),
11414                Some(len) => len,
11415            };
11416            // Calling decoder.out_of_line_offset(0) is not allowed.
11417            if len == 0 {
11418                return Ok(());
11419            };
11420            depth.increment()?;
11421            let envelope_size = 8;
11422            let bytes_len = len * envelope_size;
11423            let offset = decoder.out_of_line_offset(bytes_len)?;
11424            // Decode the envelope for each type.
11425            let mut _next_ordinal_to_read = 0;
11426            let mut next_offset = offset;
11427            let end_offset = offset + bytes_len;
11428            _next_ordinal_to_read += 1;
11429            if next_offset >= end_offset {
11430                return Ok(());
11431            }
11432
11433            // Decode unknown envelopes for gaps in ordinals.
11434            while _next_ordinal_to_read < 1 {
11435                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11436                _next_ordinal_to_read += 1;
11437                next_offset += envelope_size;
11438            }
11439
11440            let next_out_of_line = decoder.next_out_of_line();
11441            let handles_before = decoder.remaining_handles();
11442            if let Some((inlined, num_bytes, num_handles)) =
11443                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11444            {
11445                let member_inline_size =
11446                    <InternalCapability as fidl::encoding::TypeMarker>::inline_size(
11447                        decoder.context,
11448                    );
11449                if inlined != (member_inline_size <= 4) {
11450                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11451                }
11452                let inner_offset;
11453                let mut inner_depth = depth.clone();
11454                if inlined {
11455                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11456                    inner_offset = next_offset;
11457                } else {
11458                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11459                    inner_depth.increment()?;
11460                }
11461                let val_ref =
11462                    self.capability.get_or_insert_with(|| fidl::new_empty!(InternalCapability, D));
11463                fidl::decode!(InternalCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
11464                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11465                {
11466                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11467                }
11468                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11469                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11470                }
11471            }
11472
11473            next_offset += envelope_size;
11474            _next_ordinal_to_read += 1;
11475            if next_offset >= end_offset {
11476                return Ok(());
11477            }
11478
11479            // Decode unknown envelopes for gaps in ordinals.
11480            while _next_ordinal_to_read < 2 {
11481                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11482                _next_ordinal_to_read += 1;
11483                next_offset += envelope_size;
11484            }
11485
11486            let next_out_of_line = decoder.next_out_of_line();
11487            let handles_before = decoder.remaining_handles();
11488            if let Some((inlined, num_bytes, num_handles)) =
11489                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11490            {
11491                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11492                if inlined != (member_inline_size <= 4) {
11493                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11494                }
11495                let inner_offset;
11496                let mut inner_depth = depth.clone();
11497                if inlined {
11498                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11499                    inner_offset = next_offset;
11500                } else {
11501                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11502                    inner_depth.increment()?;
11503                }
11504                let val_ref = self.moniker.get_or_insert_with(|| {
11505                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
11506                });
11507                fidl::decode!(
11508                    fidl::encoding::BoundedString<4096>,
11509                    D,
11510                    val_ref,
11511                    decoder,
11512                    inner_offset,
11513                    inner_depth
11514                )?;
11515                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11516                {
11517                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11518                }
11519                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11520                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11521                }
11522            }
11523
11524            next_offset += envelope_size;
11525
11526            // Decode the remaining unknown envelopes.
11527            while next_offset < end_offset {
11528                _next_ordinal_to_read += 1;
11529                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11530                next_offset += envelope_size;
11531            }
11532
11533            Ok(())
11534        }
11535    }
11536
11537    impl fidl::encoding::ValueTypeMarker for AggregateCapability {
11538        type Borrowed<'a> = &'a Self;
11539        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11540            value
11541        }
11542    }
11543
11544    unsafe impl fidl::encoding::TypeMarker for AggregateCapability {
11545        type Owned = Self;
11546
11547        #[inline(always)]
11548        fn inline_align(_context: fidl::encoding::Context) -> usize {
11549            8
11550        }
11551
11552        #[inline(always)]
11553        fn inline_size(_context: fidl::encoding::Context) -> usize {
11554            16
11555        }
11556    }
11557
11558    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AggregateCapability, D>
11559        for &AggregateCapability
11560    {
11561        #[inline]
11562        unsafe fn encode(
11563            self,
11564            encoder: &mut fidl::encoding::Encoder<'_, D>,
11565            offset: usize,
11566            _depth: fidl::encoding::Depth,
11567        ) -> fidl::Result<()> {
11568            encoder.debug_check_bounds::<AggregateCapability>(offset);
11569            encoder.write_num::<u64>(self.ordinal(), offset);
11570            match self {
11571                AggregateCapability::Service(ref val) => fidl::encoding::encode_in_envelope::<
11572                    fidl::encoding::BoundedString<100>,
11573                    D,
11574                >(
11575                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11576                        val,
11577                    ),
11578                    encoder,
11579                    offset + 8,
11580                    _depth,
11581                ),
11582            }
11583        }
11584    }
11585
11586    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AggregateCapability {
11587        #[inline(always)]
11588        fn new_empty() -> Self {
11589            Self::Service(fidl::new_empty!(fidl::encoding::BoundedString<100>, D))
11590        }
11591
11592        #[inline]
11593        unsafe fn decode(
11594            &mut self,
11595            decoder: &mut fidl::encoding::Decoder<'_, D>,
11596            offset: usize,
11597            mut depth: fidl::encoding::Depth,
11598        ) -> fidl::Result<()> {
11599            decoder.debug_check_bounds::<Self>(offset);
11600            #[allow(unused_variables)]
11601            let next_out_of_line = decoder.next_out_of_line();
11602            let handles_before = decoder.remaining_handles();
11603            let (ordinal, inlined, num_bytes, num_handles) =
11604                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11605
11606            let member_inline_size = match ordinal {
11607                1 => {
11608                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11609                        decoder.context,
11610                    )
11611                }
11612                _ => return Err(fidl::Error::UnknownUnionTag),
11613            };
11614
11615            if inlined != (member_inline_size <= 4) {
11616                return Err(fidl::Error::InvalidInlineBitInEnvelope);
11617            }
11618            let _inner_offset;
11619            if inlined {
11620                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11621                _inner_offset = offset + 8;
11622            } else {
11623                depth.increment()?;
11624                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11625            }
11626            match ordinal {
11627                1 => {
11628                    #[allow(irrefutable_let_patterns)]
11629                    if let AggregateCapability::Service(_) = self {
11630                        // Do nothing, read the value into the object
11631                    } else {
11632                        // Initialize `self` to the right variant
11633                        *self = AggregateCapability::Service(fidl::new_empty!(
11634                            fidl::encoding::BoundedString<100>,
11635                            D
11636                        ));
11637                    }
11638                    #[allow(irrefutable_let_patterns)]
11639                    if let AggregateCapability::Service(ref mut val) = self {
11640                        fidl::decode!(
11641                            fidl::encoding::BoundedString<100>,
11642                            D,
11643                            val,
11644                            decoder,
11645                            _inner_offset,
11646                            depth
11647                        )?;
11648                    } else {
11649                        unreachable!()
11650                    }
11651                }
11652                ordinal => panic!("unexpected ordinal {:?}", ordinal),
11653            }
11654            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11655                return Err(fidl::Error::InvalidNumBytesInEnvelope);
11656            }
11657            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11658                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11659            }
11660            Ok(())
11661        }
11662    }
11663
11664    impl fidl::encoding::ValueTypeMarker for AggregateMember {
11665        type Borrowed<'a> = &'a Self;
11666        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11667            value
11668        }
11669    }
11670
11671    unsafe impl fidl::encoding::TypeMarker for AggregateMember {
11672        type Owned = Self;
11673
11674        #[inline(always)]
11675        fn inline_align(_context: fidl::encoding::Context) -> usize {
11676            8
11677        }
11678
11679        #[inline(always)]
11680        fn inline_size(_context: fidl::encoding::Context) -> usize {
11681            16
11682        }
11683    }
11684
11685    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AggregateMember, D>
11686        for &AggregateMember
11687    {
11688        #[inline]
11689        unsafe fn encode(
11690            self,
11691            encoder: &mut fidl::encoding::Encoder<'_, D>,
11692            offset: usize,
11693            _depth: fidl::encoding::Depth,
11694        ) -> fidl::Result<()> {
11695            encoder.debug_check_bounds::<AggregateMember>(offset);
11696            encoder.write_num::<u64>(self.ordinal(), offset);
11697            match self {
11698            AggregateMember::Child(ref val) => {
11699                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::ChildRef, D>(
11700                    <fidl_fuchsia_component_decl__common::ChildRef as fidl::encoding::ValueTypeMarker>::borrow(val),
11701                    encoder, offset + 8, _depth
11702                )
11703            }
11704            AggregateMember::Collection(ref val) => {
11705                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<100>, D>(
11706                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(val),
11707                    encoder, offset + 8, _depth
11708                )
11709            }
11710            AggregateMember::Parent(ref val) => {
11711                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::ParentRef, D>(
11712                    <fidl_fuchsia_component_decl__common::ParentRef as fidl::encoding::ValueTypeMarker>::borrow(val),
11713                    encoder, offset + 8, _depth
11714                )
11715            }
11716            AggregateMember::Self_(ref val) => {
11717                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::SelfRef, D>(
11718                    <fidl_fuchsia_component_decl__common::SelfRef as fidl::encoding::ValueTypeMarker>::borrow(val),
11719                    encoder, offset + 8, _depth
11720                )
11721            }
11722        }
11723        }
11724    }
11725
11726    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AggregateMember {
11727        #[inline(always)]
11728        fn new_empty() -> Self {
11729            Self::Child(fidl::new_empty!(fidl_fuchsia_component_decl__common::ChildRef, D))
11730        }
11731
11732        #[inline]
11733        unsafe fn decode(
11734            &mut self,
11735            decoder: &mut fidl::encoding::Decoder<'_, D>,
11736            offset: usize,
11737            mut depth: fidl::encoding::Depth,
11738        ) -> fidl::Result<()> {
11739            decoder.debug_check_bounds::<Self>(offset);
11740            #[allow(unused_variables)]
11741            let next_out_of_line = decoder.next_out_of_line();
11742            let handles_before = decoder.remaining_handles();
11743            let (ordinal, inlined, num_bytes, num_handles) =
11744                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11745
11746            let member_inline_size = match ordinal {
11747            1 => <fidl_fuchsia_component_decl__common::ChildRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11748            2 => <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11749            3 => <fidl_fuchsia_component_decl__common::ParentRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11750            4 => <fidl_fuchsia_component_decl__common::SelfRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11751            _ => return Err(fidl::Error::UnknownUnionTag),
11752        };
11753
11754            if inlined != (member_inline_size <= 4) {
11755                return Err(fidl::Error::InvalidInlineBitInEnvelope);
11756            }
11757            let _inner_offset;
11758            if inlined {
11759                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11760                _inner_offset = offset + 8;
11761            } else {
11762                depth.increment()?;
11763                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11764            }
11765            match ordinal {
11766                1 => {
11767                    #[allow(irrefutable_let_patterns)]
11768                    if let AggregateMember::Child(_) = self {
11769                        // Do nothing, read the value into the object
11770                    } else {
11771                        // Initialize `self` to the right variant
11772                        *self = AggregateMember::Child(fidl::new_empty!(
11773                            fidl_fuchsia_component_decl__common::ChildRef,
11774                            D
11775                        ));
11776                    }
11777                    #[allow(irrefutable_let_patterns)]
11778                    if let AggregateMember::Child(ref mut val) = self {
11779                        fidl::decode!(
11780                            fidl_fuchsia_component_decl__common::ChildRef,
11781                            D,
11782                            val,
11783                            decoder,
11784                            _inner_offset,
11785                            depth
11786                        )?;
11787                    } else {
11788                        unreachable!()
11789                    }
11790                }
11791                2 => {
11792                    #[allow(irrefutable_let_patterns)]
11793                    if let AggregateMember::Collection(_) = self {
11794                        // Do nothing, read the value into the object
11795                    } else {
11796                        // Initialize `self` to the right variant
11797                        *self = AggregateMember::Collection(fidl::new_empty!(
11798                            fidl::encoding::BoundedString<100>,
11799                            D
11800                        ));
11801                    }
11802                    #[allow(irrefutable_let_patterns)]
11803                    if let AggregateMember::Collection(ref mut val) = self {
11804                        fidl::decode!(
11805                            fidl::encoding::BoundedString<100>,
11806                            D,
11807                            val,
11808                            decoder,
11809                            _inner_offset,
11810                            depth
11811                        )?;
11812                    } else {
11813                        unreachable!()
11814                    }
11815                }
11816                3 => {
11817                    #[allow(irrefutable_let_patterns)]
11818                    if let AggregateMember::Parent(_) = self {
11819                        // Do nothing, read the value into the object
11820                    } else {
11821                        // Initialize `self` to the right variant
11822                        *self = AggregateMember::Parent(fidl::new_empty!(
11823                            fidl_fuchsia_component_decl__common::ParentRef,
11824                            D
11825                        ));
11826                    }
11827                    #[allow(irrefutable_let_patterns)]
11828                    if let AggregateMember::Parent(ref mut val) = self {
11829                        fidl::decode!(
11830                            fidl_fuchsia_component_decl__common::ParentRef,
11831                            D,
11832                            val,
11833                            decoder,
11834                            _inner_offset,
11835                            depth
11836                        )?;
11837                    } else {
11838                        unreachable!()
11839                    }
11840                }
11841                4 => {
11842                    #[allow(irrefutable_let_patterns)]
11843                    if let AggregateMember::Self_(_) = self {
11844                        // Do nothing, read the value into the object
11845                    } else {
11846                        // Initialize `self` to the right variant
11847                        *self = AggregateMember::Self_(fidl::new_empty!(
11848                            fidl_fuchsia_component_decl__common::SelfRef,
11849                            D
11850                        ));
11851                    }
11852                    #[allow(irrefutable_let_patterns)]
11853                    if let AggregateMember::Self_(ref mut val) = self {
11854                        fidl::decode!(
11855                            fidl_fuchsia_component_decl__common::SelfRef,
11856                            D,
11857                            val,
11858                            decoder,
11859                            _inner_offset,
11860                            depth
11861                        )?;
11862                    } else {
11863                        unreachable!()
11864                    }
11865                }
11866                ordinal => panic!("unexpected ordinal {:?}", ordinal),
11867            }
11868            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11869                return Err(fidl::Error::InvalidNumBytesInEnvelope);
11870            }
11871            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11872                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11873            }
11874            Ok(())
11875        }
11876    }
11877
11878    impl fidl::encoding::ValueTypeMarker for AllowlistedCapability {
11879        type Borrowed<'a> = &'a Self;
11880        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11881            value
11882        }
11883    }
11884
11885    unsafe impl fidl::encoding::TypeMarker for AllowlistedCapability {
11886        type Owned = Self;
11887
11888        #[inline(always)]
11889        fn inline_align(_context: fidl::encoding::Context) -> usize {
11890            8
11891        }
11892
11893        #[inline(always)]
11894        fn inline_size(_context: fidl::encoding::Context) -> usize {
11895            16
11896        }
11897    }
11898
11899    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedCapability, D>
11900        for &AllowlistedCapability
11901    {
11902        #[inline]
11903        unsafe fn encode(
11904            self,
11905            encoder: &mut fidl::encoding::Encoder<'_, D>,
11906            offset: usize,
11907            _depth: fidl::encoding::Depth,
11908        ) -> fidl::Result<()> {
11909            encoder.debug_check_bounds::<AllowlistedCapability>(offset);
11910            encoder.write_num::<u64>(self.ordinal(), offset);
11911            match self {
11912                AllowlistedCapability::Directory(ref val) => {
11913                    fidl::encoding::encode_in_envelope::<AllowlistedDirectory, D>(
11914                        <AllowlistedDirectory as fidl::encoding::ValueTypeMarker>::borrow(val),
11915                        encoder,
11916                        offset + 8,
11917                        _depth,
11918                    )
11919                }
11920                AllowlistedCapability::Protocol(ref val) => {
11921                    fidl::encoding::encode_in_envelope::<AllowlistedProtocol, D>(
11922                        <AllowlistedProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
11923                        encoder,
11924                        offset + 8,
11925                        _depth,
11926                    )
11927                }
11928                AllowlistedCapability::Service(ref val) => {
11929                    fidl::encoding::encode_in_envelope::<AllowlistedService, D>(
11930                        <AllowlistedService as fidl::encoding::ValueTypeMarker>::borrow(val),
11931                        encoder,
11932                        offset + 8,
11933                        _depth,
11934                    )
11935                }
11936                AllowlistedCapability::Storage(ref val) => {
11937                    fidl::encoding::encode_in_envelope::<AllowlistedStorage, D>(
11938                        <AllowlistedStorage as fidl::encoding::ValueTypeMarker>::borrow(val),
11939                        encoder,
11940                        offset + 8,
11941                        _depth,
11942                    )
11943                }
11944                AllowlistedCapability::Runner(ref val) => {
11945                    fidl::encoding::encode_in_envelope::<AllowlistedRunner, D>(
11946                        <AllowlistedRunner as fidl::encoding::ValueTypeMarker>::borrow(val),
11947                        encoder,
11948                        offset + 8,
11949                        _depth,
11950                    )
11951                }
11952                AllowlistedCapability::Resolver(ref val) => {
11953                    fidl::encoding::encode_in_envelope::<AllowlistedResolver, D>(
11954                        <AllowlistedResolver as fidl::encoding::ValueTypeMarker>::borrow(val),
11955                        encoder,
11956                        offset + 8,
11957                        _depth,
11958                    )
11959                }
11960                AllowlistedCapability::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
11961            }
11962        }
11963    }
11964
11965    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedCapability {
11966        #[inline(always)]
11967        fn new_empty() -> Self {
11968            Self::__SourceBreaking { unknown_ordinal: 0 }
11969        }
11970
11971        #[inline]
11972        unsafe fn decode(
11973            &mut self,
11974            decoder: &mut fidl::encoding::Decoder<'_, D>,
11975            offset: usize,
11976            mut depth: fidl::encoding::Depth,
11977        ) -> fidl::Result<()> {
11978            decoder.debug_check_bounds::<Self>(offset);
11979            #[allow(unused_variables)]
11980            let next_out_of_line = decoder.next_out_of_line();
11981            let handles_before = decoder.remaining_handles();
11982            let (ordinal, inlined, num_bytes, num_handles) =
11983                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11984
11985            let member_inline_size = match ordinal {
11986                1 => <AllowlistedDirectory as fidl::encoding::TypeMarker>::inline_size(
11987                    decoder.context,
11988                ),
11989                3 => <AllowlistedProtocol as fidl::encoding::TypeMarker>::inline_size(
11990                    decoder.context,
11991                ),
11992                4 => {
11993                    <AllowlistedService as fidl::encoding::TypeMarker>::inline_size(decoder.context)
11994                }
11995                5 => {
11996                    <AllowlistedStorage as fidl::encoding::TypeMarker>::inline_size(decoder.context)
11997                }
11998                6 => {
11999                    <AllowlistedRunner as fidl::encoding::TypeMarker>::inline_size(decoder.context)
12000                }
12001                7 => <AllowlistedResolver as fidl::encoding::TypeMarker>::inline_size(
12002                    decoder.context,
12003                ),
12004                0 => return Err(fidl::Error::UnknownUnionTag),
12005                _ => num_bytes as usize,
12006            };
12007
12008            if inlined != (member_inline_size <= 4) {
12009                return Err(fidl::Error::InvalidInlineBitInEnvelope);
12010            }
12011            let _inner_offset;
12012            if inlined {
12013                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
12014                _inner_offset = offset + 8;
12015            } else {
12016                depth.increment()?;
12017                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12018            }
12019            match ordinal {
12020                1 => {
12021                    #[allow(irrefutable_let_patterns)]
12022                    if let AllowlistedCapability::Directory(_) = self {
12023                        // Do nothing, read the value into the object
12024                    } else {
12025                        // Initialize `self` to the right variant
12026                        *self = AllowlistedCapability::Directory(fidl::new_empty!(
12027                            AllowlistedDirectory,
12028                            D
12029                        ));
12030                    }
12031                    #[allow(irrefutable_let_patterns)]
12032                    if let AllowlistedCapability::Directory(ref mut val) = self {
12033                        fidl::decode!(AllowlistedDirectory, D, val, decoder, _inner_offset, depth)?;
12034                    } else {
12035                        unreachable!()
12036                    }
12037                }
12038                3 => {
12039                    #[allow(irrefutable_let_patterns)]
12040                    if let AllowlistedCapability::Protocol(_) = self {
12041                        // Do nothing, read the value into the object
12042                    } else {
12043                        // Initialize `self` to the right variant
12044                        *self = AllowlistedCapability::Protocol(fidl::new_empty!(
12045                            AllowlistedProtocol,
12046                            D
12047                        ));
12048                    }
12049                    #[allow(irrefutable_let_patterns)]
12050                    if let AllowlistedCapability::Protocol(ref mut val) = self {
12051                        fidl::decode!(AllowlistedProtocol, D, val, decoder, _inner_offset, depth)?;
12052                    } else {
12053                        unreachable!()
12054                    }
12055                }
12056                4 => {
12057                    #[allow(irrefutable_let_patterns)]
12058                    if let AllowlistedCapability::Service(_) = self {
12059                        // Do nothing, read the value into the object
12060                    } else {
12061                        // Initialize `self` to the right variant
12062                        *self =
12063                            AllowlistedCapability::Service(fidl::new_empty!(AllowlistedService, D));
12064                    }
12065                    #[allow(irrefutable_let_patterns)]
12066                    if let AllowlistedCapability::Service(ref mut val) = self {
12067                        fidl::decode!(AllowlistedService, D, val, decoder, _inner_offset, depth)?;
12068                    } else {
12069                        unreachable!()
12070                    }
12071                }
12072                5 => {
12073                    #[allow(irrefutable_let_patterns)]
12074                    if let AllowlistedCapability::Storage(_) = self {
12075                        // Do nothing, read the value into the object
12076                    } else {
12077                        // Initialize `self` to the right variant
12078                        *self =
12079                            AllowlistedCapability::Storage(fidl::new_empty!(AllowlistedStorage, D));
12080                    }
12081                    #[allow(irrefutable_let_patterns)]
12082                    if let AllowlistedCapability::Storage(ref mut val) = self {
12083                        fidl::decode!(AllowlistedStorage, D, val, decoder, _inner_offset, depth)?;
12084                    } else {
12085                        unreachable!()
12086                    }
12087                }
12088                6 => {
12089                    #[allow(irrefutable_let_patterns)]
12090                    if let AllowlistedCapability::Runner(_) = self {
12091                        // Do nothing, read the value into the object
12092                    } else {
12093                        // Initialize `self` to the right variant
12094                        *self =
12095                            AllowlistedCapability::Runner(fidl::new_empty!(AllowlistedRunner, D));
12096                    }
12097                    #[allow(irrefutable_let_patterns)]
12098                    if let AllowlistedCapability::Runner(ref mut val) = self {
12099                        fidl::decode!(AllowlistedRunner, D, val, decoder, _inner_offset, depth)?;
12100                    } else {
12101                        unreachable!()
12102                    }
12103                }
12104                7 => {
12105                    #[allow(irrefutable_let_patterns)]
12106                    if let AllowlistedCapability::Resolver(_) = self {
12107                        // Do nothing, read the value into the object
12108                    } else {
12109                        // Initialize `self` to the right variant
12110                        *self = AllowlistedCapability::Resolver(fidl::new_empty!(
12111                            AllowlistedResolver,
12112                            D
12113                        ));
12114                    }
12115                    #[allow(irrefutable_let_patterns)]
12116                    if let AllowlistedCapability::Resolver(ref mut val) = self {
12117                        fidl::decode!(AllowlistedResolver, D, val, decoder, _inner_offset, depth)?;
12118                    } else {
12119                        unreachable!()
12120                    }
12121                }
12122                #[allow(deprecated)]
12123                ordinal => {
12124                    for _ in 0..num_handles {
12125                        decoder.drop_next_handle()?;
12126                    }
12127                    *self = AllowlistedCapability::__SourceBreaking { unknown_ordinal: ordinal };
12128                }
12129            }
12130            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
12131                return Err(fidl::Error::InvalidNumBytesInEnvelope);
12132            }
12133            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12134                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12135            }
12136            Ok(())
12137        }
12138    }
12139
12140    impl fidl::encoding::ValueTypeMarker for AllowlistedDebugRegistration {
12141        type Borrowed<'a> = &'a Self;
12142        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12143            value
12144        }
12145    }
12146
12147    unsafe impl fidl::encoding::TypeMarker for AllowlistedDebugRegistration {
12148        type Owned = Self;
12149
12150        #[inline(always)]
12151        fn inline_align(_context: fidl::encoding::Context) -> usize {
12152            8
12153        }
12154
12155        #[inline(always)]
12156        fn inline_size(_context: fidl::encoding::Context) -> usize {
12157            16
12158        }
12159    }
12160
12161    unsafe impl<D: fidl::encoding::ResourceDialect>
12162        fidl::encoding::Encode<AllowlistedDebugRegistration, D> for &AllowlistedDebugRegistration
12163    {
12164        #[inline]
12165        unsafe fn encode(
12166            self,
12167            encoder: &mut fidl::encoding::Encoder<'_, D>,
12168            offset: usize,
12169            _depth: fidl::encoding::Depth,
12170        ) -> fidl::Result<()> {
12171            encoder.debug_check_bounds::<AllowlistedDebugRegistration>(offset);
12172            encoder.write_num::<u64>(self.ordinal(), offset);
12173            match self {
12174                AllowlistedDebugRegistration::Protocol(ref val) => {
12175                    fidl::encoding::encode_in_envelope::<AllowlistedProtocol, D>(
12176                        <AllowlistedProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
12177                        encoder,
12178                        offset + 8,
12179                        _depth,
12180                    )
12181                }
12182                AllowlistedDebugRegistration::__SourceBreaking { .. } => {
12183                    Err(fidl::Error::UnknownUnionTag)
12184                }
12185            }
12186        }
12187    }
12188
12189    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12190        for AllowlistedDebugRegistration
12191    {
12192        #[inline(always)]
12193        fn new_empty() -> Self {
12194            Self::__SourceBreaking { unknown_ordinal: 0 }
12195        }
12196
12197        #[inline]
12198        unsafe fn decode(
12199            &mut self,
12200            decoder: &mut fidl::encoding::Decoder<'_, D>,
12201            offset: usize,
12202            mut depth: fidl::encoding::Depth,
12203        ) -> fidl::Result<()> {
12204            decoder.debug_check_bounds::<Self>(offset);
12205            #[allow(unused_variables)]
12206            let next_out_of_line = decoder.next_out_of_line();
12207            let handles_before = decoder.remaining_handles();
12208            let (ordinal, inlined, num_bytes, num_handles) =
12209                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
12210
12211            let member_inline_size = match ordinal {
12212                1 => <AllowlistedProtocol as fidl::encoding::TypeMarker>::inline_size(
12213                    decoder.context,
12214                ),
12215                0 => return Err(fidl::Error::UnknownUnionTag),
12216                _ => num_bytes as usize,
12217            };
12218
12219            if inlined != (member_inline_size <= 4) {
12220                return Err(fidl::Error::InvalidInlineBitInEnvelope);
12221            }
12222            let _inner_offset;
12223            if inlined {
12224                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
12225                _inner_offset = offset + 8;
12226            } else {
12227                depth.increment()?;
12228                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12229            }
12230            match ordinal {
12231                1 => {
12232                    #[allow(irrefutable_let_patterns)]
12233                    if let AllowlistedDebugRegistration::Protocol(_) = self {
12234                        // Do nothing, read the value into the object
12235                    } else {
12236                        // Initialize `self` to the right variant
12237                        *self = AllowlistedDebugRegistration::Protocol(fidl::new_empty!(
12238                            AllowlistedProtocol,
12239                            D
12240                        ));
12241                    }
12242                    #[allow(irrefutable_let_patterns)]
12243                    if let AllowlistedDebugRegistration::Protocol(ref mut val) = self {
12244                        fidl::decode!(AllowlistedProtocol, D, val, decoder, _inner_offset, depth)?;
12245                    } else {
12246                        unreachable!()
12247                    }
12248                }
12249                #[allow(deprecated)]
12250                ordinal => {
12251                    for _ in 0..num_handles {
12252                        decoder.drop_next_handle()?;
12253                    }
12254                    *self =
12255                        AllowlistedDebugRegistration::__SourceBreaking { unknown_ordinal: ordinal };
12256                }
12257            }
12258            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
12259                return Err(fidl::Error::InvalidNumBytesInEnvelope);
12260            }
12261            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12262                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12263            }
12264            Ok(())
12265        }
12266    }
12267
12268    impl fidl::encoding::ValueTypeMarker for CapabilitySource {
12269        type Borrowed<'a> = &'a Self;
12270        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12271            value
12272        }
12273    }
12274
12275    unsafe impl fidl::encoding::TypeMarker for CapabilitySource {
12276        type Owned = Self;
12277
12278        #[inline(always)]
12279        fn inline_align(_context: fidl::encoding::Context) -> usize {
12280            8
12281        }
12282
12283        #[inline(always)]
12284        fn inline_size(_context: fidl::encoding::Context) -> usize {
12285            16
12286        }
12287    }
12288
12289    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CapabilitySource, D>
12290        for &CapabilitySource
12291    {
12292        #[inline]
12293        unsafe fn encode(
12294            self,
12295            encoder: &mut fidl::encoding::Encoder<'_, D>,
12296            offset: usize,
12297            _depth: fidl::encoding::Depth,
12298        ) -> fidl::Result<()> {
12299            encoder.debug_check_bounds::<CapabilitySource>(offset);
12300            encoder.write_num::<u64>(self.ordinal(), offset);
12301            match self {
12302            CapabilitySource::Component(ref val) => {
12303                fidl::encoding::encode_in_envelope::<Component, D>(
12304                    <Component as fidl::encoding::ValueTypeMarker>::borrow(val),
12305                    encoder, offset + 8, _depth
12306                )
12307            }
12308            CapabilitySource::Framework(ref val) => {
12309                fidl::encoding::encode_in_envelope::<Framework, D>(
12310                    <Framework as fidl::encoding::ValueTypeMarker>::borrow(val),
12311                    encoder, offset + 8, _depth
12312                )
12313            }
12314            CapabilitySource::Builtin(ref val) => {
12315                fidl::encoding::encode_in_envelope::<Builtin, D>(
12316                    <Builtin as fidl::encoding::ValueTypeMarker>::borrow(val),
12317                    encoder, offset + 8, _depth
12318                )
12319            }
12320            CapabilitySource::Namespace(ref val) => {
12321                fidl::encoding::encode_in_envelope::<Namespace, D>(
12322                    <Namespace as fidl::encoding::ValueTypeMarker>::borrow(val),
12323                    encoder, offset + 8, _depth
12324                )
12325            }
12326            CapabilitySource::Capability(ref val) => {
12327                fidl::encoding::encode_in_envelope::<Capability, D>(
12328                    <Capability as fidl::encoding::ValueTypeMarker>::borrow(val),
12329                    encoder, offset + 8, _depth
12330                )
12331            }
12332            CapabilitySource::AnonymizedAggregate(ref val) => {
12333                fidl::encoding::encode_in_envelope::<AnonymizedAggregate, D>(
12334                    <AnonymizedAggregate as fidl::encoding::ValueTypeMarker>::borrow(val),
12335                    encoder, offset + 8, _depth
12336                )
12337            }
12338            CapabilitySource::FilteredProvider(ref val) => {
12339                fidl::encoding::encode_in_envelope::<FilteredProvider, D>(
12340                    <FilteredProvider as fidl::encoding::ValueTypeMarker>::borrow(val),
12341                    encoder, offset + 8, _depth
12342                )
12343            }
12344            CapabilitySource::FilteredAggregateProvider(ref val) => {
12345                fidl::encoding::encode_in_envelope::<FilteredAggregateProvider, D>(
12346                    <FilteredAggregateProvider as fidl::encoding::ValueTypeMarker>::borrow(val),
12347                    encoder, offset + 8, _depth
12348                )
12349            }
12350            CapabilitySource::Environment(ref val) => {
12351                fidl::encoding::encode_in_envelope::<Environment, D>(
12352                    <Environment as fidl::encoding::ValueTypeMarker>::borrow(val),
12353                    encoder, offset + 8, _depth
12354                )
12355            }
12356            CapabilitySource::Void(ref val) => {
12357                fidl::encoding::encode_in_envelope::<Void, D>(
12358                    <Void as fidl::encoding::ValueTypeMarker>::borrow(val),
12359                    encoder, offset + 8, _depth
12360                )
12361            }
12362            CapabilitySource::RemotedAt(ref val) => {
12363                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<4096>, D>(
12364                    <fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(val),
12365                    encoder, offset + 8, _depth
12366                )
12367            }
12368            CapabilitySource::StorageBackingDirectory(ref val) => {
12369                fidl::encoding::encode_in_envelope::<StorageBackingDirectory, D>(
12370                    <StorageBackingDirectory as fidl::encoding::ValueTypeMarker>::borrow(val),
12371                    encoder, offset + 8, _depth
12372                )
12373            }
12374        }
12375        }
12376    }
12377
12378    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CapabilitySource {
12379        #[inline(always)]
12380        fn new_empty() -> Self {
12381            Self::Component(fidl::new_empty!(Component, D))
12382        }
12383
12384        #[inline]
12385        unsafe fn decode(
12386            &mut self,
12387            decoder: &mut fidl::encoding::Decoder<'_, D>,
12388            offset: usize,
12389            mut depth: fidl::encoding::Depth,
12390        ) -> fidl::Result<()> {
12391            decoder.debug_check_bounds::<Self>(offset);
12392            #[allow(unused_variables)]
12393            let next_out_of_line = decoder.next_out_of_line();
12394            let handles_before = decoder.remaining_handles();
12395            let (ordinal, inlined, num_bytes, num_handles) =
12396                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
12397
12398            let member_inline_size = match ordinal {
12399                1 => <Component as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12400                2 => <Framework as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12401                3 => <Builtin as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12402                4 => <Namespace as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12403                5 => <Capability as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12404                6 => <AnonymizedAggregate as fidl::encoding::TypeMarker>::inline_size(
12405                    decoder.context,
12406                ),
12407                7 => <FilteredProvider as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12408                8 => <FilteredAggregateProvider as fidl::encoding::TypeMarker>::inline_size(
12409                    decoder.context,
12410                ),
12411                9 => <Environment as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12412                10 => <Void as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12413                11 => {
12414                    <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(
12415                        decoder.context,
12416                    )
12417                }
12418                12 => <StorageBackingDirectory as fidl::encoding::TypeMarker>::inline_size(
12419                    decoder.context,
12420                ),
12421                _ => return Err(fidl::Error::UnknownUnionTag),
12422            };
12423
12424            if inlined != (member_inline_size <= 4) {
12425                return Err(fidl::Error::InvalidInlineBitInEnvelope);
12426            }
12427            let _inner_offset;
12428            if inlined {
12429                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
12430                _inner_offset = offset + 8;
12431            } else {
12432                depth.increment()?;
12433                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12434            }
12435            match ordinal {
12436                1 => {
12437                    #[allow(irrefutable_let_patterns)]
12438                    if let CapabilitySource::Component(_) = self {
12439                        // Do nothing, read the value into the object
12440                    } else {
12441                        // Initialize `self` to the right variant
12442                        *self = CapabilitySource::Component(fidl::new_empty!(Component, D));
12443                    }
12444                    #[allow(irrefutable_let_patterns)]
12445                    if let CapabilitySource::Component(ref mut val) = self {
12446                        fidl::decode!(Component, D, val, decoder, _inner_offset, depth)?;
12447                    } else {
12448                        unreachable!()
12449                    }
12450                }
12451                2 => {
12452                    #[allow(irrefutable_let_patterns)]
12453                    if let CapabilitySource::Framework(_) = self {
12454                        // Do nothing, read the value into the object
12455                    } else {
12456                        // Initialize `self` to the right variant
12457                        *self = CapabilitySource::Framework(fidl::new_empty!(Framework, D));
12458                    }
12459                    #[allow(irrefutable_let_patterns)]
12460                    if let CapabilitySource::Framework(ref mut val) = self {
12461                        fidl::decode!(Framework, D, val, decoder, _inner_offset, depth)?;
12462                    } else {
12463                        unreachable!()
12464                    }
12465                }
12466                3 => {
12467                    #[allow(irrefutable_let_patterns)]
12468                    if let CapabilitySource::Builtin(_) = self {
12469                        // Do nothing, read the value into the object
12470                    } else {
12471                        // Initialize `self` to the right variant
12472                        *self = CapabilitySource::Builtin(fidl::new_empty!(Builtin, D));
12473                    }
12474                    #[allow(irrefutable_let_patterns)]
12475                    if let CapabilitySource::Builtin(ref mut val) = self {
12476                        fidl::decode!(Builtin, D, val, decoder, _inner_offset, depth)?;
12477                    } else {
12478                        unreachable!()
12479                    }
12480                }
12481                4 => {
12482                    #[allow(irrefutable_let_patterns)]
12483                    if let CapabilitySource::Namespace(_) = self {
12484                        // Do nothing, read the value into the object
12485                    } else {
12486                        // Initialize `self` to the right variant
12487                        *self = CapabilitySource::Namespace(fidl::new_empty!(Namespace, D));
12488                    }
12489                    #[allow(irrefutable_let_patterns)]
12490                    if let CapabilitySource::Namespace(ref mut val) = self {
12491                        fidl::decode!(Namespace, D, val, decoder, _inner_offset, depth)?;
12492                    } else {
12493                        unreachable!()
12494                    }
12495                }
12496                5 => {
12497                    #[allow(irrefutable_let_patterns)]
12498                    if let CapabilitySource::Capability(_) = self {
12499                        // Do nothing, read the value into the object
12500                    } else {
12501                        // Initialize `self` to the right variant
12502                        *self = CapabilitySource::Capability(fidl::new_empty!(Capability, D));
12503                    }
12504                    #[allow(irrefutable_let_patterns)]
12505                    if let CapabilitySource::Capability(ref mut val) = self {
12506                        fidl::decode!(Capability, D, val, decoder, _inner_offset, depth)?;
12507                    } else {
12508                        unreachable!()
12509                    }
12510                }
12511                6 => {
12512                    #[allow(irrefutable_let_patterns)]
12513                    if let CapabilitySource::AnonymizedAggregate(_) = self {
12514                        // Do nothing, read the value into the object
12515                    } else {
12516                        // Initialize `self` to the right variant
12517                        *self = CapabilitySource::AnonymizedAggregate(fidl::new_empty!(
12518                            AnonymizedAggregate,
12519                            D
12520                        ));
12521                    }
12522                    #[allow(irrefutable_let_patterns)]
12523                    if let CapabilitySource::AnonymizedAggregate(ref mut val) = self {
12524                        fidl::decode!(AnonymizedAggregate, D, val, decoder, _inner_offset, depth)?;
12525                    } else {
12526                        unreachable!()
12527                    }
12528                }
12529                7 => {
12530                    #[allow(irrefutable_let_patterns)]
12531                    if let CapabilitySource::FilteredProvider(_) = self {
12532                        // Do nothing, read the value into the object
12533                    } else {
12534                        // Initialize `self` to the right variant
12535                        *self = CapabilitySource::FilteredProvider(fidl::new_empty!(
12536                            FilteredProvider,
12537                            D
12538                        ));
12539                    }
12540                    #[allow(irrefutable_let_patterns)]
12541                    if let CapabilitySource::FilteredProvider(ref mut val) = self {
12542                        fidl::decode!(FilteredProvider, D, val, decoder, _inner_offset, depth)?;
12543                    } else {
12544                        unreachable!()
12545                    }
12546                }
12547                8 => {
12548                    #[allow(irrefutable_let_patterns)]
12549                    if let CapabilitySource::FilteredAggregateProvider(_) = self {
12550                        // Do nothing, read the value into the object
12551                    } else {
12552                        // Initialize `self` to the right variant
12553                        *self = CapabilitySource::FilteredAggregateProvider(fidl::new_empty!(
12554                            FilteredAggregateProvider,
12555                            D
12556                        ));
12557                    }
12558                    #[allow(irrefutable_let_patterns)]
12559                    if let CapabilitySource::FilteredAggregateProvider(ref mut val) = self {
12560                        fidl::decode!(
12561                            FilteredAggregateProvider,
12562                            D,
12563                            val,
12564                            decoder,
12565                            _inner_offset,
12566                            depth
12567                        )?;
12568                    } else {
12569                        unreachable!()
12570                    }
12571                }
12572                9 => {
12573                    #[allow(irrefutable_let_patterns)]
12574                    if let CapabilitySource::Environment(_) = self {
12575                        // Do nothing, read the value into the object
12576                    } else {
12577                        // Initialize `self` to the right variant
12578                        *self = CapabilitySource::Environment(fidl::new_empty!(Environment, D));
12579                    }
12580                    #[allow(irrefutable_let_patterns)]
12581                    if let CapabilitySource::Environment(ref mut val) = self {
12582                        fidl::decode!(Environment, D, val, decoder, _inner_offset, depth)?;
12583                    } else {
12584                        unreachable!()
12585                    }
12586                }
12587                10 => {
12588                    #[allow(irrefutable_let_patterns)]
12589                    if let CapabilitySource::Void(_) = self {
12590                        // Do nothing, read the value into the object
12591                    } else {
12592                        // Initialize `self` to the right variant
12593                        *self = CapabilitySource::Void(fidl::new_empty!(Void, D));
12594                    }
12595                    #[allow(irrefutable_let_patterns)]
12596                    if let CapabilitySource::Void(ref mut val) = self {
12597                        fidl::decode!(Void, D, val, decoder, _inner_offset, depth)?;
12598                    } else {
12599                        unreachable!()
12600                    }
12601                }
12602                11 => {
12603                    #[allow(irrefutable_let_patterns)]
12604                    if let CapabilitySource::RemotedAt(_) = self {
12605                        // Do nothing, read the value into the object
12606                    } else {
12607                        // Initialize `self` to the right variant
12608                        *self = CapabilitySource::RemotedAt(fidl::new_empty!(
12609                            fidl::encoding::BoundedString<4096>,
12610                            D
12611                        ));
12612                    }
12613                    #[allow(irrefutable_let_patterns)]
12614                    if let CapabilitySource::RemotedAt(ref mut val) = self {
12615                        fidl::decode!(
12616                            fidl::encoding::BoundedString<4096>,
12617                            D,
12618                            val,
12619                            decoder,
12620                            _inner_offset,
12621                            depth
12622                        )?;
12623                    } else {
12624                        unreachable!()
12625                    }
12626                }
12627                12 => {
12628                    #[allow(irrefutable_let_patterns)]
12629                    if let CapabilitySource::StorageBackingDirectory(_) = self {
12630                        // Do nothing, read the value into the object
12631                    } else {
12632                        // Initialize `self` to the right variant
12633                        *self = CapabilitySource::StorageBackingDirectory(fidl::new_empty!(
12634                            StorageBackingDirectory,
12635                            D
12636                        ));
12637                    }
12638                    #[allow(irrefutable_let_patterns)]
12639                    if let CapabilitySource::StorageBackingDirectory(ref mut val) = self {
12640                        fidl::decode!(
12641                            StorageBackingDirectory,
12642                            D,
12643                            val,
12644                            decoder,
12645                            _inner_offset,
12646                            depth
12647                        )?;
12648                    } else {
12649                        unreachable!()
12650                    }
12651                }
12652                ordinal => panic!("unexpected ordinal {:?}", ordinal),
12653            }
12654            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
12655                return Err(fidl::Error::InvalidNumBytesInEnvelope);
12656            }
12657            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12658                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12659            }
12660            Ok(())
12661        }
12662    }
12663
12664    impl fidl::encoding::ValueTypeMarker for ComponentCapability {
12665        type Borrowed<'a> = &'a Self;
12666        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12667            value
12668        }
12669    }
12670
12671    unsafe impl fidl::encoding::TypeMarker for ComponentCapability {
12672        type Owned = Self;
12673
12674        #[inline(always)]
12675        fn inline_align(_context: fidl::encoding::Context) -> usize {
12676            8
12677        }
12678
12679        #[inline(always)]
12680        fn inline_size(_context: fidl::encoding::Context) -> usize {
12681            16
12682        }
12683    }
12684
12685    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ComponentCapability, D>
12686        for &ComponentCapability
12687    {
12688        #[inline]
12689        unsafe fn encode(
12690            self,
12691            encoder: &mut fidl::encoding::Encoder<'_, D>,
12692            offset: usize,
12693            _depth: fidl::encoding::Depth,
12694        ) -> fidl::Result<()> {
12695            encoder.debug_check_bounds::<ComponentCapability>(offset);
12696            encoder.write_num::<u64>(self.ordinal(), offset);
12697            match self {
12698            ComponentCapability::Use_(ref val) => {
12699                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Use, D>(
12700                    <fidl_fuchsia_component_decl__common::Use as fidl::encoding::ValueTypeMarker>::borrow(val),
12701                    encoder, offset + 8, _depth
12702                )
12703            }
12704            ComponentCapability::Offer(ref val) => {
12705                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Offer, D>(
12706                    <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::ValueTypeMarker>::borrow(val),
12707                    encoder, offset + 8, _depth
12708                )
12709            }
12710            ComponentCapability::Expose(ref val) => {
12711                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Expose, D>(
12712                    <fidl_fuchsia_component_decl__common::Expose as fidl::encoding::ValueTypeMarker>::borrow(val),
12713                    encoder, offset + 8, _depth
12714                )
12715            }
12716            ComponentCapability::Config(ref val) => {
12717                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Configuration, D>(
12718                    <fidl_fuchsia_component_decl__common::Configuration as fidl::encoding::ValueTypeMarker>::borrow(val),
12719                    encoder, offset + 8, _depth
12720                )
12721            }
12722            ComponentCapability::Dictionary(ref val) => {
12723                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Dictionary, D>(
12724                    <fidl_fuchsia_component_decl__common::Dictionary as fidl::encoding::ValueTypeMarker>::borrow(val),
12725                    encoder, offset + 8, _depth
12726                )
12727            }
12728            ComponentCapability::Directory(ref val) => {
12729                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Directory, D>(
12730                    <fidl_fuchsia_component_decl__common::Directory as fidl::encoding::ValueTypeMarker>::borrow(val),
12731                    encoder, offset + 8, _depth
12732                )
12733            }
12734            ComponentCapability::Environment(ref val) => {
12735                fidl::encoding::encode_in_envelope::<EnvironmentCapability, D>(
12736                    <EnvironmentCapability as fidl::encoding::ValueTypeMarker>::borrow(val),
12737                    encoder, offset + 8, _depth
12738                )
12739            }
12740            ComponentCapability::EventStream(ref val) => {
12741                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::EventStream, D>(
12742                    <fidl_fuchsia_component_decl__common::EventStream as fidl::encoding::ValueTypeMarker>::borrow(val),
12743                    encoder, offset + 8, _depth
12744                )
12745            }
12746            ComponentCapability::Protocol(ref val) => {
12747                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Protocol, D>(
12748                    <fidl_fuchsia_component_decl__common::Protocol as fidl::encoding::ValueTypeMarker>::borrow(val),
12749                    encoder, offset + 8, _depth
12750                )
12751            }
12752            ComponentCapability::Resolver(ref val) => {
12753                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Resolver, D>(
12754                    <fidl_fuchsia_component_decl__common::Resolver as fidl::encoding::ValueTypeMarker>::borrow(val),
12755                    encoder, offset + 8, _depth
12756                )
12757            }
12758            ComponentCapability::Runner(ref val) => {
12759                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Runner, D>(
12760                    <fidl_fuchsia_component_decl__common::Runner as fidl::encoding::ValueTypeMarker>::borrow(val),
12761                    encoder, offset + 8, _depth
12762                )
12763            }
12764            ComponentCapability::Service(ref val) => {
12765                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Service, D>(
12766                    <fidl_fuchsia_component_decl__common::Service as fidl::encoding::ValueTypeMarker>::borrow(val),
12767                    encoder, offset + 8, _depth
12768                )
12769            }
12770            ComponentCapability::Storage(ref val) => {
12771                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Storage, D>(
12772                    <fidl_fuchsia_component_decl__common::Storage as fidl::encoding::ValueTypeMarker>::borrow(val),
12773                    encoder, offset + 8, _depth
12774                )
12775            }
12776        }
12777        }
12778    }
12779
12780    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ComponentCapability {
12781        #[inline(always)]
12782        fn new_empty() -> Self {
12783            Self::Use_(fidl::new_empty!(fidl_fuchsia_component_decl__common::Use, D))
12784        }
12785
12786        #[inline]
12787        unsafe fn decode(
12788            &mut self,
12789            decoder: &mut fidl::encoding::Decoder<'_, D>,
12790            offset: usize,
12791            mut depth: fidl::encoding::Depth,
12792        ) -> fidl::Result<()> {
12793            decoder.debug_check_bounds::<Self>(offset);
12794            #[allow(unused_variables)]
12795            let next_out_of_line = decoder.next_out_of_line();
12796            let handles_before = decoder.remaining_handles();
12797            let (ordinal, inlined, num_bytes, num_handles) =
12798                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
12799
12800            let member_inline_size = match ordinal {
12801            1 => <fidl_fuchsia_component_decl__common::Use as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12802            2 => <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12803            3 => <fidl_fuchsia_component_decl__common::Expose as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12804            4 => <fidl_fuchsia_component_decl__common::Configuration as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12805            5 => <fidl_fuchsia_component_decl__common::Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12806            6 => <fidl_fuchsia_component_decl__common::Directory as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12807            7 => <EnvironmentCapability as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12808            8 => <fidl_fuchsia_component_decl__common::EventStream as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12809            9 => <fidl_fuchsia_component_decl__common::Protocol as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12810            10 => <fidl_fuchsia_component_decl__common::Resolver as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12811            11 => <fidl_fuchsia_component_decl__common::Runner as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12812            12 => <fidl_fuchsia_component_decl__common::Service as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12813            13 => <fidl_fuchsia_component_decl__common::Storage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12814            _ => return Err(fidl::Error::UnknownUnionTag),
12815        };
12816
12817            if inlined != (member_inline_size <= 4) {
12818                return Err(fidl::Error::InvalidInlineBitInEnvelope);
12819            }
12820            let _inner_offset;
12821            if inlined {
12822                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
12823                _inner_offset = offset + 8;
12824            } else {
12825                depth.increment()?;
12826                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12827            }
12828            match ordinal {
12829                1 => {
12830                    #[allow(irrefutable_let_patterns)]
12831                    if let ComponentCapability::Use_(_) = self {
12832                        // Do nothing, read the value into the object
12833                    } else {
12834                        // Initialize `self` to the right variant
12835                        *self = ComponentCapability::Use_(fidl::new_empty!(
12836                            fidl_fuchsia_component_decl__common::Use,
12837                            D
12838                        ));
12839                    }
12840                    #[allow(irrefutable_let_patterns)]
12841                    if let ComponentCapability::Use_(ref mut val) = self {
12842                        fidl::decode!(
12843                            fidl_fuchsia_component_decl__common::Use,
12844                            D,
12845                            val,
12846                            decoder,
12847                            _inner_offset,
12848                            depth
12849                        )?;
12850                    } else {
12851                        unreachable!()
12852                    }
12853                }
12854                2 => {
12855                    #[allow(irrefutable_let_patterns)]
12856                    if let ComponentCapability::Offer(_) = self {
12857                        // Do nothing, read the value into the object
12858                    } else {
12859                        // Initialize `self` to the right variant
12860                        *self = ComponentCapability::Offer(fidl::new_empty!(
12861                            fidl_fuchsia_component_decl__common::Offer,
12862                            D
12863                        ));
12864                    }
12865                    #[allow(irrefutable_let_patterns)]
12866                    if let ComponentCapability::Offer(ref mut val) = self {
12867                        fidl::decode!(
12868                            fidl_fuchsia_component_decl__common::Offer,
12869                            D,
12870                            val,
12871                            decoder,
12872                            _inner_offset,
12873                            depth
12874                        )?;
12875                    } else {
12876                        unreachable!()
12877                    }
12878                }
12879                3 => {
12880                    #[allow(irrefutable_let_patterns)]
12881                    if let ComponentCapability::Expose(_) = self {
12882                        // Do nothing, read the value into the object
12883                    } else {
12884                        // Initialize `self` to the right variant
12885                        *self = ComponentCapability::Expose(fidl::new_empty!(
12886                            fidl_fuchsia_component_decl__common::Expose,
12887                            D
12888                        ));
12889                    }
12890                    #[allow(irrefutable_let_patterns)]
12891                    if let ComponentCapability::Expose(ref mut val) = self {
12892                        fidl::decode!(
12893                            fidl_fuchsia_component_decl__common::Expose,
12894                            D,
12895                            val,
12896                            decoder,
12897                            _inner_offset,
12898                            depth
12899                        )?;
12900                    } else {
12901                        unreachable!()
12902                    }
12903                }
12904                4 => {
12905                    #[allow(irrefutable_let_patterns)]
12906                    if let ComponentCapability::Config(_) = self {
12907                        // Do nothing, read the value into the object
12908                    } else {
12909                        // Initialize `self` to the right variant
12910                        *self = ComponentCapability::Config(fidl::new_empty!(
12911                            fidl_fuchsia_component_decl__common::Configuration,
12912                            D
12913                        ));
12914                    }
12915                    #[allow(irrefutable_let_patterns)]
12916                    if let ComponentCapability::Config(ref mut val) = self {
12917                        fidl::decode!(
12918                            fidl_fuchsia_component_decl__common::Configuration,
12919                            D,
12920                            val,
12921                            decoder,
12922                            _inner_offset,
12923                            depth
12924                        )?;
12925                    } else {
12926                        unreachable!()
12927                    }
12928                }
12929                5 => {
12930                    #[allow(irrefutable_let_patterns)]
12931                    if let ComponentCapability::Dictionary(_) = self {
12932                        // Do nothing, read the value into the object
12933                    } else {
12934                        // Initialize `self` to the right variant
12935                        *self = ComponentCapability::Dictionary(fidl::new_empty!(
12936                            fidl_fuchsia_component_decl__common::Dictionary,
12937                            D
12938                        ));
12939                    }
12940                    #[allow(irrefutable_let_patterns)]
12941                    if let ComponentCapability::Dictionary(ref mut val) = self {
12942                        fidl::decode!(
12943                            fidl_fuchsia_component_decl__common::Dictionary,
12944                            D,
12945                            val,
12946                            decoder,
12947                            _inner_offset,
12948                            depth
12949                        )?;
12950                    } else {
12951                        unreachable!()
12952                    }
12953                }
12954                6 => {
12955                    #[allow(irrefutable_let_patterns)]
12956                    if let ComponentCapability::Directory(_) = self {
12957                        // Do nothing, read the value into the object
12958                    } else {
12959                        // Initialize `self` to the right variant
12960                        *self = ComponentCapability::Directory(fidl::new_empty!(
12961                            fidl_fuchsia_component_decl__common::Directory,
12962                            D
12963                        ));
12964                    }
12965                    #[allow(irrefutable_let_patterns)]
12966                    if let ComponentCapability::Directory(ref mut val) = self {
12967                        fidl::decode!(
12968                            fidl_fuchsia_component_decl__common::Directory,
12969                            D,
12970                            val,
12971                            decoder,
12972                            _inner_offset,
12973                            depth
12974                        )?;
12975                    } else {
12976                        unreachable!()
12977                    }
12978                }
12979                7 => {
12980                    #[allow(irrefutable_let_patterns)]
12981                    if let ComponentCapability::Environment(_) = self {
12982                        // Do nothing, read the value into the object
12983                    } else {
12984                        // Initialize `self` to the right variant
12985                        *self = ComponentCapability::Environment(fidl::new_empty!(
12986                            EnvironmentCapability,
12987                            D
12988                        ));
12989                    }
12990                    #[allow(irrefutable_let_patterns)]
12991                    if let ComponentCapability::Environment(ref mut val) = self {
12992                        fidl::decode!(
12993                            EnvironmentCapability,
12994                            D,
12995                            val,
12996                            decoder,
12997                            _inner_offset,
12998                            depth
12999                        )?;
13000                    } else {
13001                        unreachable!()
13002                    }
13003                }
13004                8 => {
13005                    #[allow(irrefutable_let_patterns)]
13006                    if let ComponentCapability::EventStream(_) = self {
13007                        // Do nothing, read the value into the object
13008                    } else {
13009                        // Initialize `self` to the right variant
13010                        *self = ComponentCapability::EventStream(fidl::new_empty!(
13011                            fidl_fuchsia_component_decl__common::EventStream,
13012                            D
13013                        ));
13014                    }
13015                    #[allow(irrefutable_let_patterns)]
13016                    if let ComponentCapability::EventStream(ref mut val) = self {
13017                        fidl::decode!(
13018                            fidl_fuchsia_component_decl__common::EventStream,
13019                            D,
13020                            val,
13021                            decoder,
13022                            _inner_offset,
13023                            depth
13024                        )?;
13025                    } else {
13026                        unreachable!()
13027                    }
13028                }
13029                9 => {
13030                    #[allow(irrefutable_let_patterns)]
13031                    if let ComponentCapability::Protocol(_) = self {
13032                        // Do nothing, read the value into the object
13033                    } else {
13034                        // Initialize `self` to the right variant
13035                        *self = ComponentCapability::Protocol(fidl::new_empty!(
13036                            fidl_fuchsia_component_decl__common::Protocol,
13037                            D
13038                        ));
13039                    }
13040                    #[allow(irrefutable_let_patterns)]
13041                    if let ComponentCapability::Protocol(ref mut val) = self {
13042                        fidl::decode!(
13043                            fidl_fuchsia_component_decl__common::Protocol,
13044                            D,
13045                            val,
13046                            decoder,
13047                            _inner_offset,
13048                            depth
13049                        )?;
13050                    } else {
13051                        unreachable!()
13052                    }
13053                }
13054                10 => {
13055                    #[allow(irrefutable_let_patterns)]
13056                    if let ComponentCapability::Resolver(_) = self {
13057                        // Do nothing, read the value into the object
13058                    } else {
13059                        // Initialize `self` to the right variant
13060                        *self = ComponentCapability::Resolver(fidl::new_empty!(
13061                            fidl_fuchsia_component_decl__common::Resolver,
13062                            D
13063                        ));
13064                    }
13065                    #[allow(irrefutable_let_patterns)]
13066                    if let ComponentCapability::Resolver(ref mut val) = self {
13067                        fidl::decode!(
13068                            fidl_fuchsia_component_decl__common::Resolver,
13069                            D,
13070                            val,
13071                            decoder,
13072                            _inner_offset,
13073                            depth
13074                        )?;
13075                    } else {
13076                        unreachable!()
13077                    }
13078                }
13079                11 => {
13080                    #[allow(irrefutable_let_patterns)]
13081                    if let ComponentCapability::Runner(_) = self {
13082                        // Do nothing, read the value into the object
13083                    } else {
13084                        // Initialize `self` to the right variant
13085                        *self = ComponentCapability::Runner(fidl::new_empty!(
13086                            fidl_fuchsia_component_decl__common::Runner,
13087                            D
13088                        ));
13089                    }
13090                    #[allow(irrefutable_let_patterns)]
13091                    if let ComponentCapability::Runner(ref mut val) = self {
13092                        fidl::decode!(
13093                            fidl_fuchsia_component_decl__common::Runner,
13094                            D,
13095                            val,
13096                            decoder,
13097                            _inner_offset,
13098                            depth
13099                        )?;
13100                    } else {
13101                        unreachable!()
13102                    }
13103                }
13104                12 => {
13105                    #[allow(irrefutable_let_patterns)]
13106                    if let ComponentCapability::Service(_) = self {
13107                        // Do nothing, read the value into the object
13108                    } else {
13109                        // Initialize `self` to the right variant
13110                        *self = ComponentCapability::Service(fidl::new_empty!(
13111                            fidl_fuchsia_component_decl__common::Service,
13112                            D
13113                        ));
13114                    }
13115                    #[allow(irrefutable_let_patterns)]
13116                    if let ComponentCapability::Service(ref mut val) = self {
13117                        fidl::decode!(
13118                            fidl_fuchsia_component_decl__common::Service,
13119                            D,
13120                            val,
13121                            decoder,
13122                            _inner_offset,
13123                            depth
13124                        )?;
13125                    } else {
13126                        unreachable!()
13127                    }
13128                }
13129                13 => {
13130                    #[allow(irrefutable_let_patterns)]
13131                    if let ComponentCapability::Storage(_) = self {
13132                        // Do nothing, read the value into the object
13133                    } else {
13134                        // Initialize `self` to the right variant
13135                        *self = ComponentCapability::Storage(fidl::new_empty!(
13136                            fidl_fuchsia_component_decl__common::Storage,
13137                            D
13138                        ));
13139                    }
13140                    #[allow(irrefutable_let_patterns)]
13141                    if let ComponentCapability::Storage(ref mut val) = self {
13142                        fidl::decode!(
13143                            fidl_fuchsia_component_decl__common::Storage,
13144                            D,
13145                            val,
13146                            decoder,
13147                            _inner_offset,
13148                            depth
13149                        )?;
13150                    } else {
13151                        unreachable!()
13152                    }
13153                }
13154                ordinal => panic!("unexpected ordinal {:?}", ordinal),
13155            }
13156            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
13157                return Err(fidl::Error::InvalidNumBytesInEnvelope);
13158            }
13159            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13160                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13161            }
13162            Ok(())
13163        }
13164    }
13165
13166    impl fidl::encoding::ValueTypeMarker for EnvironmentCapability {
13167        type Borrowed<'a> = &'a Self;
13168        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13169            value
13170        }
13171    }
13172
13173    unsafe impl fidl::encoding::TypeMarker for EnvironmentCapability {
13174        type Owned = Self;
13175
13176        #[inline(always)]
13177        fn inline_align(_context: fidl::encoding::Context) -> usize {
13178            8
13179        }
13180
13181        #[inline(always)]
13182        fn inline_size(_context: fidl::encoding::Context) -> usize {
13183            16
13184        }
13185    }
13186
13187    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnvironmentCapability, D>
13188        for &EnvironmentCapability
13189    {
13190        #[inline]
13191        unsafe fn encode(
13192            self,
13193            encoder: &mut fidl::encoding::Encoder<'_, D>,
13194            offset: usize,
13195            _depth: fidl::encoding::Depth,
13196        ) -> fidl::Result<()> {
13197            encoder.debug_check_bounds::<EnvironmentCapability>(offset);
13198            encoder.write_num::<u64>(self.ordinal(), offset);
13199            match self {
13200                EnvironmentCapability::Runner(ref val) => {
13201                    fidl::encoding::encode_in_envelope::<EnvironmentSource, D>(
13202                        <EnvironmentSource as fidl::encoding::ValueTypeMarker>::borrow(val),
13203                        encoder,
13204                        offset + 8,
13205                        _depth,
13206                    )
13207                }
13208                EnvironmentCapability::Resolver(ref val) => {
13209                    fidl::encoding::encode_in_envelope::<EnvironmentSource, D>(
13210                        <EnvironmentSource as fidl::encoding::ValueTypeMarker>::borrow(val),
13211                        encoder,
13212                        offset + 8,
13213                        _depth,
13214                    )
13215                }
13216                EnvironmentCapability::Debug(ref val) => {
13217                    fidl::encoding::encode_in_envelope::<EnvironmentSource, D>(
13218                        <EnvironmentSource as fidl::encoding::ValueTypeMarker>::borrow(val),
13219                        encoder,
13220                        offset + 8,
13221                        _depth,
13222                    )
13223                }
13224            }
13225        }
13226    }
13227
13228    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnvironmentCapability {
13229        #[inline(always)]
13230        fn new_empty() -> Self {
13231            Self::Runner(fidl::new_empty!(EnvironmentSource, D))
13232        }
13233
13234        #[inline]
13235        unsafe fn decode(
13236            &mut self,
13237            decoder: &mut fidl::encoding::Decoder<'_, D>,
13238            offset: usize,
13239            mut depth: fidl::encoding::Depth,
13240        ) -> fidl::Result<()> {
13241            decoder.debug_check_bounds::<Self>(offset);
13242            #[allow(unused_variables)]
13243            let next_out_of_line = decoder.next_out_of_line();
13244            let handles_before = decoder.remaining_handles();
13245            let (ordinal, inlined, num_bytes, num_handles) =
13246                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
13247
13248            let member_inline_size = match ordinal {
13249                1 => {
13250                    <EnvironmentSource as fidl::encoding::TypeMarker>::inline_size(decoder.context)
13251                }
13252                2 => {
13253                    <EnvironmentSource as fidl::encoding::TypeMarker>::inline_size(decoder.context)
13254                }
13255                3 => {
13256                    <EnvironmentSource as fidl::encoding::TypeMarker>::inline_size(decoder.context)
13257                }
13258                _ => return Err(fidl::Error::UnknownUnionTag),
13259            };
13260
13261            if inlined != (member_inline_size <= 4) {
13262                return Err(fidl::Error::InvalidInlineBitInEnvelope);
13263            }
13264            let _inner_offset;
13265            if inlined {
13266                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
13267                _inner_offset = offset + 8;
13268            } else {
13269                depth.increment()?;
13270                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13271            }
13272            match ordinal {
13273                1 => {
13274                    #[allow(irrefutable_let_patterns)]
13275                    if let EnvironmentCapability::Runner(_) = self {
13276                        // Do nothing, read the value into the object
13277                    } else {
13278                        // Initialize `self` to the right variant
13279                        *self =
13280                            EnvironmentCapability::Runner(fidl::new_empty!(EnvironmentSource, D));
13281                    }
13282                    #[allow(irrefutable_let_patterns)]
13283                    if let EnvironmentCapability::Runner(ref mut val) = self {
13284                        fidl::decode!(EnvironmentSource, D, val, decoder, _inner_offset, depth)?;
13285                    } else {
13286                        unreachable!()
13287                    }
13288                }
13289                2 => {
13290                    #[allow(irrefutable_let_patterns)]
13291                    if let EnvironmentCapability::Resolver(_) = self {
13292                        // Do nothing, read the value into the object
13293                    } else {
13294                        // Initialize `self` to the right variant
13295                        *self =
13296                            EnvironmentCapability::Resolver(fidl::new_empty!(EnvironmentSource, D));
13297                    }
13298                    #[allow(irrefutable_let_patterns)]
13299                    if let EnvironmentCapability::Resolver(ref mut val) = self {
13300                        fidl::decode!(EnvironmentSource, D, val, decoder, _inner_offset, depth)?;
13301                    } else {
13302                        unreachable!()
13303                    }
13304                }
13305                3 => {
13306                    #[allow(irrefutable_let_patterns)]
13307                    if let EnvironmentCapability::Debug(_) = self {
13308                        // Do nothing, read the value into the object
13309                    } else {
13310                        // Initialize `self` to the right variant
13311                        *self =
13312                            EnvironmentCapability::Debug(fidl::new_empty!(EnvironmentSource, D));
13313                    }
13314                    #[allow(irrefutable_let_patterns)]
13315                    if let EnvironmentCapability::Debug(ref mut val) = self {
13316                        fidl::decode!(EnvironmentSource, D, val, decoder, _inner_offset, depth)?;
13317                    } else {
13318                        unreachable!()
13319                    }
13320                }
13321                ordinal => panic!("unexpected ordinal {:?}", ordinal),
13322            }
13323            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
13324                return Err(fidl::Error::InvalidNumBytesInEnvelope);
13325            }
13326            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13327                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13328            }
13329            Ok(())
13330        }
13331    }
13332
13333    impl fidl::encoding::ValueTypeMarker for InjectedUse {
13334        type Borrowed<'a> = &'a Self;
13335        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13336            value
13337        }
13338    }
13339
13340    unsafe impl fidl::encoding::TypeMarker for InjectedUse {
13341        type Owned = Self;
13342
13343        #[inline(always)]
13344        fn inline_align(_context: fidl::encoding::Context) -> usize {
13345            8
13346        }
13347
13348        #[inline(always)]
13349        fn inline_size(_context: fidl::encoding::Context) -> usize {
13350            16
13351        }
13352    }
13353
13354    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InjectedUse, D>
13355        for &InjectedUse
13356    {
13357        #[inline]
13358        unsafe fn encode(
13359            self,
13360            encoder: &mut fidl::encoding::Encoder<'_, D>,
13361            offset: usize,
13362            _depth: fidl::encoding::Depth,
13363        ) -> fidl::Result<()> {
13364            encoder.debug_check_bounds::<InjectedUse>(offset);
13365            encoder.write_num::<u64>(self.ordinal(), offset);
13366            match self {
13367                InjectedUse::Protocol(ref val) => {
13368                    fidl::encoding::encode_in_envelope::<InjectedUseProtocol, D>(
13369                        <InjectedUseProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
13370                        encoder,
13371                        offset + 8,
13372                        _depth,
13373                    )
13374                }
13375                InjectedUse::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
13376            }
13377        }
13378    }
13379
13380    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InjectedUse {
13381        #[inline(always)]
13382        fn new_empty() -> Self {
13383            Self::__SourceBreaking { unknown_ordinal: 0 }
13384        }
13385
13386        #[inline]
13387        unsafe fn decode(
13388            &mut self,
13389            decoder: &mut fidl::encoding::Decoder<'_, D>,
13390            offset: usize,
13391            mut depth: fidl::encoding::Depth,
13392        ) -> fidl::Result<()> {
13393            decoder.debug_check_bounds::<Self>(offset);
13394            #[allow(unused_variables)]
13395            let next_out_of_line = decoder.next_out_of_line();
13396            let handles_before = decoder.remaining_handles();
13397            let (ordinal, inlined, num_bytes, num_handles) =
13398                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
13399
13400            let member_inline_size = match ordinal {
13401                1 => <InjectedUseProtocol as fidl::encoding::TypeMarker>::inline_size(
13402                    decoder.context,
13403                ),
13404                0 => return Err(fidl::Error::UnknownUnionTag),
13405                _ => num_bytes as usize,
13406            };
13407
13408            if inlined != (member_inline_size <= 4) {
13409                return Err(fidl::Error::InvalidInlineBitInEnvelope);
13410            }
13411            let _inner_offset;
13412            if inlined {
13413                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
13414                _inner_offset = offset + 8;
13415            } else {
13416                depth.increment()?;
13417                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13418            }
13419            match ordinal {
13420                1 => {
13421                    #[allow(irrefutable_let_patterns)]
13422                    if let InjectedUse::Protocol(_) = self {
13423                        // Do nothing, read the value into the object
13424                    } else {
13425                        // Initialize `self` to the right variant
13426                        *self = InjectedUse::Protocol(fidl::new_empty!(InjectedUseProtocol, D));
13427                    }
13428                    #[allow(irrefutable_let_patterns)]
13429                    if let InjectedUse::Protocol(ref mut val) = self {
13430                        fidl::decode!(InjectedUseProtocol, D, val, decoder, _inner_offset, depth)?;
13431                    } else {
13432                        unreachable!()
13433                    }
13434                }
13435                #[allow(deprecated)]
13436                ordinal => {
13437                    for _ in 0..num_handles {
13438                        decoder.drop_next_handle()?;
13439                    }
13440                    *self = InjectedUse::__SourceBreaking { unknown_ordinal: ordinal };
13441                }
13442            }
13443            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
13444                return Err(fidl::Error::InvalidNumBytesInEnvelope);
13445            }
13446            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13447                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13448            }
13449            Ok(())
13450        }
13451    }
13452
13453    impl fidl::encoding::ValueTypeMarker for InternalCapability {
13454        type Borrowed<'a> = &'a Self;
13455        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13456            value
13457        }
13458    }
13459
13460    unsafe impl fidl::encoding::TypeMarker for InternalCapability {
13461        type Owned = Self;
13462
13463        #[inline(always)]
13464        fn inline_align(_context: fidl::encoding::Context) -> usize {
13465            8
13466        }
13467
13468        #[inline(always)]
13469        fn inline_size(_context: fidl::encoding::Context) -> usize {
13470            16
13471        }
13472    }
13473
13474    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InternalCapability, D>
13475        for &InternalCapability
13476    {
13477        #[inline]
13478        unsafe fn encode(
13479            self,
13480            encoder: &mut fidl::encoding::Encoder<'_, D>,
13481            offset: usize,
13482            _depth: fidl::encoding::Depth,
13483        ) -> fidl::Result<()> {
13484            encoder.debug_check_bounds::<InternalCapability>(offset);
13485            encoder.write_num::<u64>(self.ordinal(), offset);
13486            match self {
13487                InternalCapability::Config(ref val) => fidl::encoding::encode_in_envelope::<
13488                    fidl::encoding::BoundedString<100>,
13489                    D,
13490                >(
13491                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13492                        val,
13493                    ),
13494                    encoder,
13495                    offset + 8,
13496                    _depth,
13497                ),
13498                InternalCapability::Dictionary(ref val) => fidl::encoding::encode_in_envelope::<
13499                    fidl::encoding::BoundedString<100>,
13500                    D,
13501                >(
13502                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13503                        val,
13504                    ),
13505                    encoder,
13506                    offset + 8,
13507                    _depth,
13508                ),
13509                InternalCapability::Directory(ref val) => fidl::encoding::encode_in_envelope::<
13510                    fidl::encoding::BoundedString<100>,
13511                    D,
13512                >(
13513                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13514                        val,
13515                    ),
13516                    encoder,
13517                    offset + 8,
13518                    _depth,
13519                ),
13520                InternalCapability::EventStream(ref val) => fidl::encoding::encode_in_envelope::<
13521                    fidl::encoding::BoundedString<100>,
13522                    D,
13523                >(
13524                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13525                        val,
13526                    ),
13527                    encoder,
13528                    offset + 8,
13529                    _depth,
13530                ),
13531                InternalCapability::Protocol(ref val) => fidl::encoding::encode_in_envelope::<
13532                    fidl::encoding::BoundedString<100>,
13533                    D,
13534                >(
13535                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13536                        val,
13537                    ),
13538                    encoder,
13539                    offset + 8,
13540                    _depth,
13541                ),
13542                InternalCapability::Resolver(ref val) => fidl::encoding::encode_in_envelope::<
13543                    fidl::encoding::BoundedString<100>,
13544                    D,
13545                >(
13546                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13547                        val,
13548                    ),
13549                    encoder,
13550                    offset + 8,
13551                    _depth,
13552                ),
13553                InternalCapability::Runner(ref val) => fidl::encoding::encode_in_envelope::<
13554                    fidl::encoding::BoundedString<100>,
13555                    D,
13556                >(
13557                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13558                        val,
13559                    ),
13560                    encoder,
13561                    offset + 8,
13562                    _depth,
13563                ),
13564                InternalCapability::Service(ref val) => fidl::encoding::encode_in_envelope::<
13565                    fidl::encoding::BoundedString<100>,
13566                    D,
13567                >(
13568                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13569                        val,
13570                    ),
13571                    encoder,
13572                    offset + 8,
13573                    _depth,
13574                ),
13575                InternalCapability::Storage(ref val) => fidl::encoding::encode_in_envelope::<
13576                    fidl::encoding::BoundedString<100>,
13577                    D,
13578                >(
13579                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13580                        val,
13581                    ),
13582                    encoder,
13583                    offset + 8,
13584                    _depth,
13585                ),
13586            }
13587        }
13588    }
13589
13590    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InternalCapability {
13591        #[inline(always)]
13592        fn new_empty() -> Self {
13593            Self::Config(fidl::new_empty!(fidl::encoding::BoundedString<100>, D))
13594        }
13595
13596        #[inline]
13597        unsafe fn decode(
13598            &mut self,
13599            decoder: &mut fidl::encoding::Decoder<'_, D>,
13600            offset: usize,
13601            mut depth: fidl::encoding::Depth,
13602        ) -> fidl::Result<()> {
13603            decoder.debug_check_bounds::<Self>(offset);
13604            #[allow(unused_variables)]
13605            let next_out_of_line = decoder.next_out_of_line();
13606            let handles_before = decoder.remaining_handles();
13607            let (ordinal, inlined, num_bytes, num_handles) =
13608                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
13609
13610            let member_inline_size = match ordinal {
13611                1 => {
13612                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13613                        decoder.context,
13614                    )
13615                }
13616                2 => {
13617                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13618                        decoder.context,
13619                    )
13620                }
13621                3 => {
13622                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13623                        decoder.context,
13624                    )
13625                }
13626                4 => {
13627                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13628                        decoder.context,
13629                    )
13630                }
13631                5 => {
13632                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13633                        decoder.context,
13634                    )
13635                }
13636                6 => {
13637                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13638                        decoder.context,
13639                    )
13640                }
13641                7 => {
13642                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13643                        decoder.context,
13644                    )
13645                }
13646                8 => {
13647                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13648                        decoder.context,
13649                    )
13650                }
13651                9 => {
13652                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13653                        decoder.context,
13654                    )
13655                }
13656                _ => return Err(fidl::Error::UnknownUnionTag),
13657            };
13658
13659            if inlined != (member_inline_size <= 4) {
13660                return Err(fidl::Error::InvalidInlineBitInEnvelope);
13661            }
13662            let _inner_offset;
13663            if inlined {
13664                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
13665                _inner_offset = offset + 8;
13666            } else {
13667                depth.increment()?;
13668                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13669            }
13670            match ordinal {
13671                1 => {
13672                    #[allow(irrefutable_let_patterns)]
13673                    if let InternalCapability::Config(_) = self {
13674                        // Do nothing, read the value into the object
13675                    } else {
13676                        // Initialize `self` to the right variant
13677                        *self = InternalCapability::Config(fidl::new_empty!(
13678                            fidl::encoding::BoundedString<100>,
13679                            D
13680                        ));
13681                    }
13682                    #[allow(irrefutable_let_patterns)]
13683                    if let InternalCapability::Config(ref mut val) = self {
13684                        fidl::decode!(
13685                            fidl::encoding::BoundedString<100>,
13686                            D,
13687                            val,
13688                            decoder,
13689                            _inner_offset,
13690                            depth
13691                        )?;
13692                    } else {
13693                        unreachable!()
13694                    }
13695                }
13696                2 => {
13697                    #[allow(irrefutable_let_patterns)]
13698                    if let InternalCapability::Dictionary(_) = self {
13699                        // Do nothing, read the value into the object
13700                    } else {
13701                        // Initialize `self` to the right variant
13702                        *self = InternalCapability::Dictionary(fidl::new_empty!(
13703                            fidl::encoding::BoundedString<100>,
13704                            D
13705                        ));
13706                    }
13707                    #[allow(irrefutable_let_patterns)]
13708                    if let InternalCapability::Dictionary(ref mut val) = self {
13709                        fidl::decode!(
13710                            fidl::encoding::BoundedString<100>,
13711                            D,
13712                            val,
13713                            decoder,
13714                            _inner_offset,
13715                            depth
13716                        )?;
13717                    } else {
13718                        unreachable!()
13719                    }
13720                }
13721                3 => {
13722                    #[allow(irrefutable_let_patterns)]
13723                    if let InternalCapability::Directory(_) = self {
13724                        // Do nothing, read the value into the object
13725                    } else {
13726                        // Initialize `self` to the right variant
13727                        *self = InternalCapability::Directory(fidl::new_empty!(
13728                            fidl::encoding::BoundedString<100>,
13729                            D
13730                        ));
13731                    }
13732                    #[allow(irrefutable_let_patterns)]
13733                    if let InternalCapability::Directory(ref mut val) = self {
13734                        fidl::decode!(
13735                            fidl::encoding::BoundedString<100>,
13736                            D,
13737                            val,
13738                            decoder,
13739                            _inner_offset,
13740                            depth
13741                        )?;
13742                    } else {
13743                        unreachable!()
13744                    }
13745                }
13746                4 => {
13747                    #[allow(irrefutable_let_patterns)]
13748                    if let InternalCapability::EventStream(_) = self {
13749                        // Do nothing, read the value into the object
13750                    } else {
13751                        // Initialize `self` to the right variant
13752                        *self = InternalCapability::EventStream(fidl::new_empty!(
13753                            fidl::encoding::BoundedString<100>,
13754                            D
13755                        ));
13756                    }
13757                    #[allow(irrefutable_let_patterns)]
13758                    if let InternalCapability::EventStream(ref mut val) = self {
13759                        fidl::decode!(
13760                            fidl::encoding::BoundedString<100>,
13761                            D,
13762                            val,
13763                            decoder,
13764                            _inner_offset,
13765                            depth
13766                        )?;
13767                    } else {
13768                        unreachable!()
13769                    }
13770                }
13771                5 => {
13772                    #[allow(irrefutable_let_patterns)]
13773                    if let InternalCapability::Protocol(_) = self {
13774                        // Do nothing, read the value into the object
13775                    } else {
13776                        // Initialize `self` to the right variant
13777                        *self = InternalCapability::Protocol(fidl::new_empty!(
13778                            fidl::encoding::BoundedString<100>,
13779                            D
13780                        ));
13781                    }
13782                    #[allow(irrefutable_let_patterns)]
13783                    if let InternalCapability::Protocol(ref mut val) = self {
13784                        fidl::decode!(
13785                            fidl::encoding::BoundedString<100>,
13786                            D,
13787                            val,
13788                            decoder,
13789                            _inner_offset,
13790                            depth
13791                        )?;
13792                    } else {
13793                        unreachable!()
13794                    }
13795                }
13796                6 => {
13797                    #[allow(irrefutable_let_patterns)]
13798                    if let InternalCapability::Resolver(_) = self {
13799                        // Do nothing, read the value into the object
13800                    } else {
13801                        // Initialize `self` to the right variant
13802                        *self = InternalCapability::Resolver(fidl::new_empty!(
13803                            fidl::encoding::BoundedString<100>,
13804                            D
13805                        ));
13806                    }
13807                    #[allow(irrefutable_let_patterns)]
13808                    if let InternalCapability::Resolver(ref mut val) = self {
13809                        fidl::decode!(
13810                            fidl::encoding::BoundedString<100>,
13811                            D,
13812                            val,
13813                            decoder,
13814                            _inner_offset,
13815                            depth
13816                        )?;
13817                    } else {
13818                        unreachable!()
13819                    }
13820                }
13821                7 => {
13822                    #[allow(irrefutable_let_patterns)]
13823                    if let InternalCapability::Runner(_) = self {
13824                        // Do nothing, read the value into the object
13825                    } else {
13826                        // Initialize `self` to the right variant
13827                        *self = InternalCapability::Runner(fidl::new_empty!(
13828                            fidl::encoding::BoundedString<100>,
13829                            D
13830                        ));
13831                    }
13832                    #[allow(irrefutable_let_patterns)]
13833                    if let InternalCapability::Runner(ref mut val) = self {
13834                        fidl::decode!(
13835                            fidl::encoding::BoundedString<100>,
13836                            D,
13837                            val,
13838                            decoder,
13839                            _inner_offset,
13840                            depth
13841                        )?;
13842                    } else {
13843                        unreachable!()
13844                    }
13845                }
13846                8 => {
13847                    #[allow(irrefutable_let_patterns)]
13848                    if let InternalCapability::Service(_) = self {
13849                        // Do nothing, read the value into the object
13850                    } else {
13851                        // Initialize `self` to the right variant
13852                        *self = InternalCapability::Service(fidl::new_empty!(
13853                            fidl::encoding::BoundedString<100>,
13854                            D
13855                        ));
13856                    }
13857                    #[allow(irrefutable_let_patterns)]
13858                    if let InternalCapability::Service(ref mut val) = self {
13859                        fidl::decode!(
13860                            fidl::encoding::BoundedString<100>,
13861                            D,
13862                            val,
13863                            decoder,
13864                            _inner_offset,
13865                            depth
13866                        )?;
13867                    } else {
13868                        unreachable!()
13869                    }
13870                }
13871                9 => {
13872                    #[allow(irrefutable_let_patterns)]
13873                    if let InternalCapability::Storage(_) = self {
13874                        // Do nothing, read the value into the object
13875                    } else {
13876                        // Initialize `self` to the right variant
13877                        *self = InternalCapability::Storage(fidl::new_empty!(
13878                            fidl::encoding::BoundedString<100>,
13879                            D
13880                        ));
13881                    }
13882                    #[allow(irrefutable_let_patterns)]
13883                    if let InternalCapability::Storage(ref mut val) = self {
13884                        fidl::decode!(
13885                            fidl::encoding::BoundedString<100>,
13886                            D,
13887                            val,
13888                            decoder,
13889                            _inner_offset,
13890                            depth
13891                        )?;
13892                    } else {
13893                        unreachable!()
13894                    }
13895                }
13896                ordinal => panic!("unexpected ordinal {:?}", ordinal),
13897            }
13898            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
13899                return Err(fidl::Error::InvalidNumBytesInEnvelope);
13900            }
13901            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13902                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13903            }
13904            Ok(())
13905        }
13906    }
13907}
fidl_fuchsia_component_internal__common/fidl_fuchsia_component_internal__common.rs

fidl_fuchsia_component_internal__common/
fidl_fuchsia_component_internal__common.rs
