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 instances: Option<Vec<fidl_fuchsia_sys2__common::ServiceInstance>>,
237    #[doc(hidden)]
238    pub __source_breaking: fidl::marker::SourceBreaking,
239}
240
241impl fidl::Persistable for AnonymizedAggregate {}
242
243#[derive(Clone, Debug, Default, PartialEq)]
244pub struct Builtin {
245    pub capability: Option<InternalCapability>,
246    #[doc(hidden)]
247    pub __source_breaking: fidl::marker::SourceBreaking,
248}
249
250impl fidl::Persistable for Builtin {}
251
252#[derive(Clone, Debug, Default, PartialEq)]
253pub struct Capability {
254    pub source_capability: Option<ComponentCapability>,
255    pub moniker: Option<String>,
256    #[doc(hidden)]
257    pub __source_breaking: fidl::marker::SourceBreaking,
258}
259
260impl fidl::Persistable for Capability {}
261
262/// Defines a single capability policy entry in the set of capability policy
263/// allowlists.
264#[derive(Clone, Debug, Default, PartialEq)]
265pub struct CapabilityAllowlistEntry {
266    /// The `source_moniker` represents the origin of a capability. The
267    /// `source_moniker` is either a moniker or '<component_manager>'.
268    pub source_moniker: Option<String>,
269    /// The source name of this particular capability.
270    pub source_name: Option<String>,
271    /// Represents the type of capability that is being restricted along
272    /// with any other properties required by a particular capability type.
273    pub capability: Option<AllowlistedCapability>,
274    /// The set of components, described by either exact monikers, realm, or collection,
275    /// that are allowed to use this specific capability.
276    pub target_monikers: Option<Vec<String>>,
277    /// The original source type of this capability, self or framework.
278    pub source: Option<fidl_fuchsia_component_decl__common::Ref>,
279    #[doc(hidden)]
280    pub __source_breaking: fidl::marker::SourceBreaking,
281}
282
283impl fidl::Persistable for CapabilityAllowlistEntry {}
284
285/// Defines the total set of capability allowlists. Each
286/// `source_moniker` + `capability` pair must be unique in the vector.
287#[derive(Clone, Debug, Default, PartialEq)]
288pub struct CapabilityPolicyAllowlists {
289    pub allowlist: Option<Vec<CapabilityAllowlistEntry>>,
290    #[doc(hidden)]
291    pub __source_breaking: fidl::marker::SourceBreaking,
292}
293
294impl fidl::Persistable for CapabilityPolicyAllowlists {}
295
296/// Allowlists for privileged child options.
297#[derive(Clone, Debug, Default, PartialEq)]
298pub struct ChildPolicyAllowlists {
299    /// Allowlist entry monikers of component instances allowed to have the
300    /// `on_terminate=REBOOT` in their `children` declaration.
301    pub reboot_on_terminate: Option<Vec<String>>,
302    #[doc(hidden)]
303    pub __source_breaking: fidl::marker::SourceBreaking,
304}
305
306impl fidl::Persistable for ChildPolicyAllowlists {}
307
308#[derive(Clone, Debug, Default, PartialEq)]
309pub struct Component {
310    pub capability: Option<ComponentCapability>,
311    pub moniker: Option<String>,
312    #[doc(hidden)]
313    pub __source_breaking: fidl::marker::SourceBreaking,
314}
315
316impl fidl::Persistable for Component {}
317
318/// Top-level type describing the component ID index.
319#[derive(Clone, Debug, Default, PartialEq)]
320pub struct ComponentIdIndex {
321    /// A list of component ID instance entries.
322    ///
323    /// Required, but may be empty.
324    pub instances: Option<Vec<InstanceIdEntry>>,
325    #[doc(hidden)]
326    pub __source_breaking: fidl::marker::SourceBreaking,
327}
328
329impl fidl::Persistable for ComponentIdIndex {}
330
331#[derive(Clone, Debug, Default, PartialEq)]
332pub struct Config {
333    /// If true, component manager will be in debug mode. In this mode, component manager
334    /// provides the `EventSource` protocol and exposes this protocol. Component
335    /// manager will not start until it is resumed by a call to
336    /// `EventSource.StartComponentTree`.
337    ///
338    /// This is done so that an external component (say an integration test) can subscribe
339    /// to events before the root component has started.
340    pub debug: Option<bool>,
341    /// How many children, maximum, are returned by a call to `Realm.ChildIterator.next()`.
342    pub list_children_batch_size: Option<u32>,
343    /// Security policy configuration.
344    pub security_policy: Option<SecurityPolicy>,
345    /// Capabilities offered from component manager's namespace.
346    pub namespace_capabilities: Option<Vec<fidl_fuchsia_component_decl__common::Capability>>,
347    /// If true, component_manager will serve an instance of fuchsia.process.Launcher and use this
348    /// launcher for the built-in ELF component runner. The root component can additionally
349    /// use and/or offer this service using `/builtin/fuchsia.process.Launcher` from realm.
350    /// This flag exists because the built-in process launcher *only* works when
351    /// component_manager runs under a job that has ZX_POL_NEW_PROCESS set to allow, like the root
352    /// job. Otherwise, the component_manager process cannot directly create process through
353    /// zx_process_create. When we run component_manager elsewhere, like in test environments, it
354    /// has to use the fuchsia.process.Launcher service provided through its namespace instead.
355    pub use_builtin_process_launcher: Option<bool>,
356    /// If true, component_manager will maintain a UTC kernel clock and vend write handles through
357    /// an instance of `fuchsia.time.Maintenance`. This flag should only be used with the top-level
358    /// component_manager.
359    pub maintain_utc_clock: Option<bool>,
360    /// The number of threads to use for running component_manager's executor.
361    /// If not present, interpreted as 1.
362    pub num_threads: Option<u8>,
363    /// URL of the root component to launch. This field is used if the no URL
364    /// is passed to component manager. If value is passed in both places, then
365    /// an error is raised.
366    pub root_component_url: Option<String>,
367    /// Path to the component ID index. An empty value defaults to an empty index.
368    /// An invalid index causes component_manager to abort.
369    pub component_id_index_path: Option<String>,
370    /// Where to log to.
371    pub log_destination: Option<LogDestination>,
372    /// If true, component manager will log all events dispatched in the topology.
373    pub log_all_events: Option<bool>,
374    /// Which builtin resolver to use for the fuchsia-boot scheme.
375    /// If not present, interpreted as BuiltinBootResolver.NONE.
376    pub builtin_boot_resolver: Option<BuiltinBootResolver>,
377    /// If and how the realm builder resolver and runner will be used. Typically
378    /// these capabilities from realm builder are available to a nested
379    /// component manager that is undergoing an integration test.
380    pub realm_builder_resolver_and_runner: Option<RealmBuilderResolverAndRunner>,
381    /// Capabilities offered from component manager as built-in capabilities.
382    pub builtin_capabilities: Option<Vec<fidl_fuchsia_component_decl__common::Capability>>,
383    /// Enables Component Manager's introspection APIs (RealmQuery, RealmExplorer,
384    /// RouteValidator, LifecycleController, etc.) for use by components.
385    pub enable_introspection: Option<bool>,
386    /// The enforcement and validation policy to apply to component target ABI
387    /// revisions.
388    pub abi_revision_policy: Option<AbiRevisionPolicy>,
389    /// Where to obtain the vmex resource from, if this component_manager is hosting bootfs.
390    /// If not present, defaults to `VmexSource::SYSTEM_RESOURCE`.
391    pub vmex_source: Option<VmexSource>,
392    /// Information about the health checks during the update process.
393    pub health_check: Option<HealthCheck>,
394    /// Where to look for the trace provider. If missing, defaults to TraceProvider::NAMESPACE.
395    /// This is ignored on non-tracing builds.
396    pub trace_provider: Option<TraceProvider>,
397    /// Capabilities to inject into components at runtime.
398    pub inject_capabilities: Option<Vec<InjectedCapabilities>>,
399    /// Runtime configuration for Scudo heap allocation, using a 'KEY=VALUE,KEY=VALUE'
400    /// format. See Scudo flags documentation for details. It is shadowed by `SCUDO_OPTIONS`
401    pub scudo_options: Option<String>,
402    #[doc(hidden)]
403    pub __source_breaking: fidl::marker::SourceBreaking,
404}
405
406impl fidl::Persistable for Config {}
407
408/// Defines a capability policy entry in the set of debug capability policy
409/// allowlists.
410#[derive(Clone, Debug, Default, PartialEq)]
411pub struct DebugRegistrationAllowlistEntry {
412    /// The name of the capability as it's registered in the environment.
413    pub name: Option<String>,
414    /// Represents the type of capability that is being restricted along
415    /// with any other properties required by a particular capability type.
416    pub debug: Option<AllowlistedDebugRegistration>,
417    /// The moniker of the component which is allowed to register
418    /// this capability in its environment's debug sction.
419    pub moniker: Option<String>,
420    /// Name of the environment where this capability can be registered.
421    pub environment_name: Option<String>,
422    #[doc(hidden)]
423    pub __source_breaking: fidl::marker::SourceBreaking,
424}
425
426impl fidl::Persistable for DebugRegistrationAllowlistEntry {}
427
428/// Defines the total set of debug capability allowlists.
429#[derive(Clone, Debug, Default, PartialEq)]
430pub struct DebugRegistrationPolicyAllowlists {
431    pub allowlist: Option<Vec<DebugRegistrationAllowlistEntry>>,
432    #[doc(hidden)]
433    pub __source_breaking: fidl::marker::SourceBreaking,
434}
435
436impl fidl::Persistable for DebugRegistrationPolicyAllowlists {}
437
438#[derive(Clone, Debug, Default, PartialEq)]
439pub struct Environment {
440    pub capability: Option<ComponentCapability>,
441    pub moniker: Option<String>,
442    #[doc(hidden)]
443    pub __source_breaking: fidl::marker::SourceBreaking,
444}
445
446impl fidl::Persistable for Environment {}
447
448#[derive(Clone, Debug, Default, PartialEq)]
449pub struct EnvironmentSource {
450    pub source_name: Option<String>,
451    pub source: Option<fidl_fuchsia_component_decl__common::Ref>,
452    #[doc(hidden)]
453    pub __source_breaking: fidl::marker::SourceBreaking,
454}
455
456impl fidl::Persistable for EnvironmentSource {}
457
458/// This value is used internally by event stream routers, to carry information
459/// pertinent to the route.
460#[derive(Clone, Debug, Default, PartialEq)]
461pub struct EventStreamRouteMetadata {
462    /// The moniker of the component that has set a scope on this event stream.
463    /// Unset if there is no scope on the event stream.
464    pub scope_moniker: Option<String>,
465    /// The scope(s) from which the consumer of this event stream will be able
466    /// to observe events. Relative to the `scope_moniker`. Unset if there is no
467    /// scope on the event stream.
468    pub scope: Option<Vec<fidl_fuchsia_component_decl__common::Ref>>,
469    #[doc(hidden)]
470    pub __source_breaking: fidl::marker::SourceBreaking,
471}
472
473impl fidl::Persistable for EventStreamRouteMetadata {}
474
475#[derive(Clone, Debug, Default, PartialEq)]
476pub struct FilteredAggregateProvider {
477    pub capability: Option<AggregateCapability>,
478    pub moniker: Option<String>,
479    pub offer_service_decls: Option<Vec<fidl_fuchsia_component_decl__common::OfferService>>,
480    #[doc(hidden)]
481    pub __source_breaking: fidl::marker::SourceBreaking,
482}
483
484impl fidl::Persistable for FilteredAggregateProvider {}
485
486#[derive(Clone, Debug, Default, PartialEq)]
487pub struct FilteredProvider {
488    pub capability: Option<AggregateCapability>,
489    pub moniker: Option<String>,
490    pub service_capability: Option<ComponentCapability>,
491    pub offer_service_decl: Option<fidl_fuchsia_component_decl__common::OfferService>,
492    #[doc(hidden)]
493    pub __source_breaking: fidl::marker::SourceBreaking,
494}
495
496impl fidl::Persistable for FilteredProvider {}
497
498#[derive(Clone, Debug, Default, PartialEq)]
499pub struct Framework {
500    pub capability: Option<InternalCapability>,
501    pub moniker: Option<String>,
502    #[doc(hidden)]
503    pub __source_breaking: fidl::marker::SourceBreaking,
504}
505
506impl fidl::Persistable for Framework {}
507
508/// Information about the health checks during the update process.
509#[derive(Clone, Debug, Default, PartialEq)]
510pub struct HealthCheck {
511    /// Component monikers that must be healthy in order to complete an OTA update.
512    pub monikers: Option<Vec<String>>,
513    #[doc(hidden)]
514    pub __source_breaking: fidl::marker::SourceBreaking,
515}
516
517impl fidl::Persistable for HealthCheck {}
518
519/// Declares a group of extra capabilities that are layered at runtime on top of
520/// those that would normally be routed to the component.
521#[derive(Clone, Debug, Default, PartialEq)]
522pub struct InjectedCapabilities {
523    /// (Required) Components that will have these capabilities injected into.
524    pub components: Option<Vec<String>>,
525    /// (Optional) Capabilities to be injected.
526    pub use_: Option<Vec<InjectedUse>>,
527    #[doc(hidden)]
528    pub __source_breaking: fidl::marker::SourceBreaking,
529}
530
531impl fidl::Persistable for InjectedCapabilities {}
532
533/// Declares a protocol to be injected into a component.
534#[derive(Clone, Debug, Default, PartialEq)]
535pub struct InjectedUseProtocol {
536    /// (Required) Name identifying the protocol within the root component.
537    pub source_name: Option<String>,
538    /// (Required) The path where the capability should be injected in the new
539    /// component's namespace.
540    ///
541    /// Must be an absolute path starting with /.
542    pub target_path: Option<String>,
543    #[doc(hidden)]
544    pub __source_breaking: fidl::marker::SourceBreaking,
545}
546
547impl fidl::Persistable for InjectedUseProtocol {}
548
549#[derive(Clone, Debug, Default, PartialEq)]
550pub struct InstanceIdEntry {
551    /// A 256-bit identifier encoded in base64 which is unique across all other
552    /// instance IDs in the index.
553    pub instance_id: Option<String>,
554    /// The moniker identifying the component instance.
555    pub moniker: Option<String>,
556    /// Do not generate an error if this entry has the same instance ID as
557    /// another.
558    pub ignore_duplicate_id: Option<bool>,
559    #[doc(hidden)]
560    pub __source_breaking: fidl::marker::SourceBreaking,
561}
562
563impl fidl::Persistable for InstanceIdEntry {}
564
565#[derive(Clone, Debug, Default, PartialEq)]
566pub struct InternalEventStreamCapability {
567    pub name: Option<String>,
568    pub route_metadata: Option<EventStreamRouteMetadata>,
569    #[doc(hidden)]
570    pub __source_breaking: fidl::marker::SourceBreaking,
571}
572
573impl fidl::Persistable for InternalEventStreamCapability {}
574
575/// Allowlists for Zircon job policy.
576#[derive(Clone, Debug, Default, PartialEq)]
577pub struct JobPolicyAllowlists {
578    /// Allowlist entry monikers for components allowed to be given the
579    /// ZX_POL_AMBIENT_MARK_VMO_EXEC job policy.
580    ///
581    /// Components must request this policy by including "job_policy_ambient_mark_vmo_exec: true" in
582    /// their CML's `program` section and must be using the ELF runner.
583    /// This is equivalent to the v1 'deprecated-ambient-replace-as-executable' feature.
584    pub ambient_mark_vmo_exec: Option<Vec<String>>,
585    /// Allowlist entry monikers for components allowed to have their original process
586    /// marked as critical to component_manager's job.
587    ///
588    /// Components must request this critical marking by including "main_process_critical: true" in
589    /// their CML's `program` section and must be using the ELF runner.
590    pub main_process_critical: Option<Vec<String>>,
591    /// Allowlist entry monikers for components allowed to call zx_process_create directly
592    /// (e.g., do not have ZX_POL_NEW_PROCESS set to ZX_POL_ACTION_DENY).
593    ///
594    /// Components must request this policy by including "job_policy_create_raw_processes: true" in
595    /// their manifest's program object and must be using the ELF runner.
596    pub create_raw_processes: Option<Vec<String>>,
597    #[doc(hidden)]
598    pub __source_breaking: fidl::marker::SourceBreaking,
599}
600
601impl fidl::Persistable for JobPolicyAllowlists {}
602
603#[derive(Clone, Debug, Default, PartialEq)]
604pub struct Namespace {
605    pub capability: Option<ComponentCapability>,
606    #[doc(hidden)]
607    pub __source_breaking: fidl::marker::SourceBreaking,
608}
609
610impl fidl::Persistable for Namespace {}
611
612#[derive(Clone, Debug, Default, PartialEq)]
613pub struct RemotedAt {
614    pub moniker: Option<String>,
615    pub type_name: Option<String>,
616    #[doc(hidden)]
617    pub __source_breaking: fidl::marker::SourceBreaking,
618}
619
620impl fidl::Persistable for RemotedAt {}
621
622/// Runtime security policy.
623#[derive(Clone, Debug, Default, PartialEq)]
624pub struct SecurityPolicy {
625    /// Allowlists for Zircon job policy.
626    pub job_policy: Option<JobPolicyAllowlists>,
627    /// Capability access policy.
628    pub capability_policy: Option<CapabilityPolicyAllowlists>,
629    /// Debug capability registration policy.
630    pub debug_registration_policy: Option<DebugRegistrationPolicyAllowlists>,
631    /// Component child options policy.
632    pub child_policy: Option<ChildPolicyAllowlists>,
633    #[doc(hidden)]
634    pub __source_breaking: fidl::marker::SourceBreaking,
635}
636
637impl fidl::Persistable for SecurityPolicy {}
638
639#[derive(Clone, Debug, Default, PartialEq)]
640pub struct StorageBackingDirectory {
641    pub capability: Option<ComponentCapability>,
642    pub moniker: Option<String>,
643    pub backing_dir_subdir: Option<String>,
644    pub storage_subdir: Option<String>,
645    pub storage_source_moniker: Option<String>,
646    #[doc(hidden)]
647    pub __source_breaking: fidl::marker::SourceBreaking,
648}
649
650impl fidl::Persistable for StorageBackingDirectory {}
651
652#[derive(Clone, Debug, Default, PartialEq)]
653pub struct Void {
654    pub capability: Option<InternalCapability>,
655    pub moniker: Option<String>,
656    #[doc(hidden)]
657    pub __source_breaking: fidl::marker::SourceBreaking,
658}
659
660impl fidl::Persistable for Void {}
661
662#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
663pub enum AggregateCapability {
664    Service(String),
665}
666
667impl AggregateCapability {
668    #[inline]
669    pub fn ordinal(&self) -> u64 {
670        match *self {
671            Self::Service(_) => 1,
672        }
673    }
674}
675
676impl fidl::Persistable for AggregateCapability {}
677
678#[derive(Clone, Debug, PartialEq)]
679pub enum AggregateMember {
680    Child(fidl_fuchsia_component_decl__common::ChildRef),
681    Collection(String),
682    Parent(fidl_fuchsia_component_decl__common::ParentRef),
683    Self_(fidl_fuchsia_component_decl__common::SelfRef),
684}
685
686impl AggregateMember {
687    #[inline]
688    pub fn ordinal(&self) -> u64 {
689        match *self {
690            Self::Child(_) => 1,
691            Self::Collection(_) => 2,
692            Self::Parent(_) => 3,
693            Self::Self_(_) => 4,
694        }
695    }
696}
697
698impl fidl::Persistable for AggregateMember {}
699
700/// Represents the class of capabilities supported to be allowlisted.
701#[derive(Clone, Debug)]
702pub enum AllowlistedCapability {
703    Directory(AllowlistedDirectory),
704    Protocol(AllowlistedProtocol),
705    Service(AllowlistedService),
706    Storage(AllowlistedStorage),
707    Runner(AllowlistedRunner),
708    Resolver(AllowlistedResolver),
709    #[doc(hidden)]
710    __SourceBreaking {
711        unknown_ordinal: u64,
712    },
713}
714
715/// Pattern that matches an unknown `AllowlistedCapability` member.
716#[macro_export]
717macro_rules! AllowlistedCapabilityUnknown {
718    () => {
719        _
720    };
721}
722
723// Custom PartialEq so that unknown variants are not equal to themselves.
724impl PartialEq for AllowlistedCapability {
725    fn eq(&self, other: &Self) -> bool {
726        match (self, other) {
727            (Self::Directory(x), Self::Directory(y)) => *x == *y,
728            (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
729            (Self::Service(x), Self::Service(y)) => *x == *y,
730            (Self::Storage(x), Self::Storage(y)) => *x == *y,
731            (Self::Runner(x), Self::Runner(y)) => *x == *y,
732            (Self::Resolver(x), Self::Resolver(y)) => *x == *y,
733            _ => false,
734        }
735    }
736}
737
738impl AllowlistedCapability {
739    #[inline]
740    pub fn ordinal(&self) -> u64 {
741        match *self {
742            Self::Directory(_) => 1,
743            Self::Protocol(_) => 3,
744            Self::Service(_) => 4,
745            Self::Storage(_) => 5,
746            Self::Runner(_) => 6,
747            Self::Resolver(_) => 7,
748            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
749        }
750    }
751
752    #[inline]
753    pub fn unknown_variant_for_testing() -> Self {
754        Self::__SourceBreaking { unknown_ordinal: 0 }
755    }
756
757    #[inline]
758    pub fn is_unknown(&self) -> bool {
759        match self {
760            Self::__SourceBreaking { .. } => true,
761            _ => false,
762        }
763    }
764}
765
766impl fidl::Persistable for AllowlistedCapability {}
767
768/// Represents the class of capabilities supported to be allowlisted.
769#[derive(Clone, Debug)]
770pub enum AllowlistedDebugRegistration {
771    Protocol(AllowlistedProtocol),
772    #[doc(hidden)]
773    __SourceBreaking {
774        unknown_ordinal: u64,
775    },
776}
777
778/// Pattern that matches an unknown `AllowlistedDebugRegistration` member.
779#[macro_export]
780macro_rules! AllowlistedDebugRegistrationUnknown {
781    () => {
782        _
783    };
784}
785
786// Custom PartialEq so that unknown variants are not equal to themselves.
787impl PartialEq for AllowlistedDebugRegistration {
788    fn eq(&self, other: &Self) -> bool {
789        match (self, other) {
790            (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
791            _ => false,
792        }
793    }
794}
795
796impl AllowlistedDebugRegistration {
797    #[inline]
798    pub fn ordinal(&self) -> u64 {
799        match *self {
800            Self::Protocol(_) => 1,
801            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
802        }
803    }
804
805    #[inline]
806    pub fn unknown_variant_for_testing() -> Self {
807        Self::__SourceBreaking { unknown_ordinal: 0 }
808    }
809
810    #[inline]
811    pub fn is_unknown(&self) -> bool {
812        match self {
813            Self::__SourceBreaking { .. } => true,
814            _ => false,
815        }
816    }
817}
818
819impl fidl::Persistable for AllowlistedDebugRegistration {}
820
821#[derive(Clone, Debug, PartialEq)]
822pub enum CapabilitySource {
823    Component(Component),
824    Framework(Framework),
825    Builtin(Builtin),
826    Namespace(Namespace),
827    Capability(Capability),
828    AnonymizedAggregate(AnonymizedAggregate),
829    FilteredProvider(FilteredProvider),
830    FilteredAggregateProvider(FilteredAggregateProvider),
831    Environment(Environment),
832    Void(Void),
833    RemotedAt(RemotedAt),
834    StorageBackingDirectory(StorageBackingDirectory),
835}
836
837impl CapabilitySource {
838    #[inline]
839    pub fn ordinal(&self) -> u64 {
840        match *self {
841            Self::Component(_) => 1,
842            Self::Framework(_) => 2,
843            Self::Builtin(_) => 3,
844            Self::Namespace(_) => 4,
845            Self::Capability(_) => 5,
846            Self::AnonymizedAggregate(_) => 6,
847            Self::FilteredProvider(_) => 7,
848            Self::FilteredAggregateProvider(_) => 8,
849            Self::Environment(_) => 9,
850            Self::Void(_) => 10,
851            Self::RemotedAt(_) => 11,
852            Self::StorageBackingDirectory(_) => 12,
853        }
854    }
855}
856
857impl fidl::Persistable for CapabilitySource {}
858
859#[derive(Clone, Debug, PartialEq)]
860pub enum ComponentCapability {
861    Use_(fidl_fuchsia_component_decl__common::Use),
862    Offer(fidl_fuchsia_component_decl__common::Offer),
863    Expose(fidl_fuchsia_component_decl__common::Expose),
864    Config(fidl_fuchsia_component_decl__common::Configuration),
865    Dictionary(fidl_fuchsia_component_decl__common::Dictionary),
866    Directory(fidl_fuchsia_component_decl__common::Directory),
867    Environment(EnvironmentCapability),
868    EventStream(fidl_fuchsia_component_decl__common::EventStream),
869    Protocol(fidl_fuchsia_component_decl__common::Protocol),
870    Resolver(fidl_fuchsia_component_decl__common::Resolver),
871    Runner(fidl_fuchsia_component_decl__common::Runner),
872    Service(fidl_fuchsia_component_decl__common::Service),
873    Storage(fidl_fuchsia_component_decl__common::Storage),
874}
875
876impl ComponentCapability {
877    #[inline]
878    pub fn ordinal(&self) -> u64 {
879        match *self {
880            Self::Use_(_) => 1,
881            Self::Offer(_) => 2,
882            Self::Expose(_) => 3,
883            Self::Config(_) => 4,
884            Self::Dictionary(_) => 5,
885            Self::Directory(_) => 6,
886            Self::Environment(_) => 7,
887            Self::EventStream(_) => 8,
888            Self::Protocol(_) => 9,
889            Self::Resolver(_) => 10,
890            Self::Runner(_) => 11,
891            Self::Service(_) => 12,
892            Self::Storage(_) => 13,
893        }
894    }
895}
896
897impl fidl::Persistable for ComponentCapability {}
898
899#[derive(Clone, Debug, PartialEq)]
900pub enum EnvironmentCapability {
901    Runner(EnvironmentSource),
902    Resolver(EnvironmentSource),
903    Debug(EnvironmentSource),
904}
905
906impl EnvironmentCapability {
907    #[inline]
908    pub fn ordinal(&self) -> u64 {
909        match *self {
910            Self::Runner(_) => 1,
911            Self::Resolver(_) => 2,
912            Self::Debug(_) => 3,
913        }
914    }
915}
916
917impl fidl::Persistable for EnvironmentCapability {}
918
919/// Declares a capability to be injected into a component.
920#[derive(Clone, Debug)]
921pub enum InjectedUse {
922    Protocol(InjectedUseProtocol),
923    #[doc(hidden)]
924    __SourceBreaking {
925        unknown_ordinal: u64,
926    },
927}
928
929/// Pattern that matches an unknown `InjectedUse` member.
930#[macro_export]
931macro_rules! InjectedUseUnknown {
932    () => {
933        _
934    };
935}
936
937// Custom PartialEq so that unknown variants are not equal to themselves.
938impl PartialEq for InjectedUse {
939    fn eq(&self, other: &Self) -> bool {
940        match (self, other) {
941            (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
942            _ => false,
943        }
944    }
945}
946
947impl InjectedUse {
948    #[inline]
949    pub fn ordinal(&self) -> u64 {
950        match *self {
951            Self::Protocol(_) => 1,
952            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
953        }
954    }
955
956    #[inline]
957    pub fn unknown_variant_for_testing() -> Self {
958        Self::__SourceBreaking { unknown_ordinal: 0 }
959    }
960
961    #[inline]
962    pub fn is_unknown(&self) -> bool {
963        match self {
964            Self::__SourceBreaking { .. } => true,
965            _ => false,
966        }
967    }
968}
969
970impl fidl::Persistable for InjectedUse {}
971
972#[derive(Clone, Debug, PartialEq)]
973pub enum InternalCapability {
974    Config(String),
975    Dictionary(String),
976    Directory(String),
977    EventStream(InternalEventStreamCapability),
978    Protocol(String),
979    Resolver(String),
980    Runner(String),
981    Service(String),
982    Storage(String),
983}
984
985impl InternalCapability {
986    #[inline]
987    pub fn ordinal(&self) -> u64 {
988        match *self {
989            Self::Config(_) => 1,
990            Self::Dictionary(_) => 2,
991            Self::Directory(_) => 3,
992            Self::EventStream(_) => 4,
993            Self::Protocol(_) => 5,
994            Self::Resolver(_) => 6,
995            Self::Runner(_) => 7,
996            Self::Service(_) => 8,
997            Self::Storage(_) => 9,
998        }
999    }
1000}
1001
1002impl fidl::Persistable for InternalCapability {}
1003
1004pub mod component_sandbox_retriever_ordinals {
1005    pub const GET_MY_SANDBOX: u64 = 0x61ca075fb9860e84;
1006}
1007
1008mod internal {
1009    use super::*;
1010    unsafe impl fidl::encoding::TypeMarker for BuiltinBootResolver {
1011        type Owned = Self;
1012
1013        #[inline(always)]
1014        fn inline_align(_context: fidl::encoding::Context) -> usize {
1015            std::mem::align_of::<u8>()
1016        }
1017
1018        #[inline(always)]
1019        fn inline_size(_context: fidl::encoding::Context) -> usize {
1020            std::mem::size_of::<u8>()
1021        }
1022
1023        #[inline(always)]
1024        fn encode_is_copy() -> bool {
1025            true
1026        }
1027
1028        #[inline(always)]
1029        fn decode_is_copy() -> bool {
1030            false
1031        }
1032    }
1033
1034    impl fidl::encoding::ValueTypeMarker for BuiltinBootResolver {
1035        type Borrowed<'a> = Self;
1036        #[inline(always)]
1037        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1038            *value
1039        }
1040    }
1041
1042    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1043        for BuiltinBootResolver
1044    {
1045        #[inline]
1046        unsafe fn encode(
1047            self,
1048            encoder: &mut fidl::encoding::Encoder<'_, D>,
1049            offset: usize,
1050            _depth: fidl::encoding::Depth,
1051        ) -> fidl::Result<()> {
1052            encoder.debug_check_bounds::<Self>(offset);
1053            encoder.write_num(self.into_primitive(), offset);
1054            Ok(())
1055        }
1056    }
1057
1058    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BuiltinBootResolver {
1059        #[inline(always)]
1060        fn new_empty() -> Self {
1061            Self::None
1062        }
1063
1064        #[inline]
1065        unsafe fn decode(
1066            &mut self,
1067            decoder: &mut fidl::encoding::Decoder<'_, D>,
1068            offset: usize,
1069            _depth: fidl::encoding::Depth,
1070        ) -> fidl::Result<()> {
1071            decoder.debug_check_bounds::<Self>(offset);
1072            let prim = decoder.read_num::<u8>(offset);
1073
1074            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1075            Ok(())
1076        }
1077    }
1078    unsafe impl fidl::encoding::TypeMarker for LogDestination {
1079        type Owned = Self;
1080
1081        #[inline(always)]
1082        fn inline_align(_context: fidl::encoding::Context) -> usize {
1083            std::mem::align_of::<u8>()
1084        }
1085
1086        #[inline(always)]
1087        fn inline_size(_context: fidl::encoding::Context) -> usize {
1088            std::mem::size_of::<u8>()
1089        }
1090
1091        #[inline(always)]
1092        fn encode_is_copy() -> bool {
1093            true
1094        }
1095
1096        #[inline(always)]
1097        fn decode_is_copy() -> bool {
1098            false
1099        }
1100    }
1101
1102    impl fidl::encoding::ValueTypeMarker for LogDestination {
1103        type Borrowed<'a> = Self;
1104        #[inline(always)]
1105        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1106            *value
1107        }
1108    }
1109
1110    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for LogDestination {
1111        #[inline]
1112        unsafe fn encode(
1113            self,
1114            encoder: &mut fidl::encoding::Encoder<'_, D>,
1115            offset: usize,
1116            _depth: fidl::encoding::Depth,
1117        ) -> fidl::Result<()> {
1118            encoder.debug_check_bounds::<Self>(offset);
1119            encoder.write_num(self.into_primitive(), offset);
1120            Ok(())
1121        }
1122    }
1123
1124    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LogDestination {
1125        #[inline(always)]
1126        fn new_empty() -> Self {
1127            Self::Syslog
1128        }
1129
1130        #[inline]
1131        unsafe fn decode(
1132            &mut self,
1133            decoder: &mut fidl::encoding::Decoder<'_, D>,
1134            offset: usize,
1135            _depth: fidl::encoding::Depth,
1136        ) -> fidl::Result<()> {
1137            decoder.debug_check_bounds::<Self>(offset);
1138            let prim = decoder.read_num::<u8>(offset);
1139
1140            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1141            Ok(())
1142        }
1143    }
1144    unsafe impl fidl::encoding::TypeMarker for RealmBuilderResolverAndRunner {
1145        type Owned = Self;
1146
1147        #[inline(always)]
1148        fn inline_align(_context: fidl::encoding::Context) -> usize {
1149            std::mem::align_of::<u8>()
1150        }
1151
1152        #[inline(always)]
1153        fn inline_size(_context: fidl::encoding::Context) -> usize {
1154            std::mem::size_of::<u8>()
1155        }
1156
1157        #[inline(always)]
1158        fn encode_is_copy() -> bool {
1159            true
1160        }
1161
1162        #[inline(always)]
1163        fn decode_is_copy() -> bool {
1164            false
1165        }
1166    }
1167
1168    impl fidl::encoding::ValueTypeMarker for RealmBuilderResolverAndRunner {
1169        type Borrowed<'a> = Self;
1170        #[inline(always)]
1171        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1172            *value
1173        }
1174    }
1175
1176    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1177        for RealmBuilderResolverAndRunner
1178    {
1179        #[inline]
1180        unsafe fn encode(
1181            self,
1182            encoder: &mut fidl::encoding::Encoder<'_, D>,
1183            offset: usize,
1184            _depth: fidl::encoding::Depth,
1185        ) -> fidl::Result<()> {
1186            encoder.debug_check_bounds::<Self>(offset);
1187            encoder.write_num(self.into_primitive(), offset);
1188            Ok(())
1189        }
1190    }
1191
1192    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1193        for RealmBuilderResolverAndRunner
1194    {
1195        #[inline(always)]
1196        fn new_empty() -> Self {
1197            Self::None
1198        }
1199
1200        #[inline]
1201        unsafe fn decode(
1202            &mut self,
1203            decoder: &mut fidl::encoding::Decoder<'_, D>,
1204            offset: usize,
1205            _depth: fidl::encoding::Depth,
1206        ) -> fidl::Result<()> {
1207            decoder.debug_check_bounds::<Self>(offset);
1208            let prim = decoder.read_num::<u8>(offset);
1209
1210            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1211            Ok(())
1212        }
1213    }
1214    unsafe impl fidl::encoding::TypeMarker for TraceProvider {
1215        type Owned = Self;
1216
1217        #[inline(always)]
1218        fn inline_align(_context: fidl::encoding::Context) -> usize {
1219            std::mem::align_of::<u8>()
1220        }
1221
1222        #[inline(always)]
1223        fn inline_size(_context: fidl::encoding::Context) -> usize {
1224            std::mem::size_of::<u8>()
1225        }
1226
1227        #[inline(always)]
1228        fn encode_is_copy() -> bool {
1229            true
1230        }
1231
1232        #[inline(always)]
1233        fn decode_is_copy() -> bool {
1234            false
1235        }
1236    }
1237
1238    impl fidl::encoding::ValueTypeMarker for TraceProvider {
1239        type Borrowed<'a> = Self;
1240        #[inline(always)]
1241        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1242            *value
1243        }
1244    }
1245
1246    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for TraceProvider {
1247        #[inline]
1248        unsafe fn encode(
1249            self,
1250            encoder: &mut fidl::encoding::Encoder<'_, D>,
1251            offset: usize,
1252            _depth: fidl::encoding::Depth,
1253        ) -> fidl::Result<()> {
1254            encoder.debug_check_bounds::<Self>(offset);
1255            encoder.write_num(self.into_primitive(), offset);
1256            Ok(())
1257        }
1258    }
1259
1260    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TraceProvider {
1261        #[inline(always)]
1262        fn new_empty() -> Self {
1263            Self::Namespace
1264        }
1265
1266        #[inline]
1267        unsafe fn decode(
1268            &mut self,
1269            decoder: &mut fidl::encoding::Decoder<'_, D>,
1270            offset: usize,
1271            _depth: fidl::encoding::Depth,
1272        ) -> fidl::Result<()> {
1273            decoder.debug_check_bounds::<Self>(offset);
1274            let prim = decoder.read_num::<u8>(offset);
1275
1276            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1277            Ok(())
1278        }
1279    }
1280    unsafe impl fidl::encoding::TypeMarker for VmexSource {
1281        type Owned = Self;
1282
1283        #[inline(always)]
1284        fn inline_align(_context: fidl::encoding::Context) -> usize {
1285            std::mem::align_of::<u8>()
1286        }
1287
1288        #[inline(always)]
1289        fn inline_size(_context: fidl::encoding::Context) -> usize {
1290            std::mem::size_of::<u8>()
1291        }
1292
1293        #[inline(always)]
1294        fn encode_is_copy() -> bool {
1295            true
1296        }
1297
1298        #[inline(always)]
1299        fn decode_is_copy() -> bool {
1300            false
1301        }
1302    }
1303
1304    impl fidl::encoding::ValueTypeMarker for VmexSource {
1305        type Borrowed<'a> = Self;
1306        #[inline(always)]
1307        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1308            *value
1309        }
1310    }
1311
1312    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for VmexSource {
1313        #[inline]
1314        unsafe fn encode(
1315            self,
1316            encoder: &mut fidl::encoding::Encoder<'_, D>,
1317            offset: usize,
1318            _depth: fidl::encoding::Depth,
1319        ) -> fidl::Result<()> {
1320            encoder.debug_check_bounds::<Self>(offset);
1321            encoder.write_num(self.into_primitive(), offset);
1322            Ok(())
1323        }
1324    }
1325
1326    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VmexSource {
1327        #[inline(always)]
1328        fn new_empty() -> Self {
1329            Self::SystemResource
1330        }
1331
1332        #[inline]
1333        unsafe fn decode(
1334            &mut self,
1335            decoder: &mut fidl::encoding::Decoder<'_, D>,
1336            offset: usize,
1337            _depth: fidl::encoding::Depth,
1338        ) -> fidl::Result<()> {
1339            decoder.debug_check_bounds::<Self>(offset);
1340            let prim = decoder.read_num::<u8>(offset);
1341
1342            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1343            Ok(())
1344        }
1345    }
1346
1347    impl AbiRevisionPolicy {
1348        #[inline(always)]
1349        fn max_ordinal_present(&self) -> u64 {
1350            if let Some(_) = self.allowlist {
1351                return 1;
1352            }
1353            0
1354        }
1355    }
1356
1357    impl fidl::encoding::ValueTypeMarker for AbiRevisionPolicy {
1358        type Borrowed<'a> = &'a Self;
1359        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1360            value
1361        }
1362    }
1363
1364    unsafe impl fidl::encoding::TypeMarker for AbiRevisionPolicy {
1365        type Owned = Self;
1366
1367        #[inline(always)]
1368        fn inline_align(_context: fidl::encoding::Context) -> usize {
1369            8
1370        }
1371
1372        #[inline(always)]
1373        fn inline_size(_context: fidl::encoding::Context) -> usize {
1374            16
1375        }
1376    }
1377
1378    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AbiRevisionPolicy, D>
1379        for &AbiRevisionPolicy
1380    {
1381        unsafe fn encode(
1382            self,
1383            encoder: &mut fidl::encoding::Encoder<'_, D>,
1384            offset: usize,
1385            mut depth: fidl::encoding::Depth,
1386        ) -> fidl::Result<()> {
1387            encoder.debug_check_bounds::<AbiRevisionPolicy>(offset);
1388            // Vector header
1389            let max_ordinal: u64 = self.max_ordinal_present();
1390            encoder.write_num(max_ordinal, offset);
1391            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1392            // Calling encoder.out_of_line_offset(0) is not allowed.
1393            if max_ordinal == 0 {
1394                return Ok(());
1395            }
1396            depth.increment()?;
1397            let envelope_size = 8;
1398            let bytes_len = max_ordinal as usize * envelope_size;
1399            #[allow(unused_variables)]
1400            let offset = encoder.out_of_line_offset(bytes_len);
1401            let mut _prev_end_offset: usize = 0;
1402            if 1 > max_ordinal {
1403                return Ok(());
1404            }
1405
1406            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1407            // are envelope_size bytes.
1408            let cur_offset: usize = (1 - 1) * envelope_size;
1409
1410            // Zero reserved fields.
1411            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1412
1413            // Safety:
1414            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1415            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1416            //   envelope_size bytes, there is always sufficient room.
1417            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
1418            self.allowlist.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
1419            encoder, offset + cur_offset, depth
1420        )?;
1421
1422            _prev_end_offset = cur_offset + envelope_size;
1423
1424            Ok(())
1425        }
1426    }
1427
1428    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AbiRevisionPolicy {
1429        #[inline(always)]
1430        fn new_empty() -> Self {
1431            Self::default()
1432        }
1433
1434        unsafe fn decode(
1435            &mut self,
1436            decoder: &mut fidl::encoding::Decoder<'_, D>,
1437            offset: usize,
1438            mut depth: fidl::encoding::Depth,
1439        ) -> fidl::Result<()> {
1440            decoder.debug_check_bounds::<Self>(offset);
1441            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1442                None => return Err(fidl::Error::NotNullable),
1443                Some(len) => len,
1444            };
1445            // Calling decoder.out_of_line_offset(0) is not allowed.
1446            if len == 0 {
1447                return Ok(());
1448            };
1449            depth.increment()?;
1450            let envelope_size = 8;
1451            let bytes_len = len * envelope_size;
1452            let offset = decoder.out_of_line_offset(bytes_len)?;
1453            // Decode the envelope for each type.
1454            let mut _next_ordinal_to_read = 0;
1455            let mut next_offset = offset;
1456            let end_offset = offset + bytes_len;
1457            _next_ordinal_to_read += 1;
1458            if next_offset >= end_offset {
1459                return Ok(());
1460            }
1461
1462            // Decode unknown envelopes for gaps in ordinals.
1463            while _next_ordinal_to_read < 1 {
1464                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1465                _next_ordinal_to_read += 1;
1466                next_offset += envelope_size;
1467            }
1468
1469            let next_out_of_line = decoder.next_out_of_line();
1470            let handles_before = decoder.remaining_handles();
1471            if let Some((inlined, num_bytes, num_handles)) =
1472                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1473            {
1474                let member_inline_size = <fidl::encoding::Vector<
1475                    fidl::encoding::BoundedString<4096>,
1476                    128,
1477                > as fidl::encoding::TypeMarker>::inline_size(
1478                    decoder.context
1479                );
1480                if inlined != (member_inline_size <= 4) {
1481                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1482                }
1483                let inner_offset;
1484                let mut inner_depth = depth.clone();
1485                if inlined {
1486                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1487                    inner_offset = next_offset;
1488                } else {
1489                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1490                    inner_depth.increment()?;
1491                }
1492                let val_ref = self.allowlist.get_or_insert_with(|| {
1493                    fidl::new_empty!(
1494                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
1495                        D
1496                    )
1497                });
1498                fidl::decode!(
1499                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
1500                    D,
1501                    val_ref,
1502                    decoder,
1503                    inner_offset,
1504                    inner_depth
1505                )?;
1506                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1507                {
1508                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1509                }
1510                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1511                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1512                }
1513            }
1514
1515            next_offset += envelope_size;
1516
1517            // Decode the remaining unknown envelopes.
1518            while next_offset < end_offset {
1519                _next_ordinal_to_read += 1;
1520                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1521                next_offset += envelope_size;
1522            }
1523
1524            Ok(())
1525        }
1526    }
1527
1528    impl AllowlistedDirectory {
1529        #[inline(always)]
1530        fn max_ordinal_present(&self) -> u64 {
1531            0
1532        }
1533    }
1534
1535    impl fidl::encoding::ValueTypeMarker for AllowlistedDirectory {
1536        type Borrowed<'a> = &'a Self;
1537        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1538            value
1539        }
1540    }
1541
1542    unsafe impl fidl::encoding::TypeMarker for AllowlistedDirectory {
1543        type Owned = Self;
1544
1545        #[inline(always)]
1546        fn inline_align(_context: fidl::encoding::Context) -> usize {
1547            8
1548        }
1549
1550        #[inline(always)]
1551        fn inline_size(_context: fidl::encoding::Context) -> usize {
1552            16
1553        }
1554    }
1555
1556    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedDirectory, D>
1557        for &AllowlistedDirectory
1558    {
1559        unsafe fn encode(
1560            self,
1561            encoder: &mut fidl::encoding::Encoder<'_, D>,
1562            offset: usize,
1563            mut depth: fidl::encoding::Depth,
1564        ) -> fidl::Result<()> {
1565            encoder.debug_check_bounds::<AllowlistedDirectory>(offset);
1566            // Vector header
1567            let max_ordinal: u64 = self.max_ordinal_present();
1568            encoder.write_num(max_ordinal, offset);
1569            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1570            // Calling encoder.out_of_line_offset(0) is not allowed.
1571            if max_ordinal == 0 {
1572                return Ok(());
1573            }
1574            depth.increment()?;
1575            let envelope_size = 8;
1576            let bytes_len = max_ordinal as usize * envelope_size;
1577            #[allow(unused_variables)]
1578            let offset = encoder.out_of_line_offset(bytes_len);
1579            let mut _prev_end_offset: usize = 0;
1580
1581            Ok(())
1582        }
1583    }
1584
1585    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedDirectory {
1586        #[inline(always)]
1587        fn new_empty() -> Self {
1588            Self::default()
1589        }
1590
1591        unsafe fn decode(
1592            &mut self,
1593            decoder: &mut fidl::encoding::Decoder<'_, D>,
1594            offset: usize,
1595            mut depth: fidl::encoding::Depth,
1596        ) -> fidl::Result<()> {
1597            decoder.debug_check_bounds::<Self>(offset);
1598            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1599                None => return Err(fidl::Error::NotNullable),
1600                Some(len) => len,
1601            };
1602            // Calling decoder.out_of_line_offset(0) is not allowed.
1603            if len == 0 {
1604                return Ok(());
1605            };
1606            depth.increment()?;
1607            let envelope_size = 8;
1608            let bytes_len = len * envelope_size;
1609            let offset = decoder.out_of_line_offset(bytes_len)?;
1610            // Decode the envelope for each type.
1611            let mut _next_ordinal_to_read = 0;
1612            let mut next_offset = offset;
1613            let end_offset = offset + bytes_len;
1614
1615            // Decode the remaining unknown envelopes.
1616            while next_offset < end_offset {
1617                _next_ordinal_to_read += 1;
1618                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1619                next_offset += envelope_size;
1620            }
1621
1622            Ok(())
1623        }
1624    }
1625
1626    impl AllowlistedProtocol {
1627        #[inline(always)]
1628        fn max_ordinal_present(&self) -> u64 {
1629            0
1630        }
1631    }
1632
1633    impl fidl::encoding::ValueTypeMarker for AllowlistedProtocol {
1634        type Borrowed<'a> = &'a Self;
1635        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1636            value
1637        }
1638    }
1639
1640    unsafe impl fidl::encoding::TypeMarker for AllowlistedProtocol {
1641        type Owned = Self;
1642
1643        #[inline(always)]
1644        fn inline_align(_context: fidl::encoding::Context) -> usize {
1645            8
1646        }
1647
1648        #[inline(always)]
1649        fn inline_size(_context: fidl::encoding::Context) -> usize {
1650            16
1651        }
1652    }
1653
1654    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedProtocol, D>
1655        for &AllowlistedProtocol
1656    {
1657        unsafe fn encode(
1658            self,
1659            encoder: &mut fidl::encoding::Encoder<'_, D>,
1660            offset: usize,
1661            mut depth: fidl::encoding::Depth,
1662        ) -> fidl::Result<()> {
1663            encoder.debug_check_bounds::<AllowlistedProtocol>(offset);
1664            // Vector header
1665            let max_ordinal: u64 = self.max_ordinal_present();
1666            encoder.write_num(max_ordinal, offset);
1667            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1668            // Calling encoder.out_of_line_offset(0) is not allowed.
1669            if max_ordinal == 0 {
1670                return Ok(());
1671            }
1672            depth.increment()?;
1673            let envelope_size = 8;
1674            let bytes_len = max_ordinal as usize * envelope_size;
1675            #[allow(unused_variables)]
1676            let offset = encoder.out_of_line_offset(bytes_len);
1677            let mut _prev_end_offset: usize = 0;
1678
1679            Ok(())
1680        }
1681    }
1682
1683    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedProtocol {
1684        #[inline(always)]
1685        fn new_empty() -> Self {
1686            Self::default()
1687        }
1688
1689        unsafe fn decode(
1690            &mut self,
1691            decoder: &mut fidl::encoding::Decoder<'_, D>,
1692            offset: usize,
1693            mut depth: fidl::encoding::Depth,
1694        ) -> fidl::Result<()> {
1695            decoder.debug_check_bounds::<Self>(offset);
1696            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1697                None => return Err(fidl::Error::NotNullable),
1698                Some(len) => len,
1699            };
1700            // Calling decoder.out_of_line_offset(0) is not allowed.
1701            if len == 0 {
1702                return Ok(());
1703            };
1704            depth.increment()?;
1705            let envelope_size = 8;
1706            let bytes_len = len * envelope_size;
1707            let offset = decoder.out_of_line_offset(bytes_len)?;
1708            // Decode the envelope for each type.
1709            let mut _next_ordinal_to_read = 0;
1710            let mut next_offset = offset;
1711            let end_offset = offset + bytes_len;
1712
1713            // Decode the remaining unknown envelopes.
1714            while next_offset < end_offset {
1715                _next_ordinal_to_read += 1;
1716                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1717                next_offset += envelope_size;
1718            }
1719
1720            Ok(())
1721        }
1722    }
1723
1724    impl AllowlistedResolver {
1725        #[inline(always)]
1726        fn max_ordinal_present(&self) -> u64 {
1727            0
1728        }
1729    }
1730
1731    impl fidl::encoding::ValueTypeMarker for AllowlistedResolver {
1732        type Borrowed<'a> = &'a Self;
1733        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1734            value
1735        }
1736    }
1737
1738    unsafe impl fidl::encoding::TypeMarker for AllowlistedResolver {
1739        type Owned = Self;
1740
1741        #[inline(always)]
1742        fn inline_align(_context: fidl::encoding::Context) -> usize {
1743            8
1744        }
1745
1746        #[inline(always)]
1747        fn inline_size(_context: fidl::encoding::Context) -> usize {
1748            16
1749        }
1750    }
1751
1752    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedResolver, D>
1753        for &AllowlistedResolver
1754    {
1755        unsafe fn encode(
1756            self,
1757            encoder: &mut fidl::encoding::Encoder<'_, D>,
1758            offset: usize,
1759            mut depth: fidl::encoding::Depth,
1760        ) -> fidl::Result<()> {
1761            encoder.debug_check_bounds::<AllowlistedResolver>(offset);
1762            // Vector header
1763            let max_ordinal: u64 = self.max_ordinal_present();
1764            encoder.write_num(max_ordinal, offset);
1765            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1766            // Calling encoder.out_of_line_offset(0) is not allowed.
1767            if max_ordinal == 0 {
1768                return Ok(());
1769            }
1770            depth.increment()?;
1771            let envelope_size = 8;
1772            let bytes_len = max_ordinal as usize * envelope_size;
1773            #[allow(unused_variables)]
1774            let offset = encoder.out_of_line_offset(bytes_len);
1775            let mut _prev_end_offset: usize = 0;
1776
1777            Ok(())
1778        }
1779    }
1780
1781    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedResolver {
1782        #[inline(always)]
1783        fn new_empty() -> Self {
1784            Self::default()
1785        }
1786
1787        unsafe fn decode(
1788            &mut self,
1789            decoder: &mut fidl::encoding::Decoder<'_, D>,
1790            offset: usize,
1791            mut depth: fidl::encoding::Depth,
1792        ) -> fidl::Result<()> {
1793            decoder.debug_check_bounds::<Self>(offset);
1794            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1795                None => return Err(fidl::Error::NotNullable),
1796                Some(len) => len,
1797            };
1798            // Calling decoder.out_of_line_offset(0) is not allowed.
1799            if len == 0 {
1800                return Ok(());
1801            };
1802            depth.increment()?;
1803            let envelope_size = 8;
1804            let bytes_len = len * envelope_size;
1805            let offset = decoder.out_of_line_offset(bytes_len)?;
1806            // Decode the envelope for each type.
1807            let mut _next_ordinal_to_read = 0;
1808            let mut next_offset = offset;
1809            let end_offset = offset + bytes_len;
1810
1811            // Decode the remaining unknown envelopes.
1812            while next_offset < end_offset {
1813                _next_ordinal_to_read += 1;
1814                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1815                next_offset += envelope_size;
1816            }
1817
1818            Ok(())
1819        }
1820    }
1821
1822    impl AllowlistedRunner {
1823        #[inline(always)]
1824        fn max_ordinal_present(&self) -> u64 {
1825            0
1826        }
1827    }
1828
1829    impl fidl::encoding::ValueTypeMarker for AllowlistedRunner {
1830        type Borrowed<'a> = &'a Self;
1831        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1832            value
1833        }
1834    }
1835
1836    unsafe impl fidl::encoding::TypeMarker for AllowlistedRunner {
1837        type Owned = Self;
1838
1839        #[inline(always)]
1840        fn inline_align(_context: fidl::encoding::Context) -> usize {
1841            8
1842        }
1843
1844        #[inline(always)]
1845        fn inline_size(_context: fidl::encoding::Context) -> usize {
1846            16
1847        }
1848    }
1849
1850    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedRunner, D>
1851        for &AllowlistedRunner
1852    {
1853        unsafe fn encode(
1854            self,
1855            encoder: &mut fidl::encoding::Encoder<'_, D>,
1856            offset: usize,
1857            mut depth: fidl::encoding::Depth,
1858        ) -> fidl::Result<()> {
1859            encoder.debug_check_bounds::<AllowlistedRunner>(offset);
1860            // Vector header
1861            let max_ordinal: u64 = self.max_ordinal_present();
1862            encoder.write_num(max_ordinal, offset);
1863            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1864            // Calling encoder.out_of_line_offset(0) is not allowed.
1865            if max_ordinal == 0 {
1866                return Ok(());
1867            }
1868            depth.increment()?;
1869            let envelope_size = 8;
1870            let bytes_len = max_ordinal as usize * envelope_size;
1871            #[allow(unused_variables)]
1872            let offset = encoder.out_of_line_offset(bytes_len);
1873            let mut _prev_end_offset: usize = 0;
1874
1875            Ok(())
1876        }
1877    }
1878
1879    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedRunner {
1880        #[inline(always)]
1881        fn new_empty() -> Self {
1882            Self::default()
1883        }
1884
1885        unsafe fn decode(
1886            &mut self,
1887            decoder: &mut fidl::encoding::Decoder<'_, D>,
1888            offset: usize,
1889            mut depth: fidl::encoding::Depth,
1890        ) -> fidl::Result<()> {
1891            decoder.debug_check_bounds::<Self>(offset);
1892            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1893                None => return Err(fidl::Error::NotNullable),
1894                Some(len) => len,
1895            };
1896            // Calling decoder.out_of_line_offset(0) is not allowed.
1897            if len == 0 {
1898                return Ok(());
1899            };
1900            depth.increment()?;
1901            let envelope_size = 8;
1902            let bytes_len = len * envelope_size;
1903            let offset = decoder.out_of_line_offset(bytes_len)?;
1904            // Decode the envelope for each type.
1905            let mut _next_ordinal_to_read = 0;
1906            let mut next_offset = offset;
1907            let end_offset = offset + bytes_len;
1908
1909            // Decode the remaining unknown envelopes.
1910            while next_offset < end_offset {
1911                _next_ordinal_to_read += 1;
1912                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1913                next_offset += envelope_size;
1914            }
1915
1916            Ok(())
1917        }
1918    }
1919
1920    impl AllowlistedService {
1921        #[inline(always)]
1922        fn max_ordinal_present(&self) -> u64 {
1923            0
1924        }
1925    }
1926
1927    impl fidl::encoding::ValueTypeMarker for AllowlistedService {
1928        type Borrowed<'a> = &'a Self;
1929        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1930            value
1931        }
1932    }
1933
1934    unsafe impl fidl::encoding::TypeMarker for AllowlistedService {
1935        type Owned = Self;
1936
1937        #[inline(always)]
1938        fn inline_align(_context: fidl::encoding::Context) -> usize {
1939            8
1940        }
1941
1942        #[inline(always)]
1943        fn inline_size(_context: fidl::encoding::Context) -> usize {
1944            16
1945        }
1946    }
1947
1948    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedService, D>
1949        for &AllowlistedService
1950    {
1951        unsafe fn encode(
1952            self,
1953            encoder: &mut fidl::encoding::Encoder<'_, D>,
1954            offset: usize,
1955            mut depth: fidl::encoding::Depth,
1956        ) -> fidl::Result<()> {
1957            encoder.debug_check_bounds::<AllowlistedService>(offset);
1958            // Vector header
1959            let max_ordinal: u64 = self.max_ordinal_present();
1960            encoder.write_num(max_ordinal, offset);
1961            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1962            // Calling encoder.out_of_line_offset(0) is not allowed.
1963            if max_ordinal == 0 {
1964                return Ok(());
1965            }
1966            depth.increment()?;
1967            let envelope_size = 8;
1968            let bytes_len = max_ordinal as usize * envelope_size;
1969            #[allow(unused_variables)]
1970            let offset = encoder.out_of_line_offset(bytes_len);
1971            let mut _prev_end_offset: usize = 0;
1972
1973            Ok(())
1974        }
1975    }
1976
1977    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedService {
1978        #[inline(always)]
1979        fn new_empty() -> Self {
1980            Self::default()
1981        }
1982
1983        unsafe fn decode(
1984            &mut self,
1985            decoder: &mut fidl::encoding::Decoder<'_, D>,
1986            offset: usize,
1987            mut depth: fidl::encoding::Depth,
1988        ) -> fidl::Result<()> {
1989            decoder.debug_check_bounds::<Self>(offset);
1990            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1991                None => return Err(fidl::Error::NotNullable),
1992                Some(len) => len,
1993            };
1994            // Calling decoder.out_of_line_offset(0) is not allowed.
1995            if len == 0 {
1996                return Ok(());
1997            };
1998            depth.increment()?;
1999            let envelope_size = 8;
2000            let bytes_len = len * envelope_size;
2001            let offset = decoder.out_of_line_offset(bytes_len)?;
2002            // Decode the envelope for each type.
2003            let mut _next_ordinal_to_read = 0;
2004            let mut next_offset = offset;
2005            let end_offset = offset + bytes_len;
2006
2007            // Decode the remaining unknown envelopes.
2008            while next_offset < end_offset {
2009                _next_ordinal_to_read += 1;
2010                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2011                next_offset += envelope_size;
2012            }
2013
2014            Ok(())
2015        }
2016    }
2017
2018    impl AllowlistedStorage {
2019        #[inline(always)]
2020        fn max_ordinal_present(&self) -> u64 {
2021            0
2022        }
2023    }
2024
2025    impl fidl::encoding::ValueTypeMarker for AllowlistedStorage {
2026        type Borrowed<'a> = &'a Self;
2027        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2028            value
2029        }
2030    }
2031
2032    unsafe impl fidl::encoding::TypeMarker for AllowlistedStorage {
2033        type Owned = Self;
2034
2035        #[inline(always)]
2036        fn inline_align(_context: fidl::encoding::Context) -> usize {
2037            8
2038        }
2039
2040        #[inline(always)]
2041        fn inline_size(_context: fidl::encoding::Context) -> usize {
2042            16
2043        }
2044    }
2045
2046    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedStorage, D>
2047        for &AllowlistedStorage
2048    {
2049        unsafe fn encode(
2050            self,
2051            encoder: &mut fidl::encoding::Encoder<'_, D>,
2052            offset: usize,
2053            mut depth: fidl::encoding::Depth,
2054        ) -> fidl::Result<()> {
2055            encoder.debug_check_bounds::<AllowlistedStorage>(offset);
2056            // Vector header
2057            let max_ordinal: u64 = self.max_ordinal_present();
2058            encoder.write_num(max_ordinal, offset);
2059            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2060            // Calling encoder.out_of_line_offset(0) is not allowed.
2061            if max_ordinal == 0 {
2062                return Ok(());
2063            }
2064            depth.increment()?;
2065            let envelope_size = 8;
2066            let bytes_len = max_ordinal as usize * envelope_size;
2067            #[allow(unused_variables)]
2068            let offset = encoder.out_of_line_offset(bytes_len);
2069            let mut _prev_end_offset: usize = 0;
2070
2071            Ok(())
2072        }
2073    }
2074
2075    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedStorage {
2076        #[inline(always)]
2077        fn new_empty() -> Self {
2078            Self::default()
2079        }
2080
2081        unsafe fn decode(
2082            &mut self,
2083            decoder: &mut fidl::encoding::Decoder<'_, D>,
2084            offset: usize,
2085            mut depth: fidl::encoding::Depth,
2086        ) -> fidl::Result<()> {
2087            decoder.debug_check_bounds::<Self>(offset);
2088            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2089                None => return Err(fidl::Error::NotNullable),
2090                Some(len) => len,
2091            };
2092            // Calling decoder.out_of_line_offset(0) is not allowed.
2093            if len == 0 {
2094                return Ok(());
2095            };
2096            depth.increment()?;
2097            let envelope_size = 8;
2098            let bytes_len = len * envelope_size;
2099            let offset = decoder.out_of_line_offset(bytes_len)?;
2100            // Decode the envelope for each type.
2101            let mut _next_ordinal_to_read = 0;
2102            let mut next_offset = offset;
2103            let end_offset = offset + bytes_len;
2104
2105            // Decode the remaining unknown envelopes.
2106            while next_offset < end_offset {
2107                _next_ordinal_to_read += 1;
2108                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2109                next_offset += envelope_size;
2110            }
2111
2112            Ok(())
2113        }
2114    }
2115
2116    impl AnonymizedAggregate {
2117        #[inline(always)]
2118        fn max_ordinal_present(&self) -> u64 {
2119            if let Some(_) = self.instances {
2120                return 5;
2121            }
2122            if let Some(_) = self.members {
2123                return 3;
2124            }
2125            if let Some(_) = self.moniker {
2126                return 2;
2127            }
2128            if let Some(_) = self.capability {
2129                return 1;
2130            }
2131            0
2132        }
2133    }
2134
2135    impl fidl::encoding::ValueTypeMarker for AnonymizedAggregate {
2136        type Borrowed<'a> = &'a Self;
2137        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2138            value
2139        }
2140    }
2141
2142    unsafe impl fidl::encoding::TypeMarker for AnonymizedAggregate {
2143        type Owned = Self;
2144
2145        #[inline(always)]
2146        fn inline_align(_context: fidl::encoding::Context) -> usize {
2147            8
2148        }
2149
2150        #[inline(always)]
2151        fn inline_size(_context: fidl::encoding::Context) -> usize {
2152            16
2153        }
2154    }
2155
2156    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AnonymizedAggregate, D>
2157        for &AnonymizedAggregate
2158    {
2159        unsafe fn encode(
2160            self,
2161            encoder: &mut fidl::encoding::Encoder<'_, D>,
2162            offset: usize,
2163            mut depth: fidl::encoding::Depth,
2164        ) -> fidl::Result<()> {
2165            encoder.debug_check_bounds::<AnonymizedAggregate>(offset);
2166            // Vector header
2167            let max_ordinal: u64 = self.max_ordinal_present();
2168            encoder.write_num(max_ordinal, offset);
2169            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2170            // Calling encoder.out_of_line_offset(0) is not allowed.
2171            if max_ordinal == 0 {
2172                return Ok(());
2173            }
2174            depth.increment()?;
2175            let envelope_size = 8;
2176            let bytes_len = max_ordinal as usize * envelope_size;
2177            #[allow(unused_variables)]
2178            let offset = encoder.out_of_line_offset(bytes_len);
2179            let mut _prev_end_offset: usize = 0;
2180            if 1 > max_ordinal {
2181                return Ok(());
2182            }
2183
2184            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2185            // are envelope_size bytes.
2186            let cur_offset: usize = (1 - 1) * envelope_size;
2187
2188            // Zero reserved fields.
2189            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2190
2191            // Safety:
2192            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2193            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2194            //   envelope_size bytes, there is always sufficient room.
2195            fidl::encoding::encode_in_envelope_optional::<AggregateCapability, D>(
2196                self.capability
2197                    .as_ref()
2198                    .map(<AggregateCapability as fidl::encoding::ValueTypeMarker>::borrow),
2199                encoder,
2200                offset + cur_offset,
2201                depth,
2202            )?;
2203
2204            _prev_end_offset = cur_offset + envelope_size;
2205            if 2 > max_ordinal {
2206                return Ok(());
2207            }
2208
2209            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2210            // are envelope_size bytes.
2211            let cur_offset: usize = (2 - 1) * envelope_size;
2212
2213            // Zero reserved fields.
2214            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2215
2216            // Safety:
2217            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2218            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2219            //   envelope_size bytes, there is always sufficient room.
2220            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
2221            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
2222            encoder, offset + cur_offset, depth
2223        )?;
2224
2225            _prev_end_offset = cur_offset + envelope_size;
2226            if 3 > max_ordinal {
2227                return Ok(());
2228            }
2229
2230            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2231            // are envelope_size bytes.
2232            let cur_offset: usize = (3 - 1) * envelope_size;
2233
2234            // Zero reserved fields.
2235            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2236
2237            // Safety:
2238            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2239            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2240            //   envelope_size bytes, there is always sufficient room.
2241            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<AggregateMember>, D>(
2242            self.members.as_ref().map(<fidl::encoding::UnboundedVector<AggregateMember> as fidl::encoding::ValueTypeMarker>::borrow),
2243            encoder, offset + cur_offset, depth
2244        )?;
2245
2246            _prev_end_offset = cur_offset + envelope_size;
2247            if 5 > max_ordinal {
2248                return Ok(());
2249            }
2250
2251            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2252            // are envelope_size bytes.
2253            let cur_offset: usize = (5 - 1) * envelope_size;
2254
2255            // Zero reserved fields.
2256            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2257
2258            // Safety:
2259            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2260            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2261            //   envelope_size bytes, there is always sufficient room.
2262            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance>, D>(
2263            self.instances.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance> as fidl::encoding::ValueTypeMarker>::borrow),
2264            encoder, offset + cur_offset, depth
2265        )?;
2266
2267            _prev_end_offset = cur_offset + envelope_size;
2268
2269            Ok(())
2270        }
2271    }
2272
2273    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AnonymizedAggregate {
2274        #[inline(always)]
2275        fn new_empty() -> Self {
2276            Self::default()
2277        }
2278
2279        unsafe fn decode(
2280            &mut self,
2281            decoder: &mut fidl::encoding::Decoder<'_, D>,
2282            offset: usize,
2283            mut depth: fidl::encoding::Depth,
2284        ) -> fidl::Result<()> {
2285            decoder.debug_check_bounds::<Self>(offset);
2286            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2287                None => return Err(fidl::Error::NotNullable),
2288                Some(len) => len,
2289            };
2290            // Calling decoder.out_of_line_offset(0) is not allowed.
2291            if len == 0 {
2292                return Ok(());
2293            };
2294            depth.increment()?;
2295            let envelope_size = 8;
2296            let bytes_len = len * envelope_size;
2297            let offset = decoder.out_of_line_offset(bytes_len)?;
2298            // Decode the envelope for each type.
2299            let mut _next_ordinal_to_read = 0;
2300            let mut next_offset = offset;
2301            let end_offset = offset + bytes_len;
2302            _next_ordinal_to_read += 1;
2303            if next_offset >= end_offset {
2304                return Ok(());
2305            }
2306
2307            // Decode unknown envelopes for gaps in ordinals.
2308            while _next_ordinal_to_read < 1 {
2309                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2310                _next_ordinal_to_read += 1;
2311                next_offset += envelope_size;
2312            }
2313
2314            let next_out_of_line = decoder.next_out_of_line();
2315            let handles_before = decoder.remaining_handles();
2316            if let Some((inlined, num_bytes, num_handles)) =
2317                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2318            {
2319                let member_inline_size =
2320                    <AggregateCapability as fidl::encoding::TypeMarker>::inline_size(
2321                        decoder.context,
2322                    );
2323                if inlined != (member_inline_size <= 4) {
2324                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2325                }
2326                let inner_offset;
2327                let mut inner_depth = depth.clone();
2328                if inlined {
2329                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2330                    inner_offset = next_offset;
2331                } else {
2332                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2333                    inner_depth.increment()?;
2334                }
2335                let val_ref =
2336                    self.capability.get_or_insert_with(|| fidl::new_empty!(AggregateCapability, D));
2337                fidl::decode!(AggregateCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
2338                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2339                {
2340                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2341                }
2342                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2343                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2344                }
2345            }
2346
2347            next_offset += envelope_size;
2348            _next_ordinal_to_read += 1;
2349            if next_offset >= end_offset {
2350                return Ok(());
2351            }
2352
2353            // Decode unknown envelopes for gaps in ordinals.
2354            while _next_ordinal_to_read < 2 {
2355                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2356                _next_ordinal_to_read += 1;
2357                next_offset += envelope_size;
2358            }
2359
2360            let next_out_of_line = decoder.next_out_of_line();
2361            let handles_before = decoder.remaining_handles();
2362            if let Some((inlined, num_bytes, num_handles)) =
2363                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2364            {
2365                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2366                if inlined != (member_inline_size <= 4) {
2367                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2368                }
2369                let inner_offset;
2370                let mut inner_depth = depth.clone();
2371                if inlined {
2372                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2373                    inner_offset = next_offset;
2374                } else {
2375                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2376                    inner_depth.increment()?;
2377                }
2378                let val_ref = self.moniker.get_or_insert_with(|| {
2379                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
2380                });
2381                fidl::decode!(
2382                    fidl::encoding::BoundedString<4096>,
2383                    D,
2384                    val_ref,
2385                    decoder,
2386                    inner_offset,
2387                    inner_depth
2388                )?;
2389                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2390                {
2391                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2392                }
2393                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2394                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2395                }
2396            }
2397
2398            next_offset += envelope_size;
2399            _next_ordinal_to_read += 1;
2400            if next_offset >= end_offset {
2401                return Ok(());
2402            }
2403
2404            // Decode unknown envelopes for gaps in ordinals.
2405            while _next_ordinal_to_read < 3 {
2406                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2407                _next_ordinal_to_read += 1;
2408                next_offset += envelope_size;
2409            }
2410
2411            let next_out_of_line = decoder.next_out_of_line();
2412            let handles_before = decoder.remaining_handles();
2413            if let Some((inlined, num_bytes, num_handles)) =
2414                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2415            {
2416                let member_inline_size = <fidl::encoding::UnboundedVector<AggregateMember> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2417                if inlined != (member_inline_size <= 4) {
2418                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2419                }
2420                let inner_offset;
2421                let mut inner_depth = depth.clone();
2422                if inlined {
2423                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2424                    inner_offset = next_offset;
2425                } else {
2426                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2427                    inner_depth.increment()?;
2428                }
2429                let val_ref = self.members.get_or_insert_with(|| {
2430                    fidl::new_empty!(fidl::encoding::UnboundedVector<AggregateMember>, D)
2431                });
2432                fidl::decode!(
2433                    fidl::encoding::UnboundedVector<AggregateMember>,
2434                    D,
2435                    val_ref,
2436                    decoder,
2437                    inner_offset,
2438                    inner_depth
2439                )?;
2440                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2441                {
2442                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2443                }
2444                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2445                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2446                }
2447            }
2448
2449            next_offset += envelope_size;
2450            _next_ordinal_to_read += 1;
2451            if next_offset >= end_offset {
2452                return Ok(());
2453            }
2454
2455            // Decode unknown envelopes for gaps in ordinals.
2456            while _next_ordinal_to_read < 5 {
2457                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2458                _next_ordinal_to_read += 1;
2459                next_offset += envelope_size;
2460            }
2461
2462            let next_out_of_line = decoder.next_out_of_line();
2463            let handles_before = decoder.remaining_handles();
2464            if let Some((inlined, num_bytes, num_handles)) =
2465                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2466            {
2467                let member_inline_size = <fidl::encoding::UnboundedVector<
2468                    fidl_fuchsia_sys2__common::ServiceInstance,
2469                > as fidl::encoding::TypeMarker>::inline_size(
2470                    decoder.context
2471                );
2472                if inlined != (member_inline_size <= 4) {
2473                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2474                }
2475                let inner_offset;
2476                let mut inner_depth = depth.clone();
2477                if inlined {
2478                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2479                    inner_offset = next_offset;
2480                } else {
2481                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2482                    inner_depth.increment()?;
2483                }
2484                let val_ref = self.instances.get_or_insert_with(|| {
2485                    fidl::new_empty!(
2486                        fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance>,
2487                        D
2488                    )
2489                });
2490                fidl::decode!(
2491                    fidl::encoding::UnboundedVector<fidl_fuchsia_sys2__common::ServiceInstance>,
2492                    D,
2493                    val_ref,
2494                    decoder,
2495                    inner_offset,
2496                    inner_depth
2497                )?;
2498                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2499                {
2500                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2501                }
2502                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2503                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2504                }
2505            }
2506
2507            next_offset += envelope_size;
2508
2509            // Decode the remaining unknown envelopes.
2510            while next_offset < end_offset {
2511                _next_ordinal_to_read += 1;
2512                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2513                next_offset += envelope_size;
2514            }
2515
2516            Ok(())
2517        }
2518    }
2519
2520    impl Builtin {
2521        #[inline(always)]
2522        fn max_ordinal_present(&self) -> u64 {
2523            if let Some(_) = self.capability {
2524                return 1;
2525            }
2526            0
2527        }
2528    }
2529
2530    impl fidl::encoding::ValueTypeMarker for Builtin {
2531        type Borrowed<'a> = &'a Self;
2532        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2533            value
2534        }
2535    }
2536
2537    unsafe impl fidl::encoding::TypeMarker for Builtin {
2538        type Owned = Self;
2539
2540        #[inline(always)]
2541        fn inline_align(_context: fidl::encoding::Context) -> usize {
2542            8
2543        }
2544
2545        #[inline(always)]
2546        fn inline_size(_context: fidl::encoding::Context) -> usize {
2547            16
2548        }
2549    }
2550
2551    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Builtin, D> for &Builtin {
2552        unsafe fn encode(
2553            self,
2554            encoder: &mut fidl::encoding::Encoder<'_, D>,
2555            offset: usize,
2556            mut depth: fidl::encoding::Depth,
2557        ) -> fidl::Result<()> {
2558            encoder.debug_check_bounds::<Builtin>(offset);
2559            // Vector header
2560            let max_ordinal: u64 = self.max_ordinal_present();
2561            encoder.write_num(max_ordinal, offset);
2562            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2563            // Calling encoder.out_of_line_offset(0) is not allowed.
2564            if max_ordinal == 0 {
2565                return Ok(());
2566            }
2567            depth.increment()?;
2568            let envelope_size = 8;
2569            let bytes_len = max_ordinal as usize * envelope_size;
2570            #[allow(unused_variables)]
2571            let offset = encoder.out_of_line_offset(bytes_len);
2572            let mut _prev_end_offset: usize = 0;
2573            if 1 > max_ordinal {
2574                return Ok(());
2575            }
2576
2577            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2578            // are envelope_size bytes.
2579            let cur_offset: usize = (1 - 1) * envelope_size;
2580
2581            // Zero reserved fields.
2582            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2583
2584            // Safety:
2585            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2586            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2587            //   envelope_size bytes, there is always sufficient room.
2588            fidl::encoding::encode_in_envelope_optional::<InternalCapability, D>(
2589                self.capability
2590                    .as_ref()
2591                    .map(<InternalCapability as fidl::encoding::ValueTypeMarker>::borrow),
2592                encoder,
2593                offset + cur_offset,
2594                depth,
2595            )?;
2596
2597            _prev_end_offset = cur_offset + envelope_size;
2598
2599            Ok(())
2600        }
2601    }
2602
2603    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Builtin {
2604        #[inline(always)]
2605        fn new_empty() -> Self {
2606            Self::default()
2607        }
2608
2609        unsafe fn decode(
2610            &mut self,
2611            decoder: &mut fidl::encoding::Decoder<'_, D>,
2612            offset: usize,
2613            mut depth: fidl::encoding::Depth,
2614        ) -> fidl::Result<()> {
2615            decoder.debug_check_bounds::<Self>(offset);
2616            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2617                None => return Err(fidl::Error::NotNullable),
2618                Some(len) => len,
2619            };
2620            // Calling decoder.out_of_line_offset(0) is not allowed.
2621            if len == 0 {
2622                return Ok(());
2623            };
2624            depth.increment()?;
2625            let envelope_size = 8;
2626            let bytes_len = len * envelope_size;
2627            let offset = decoder.out_of_line_offset(bytes_len)?;
2628            // Decode the envelope for each type.
2629            let mut _next_ordinal_to_read = 0;
2630            let mut next_offset = offset;
2631            let end_offset = offset + bytes_len;
2632            _next_ordinal_to_read += 1;
2633            if next_offset >= end_offset {
2634                return Ok(());
2635            }
2636
2637            // Decode unknown envelopes for gaps in ordinals.
2638            while _next_ordinal_to_read < 1 {
2639                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2640                _next_ordinal_to_read += 1;
2641                next_offset += envelope_size;
2642            }
2643
2644            let next_out_of_line = decoder.next_out_of_line();
2645            let handles_before = decoder.remaining_handles();
2646            if let Some((inlined, num_bytes, num_handles)) =
2647                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2648            {
2649                let member_inline_size =
2650                    <InternalCapability as fidl::encoding::TypeMarker>::inline_size(
2651                        decoder.context,
2652                    );
2653                if inlined != (member_inline_size <= 4) {
2654                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2655                }
2656                let inner_offset;
2657                let mut inner_depth = depth.clone();
2658                if inlined {
2659                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2660                    inner_offset = next_offset;
2661                } else {
2662                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2663                    inner_depth.increment()?;
2664                }
2665                let val_ref =
2666                    self.capability.get_or_insert_with(|| fidl::new_empty!(InternalCapability, D));
2667                fidl::decode!(InternalCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
2668                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2669                {
2670                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2671                }
2672                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2673                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2674                }
2675            }
2676
2677            next_offset += envelope_size;
2678
2679            // Decode the remaining unknown envelopes.
2680            while next_offset < end_offset {
2681                _next_ordinal_to_read += 1;
2682                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2683                next_offset += envelope_size;
2684            }
2685
2686            Ok(())
2687        }
2688    }
2689
2690    impl Capability {
2691        #[inline(always)]
2692        fn max_ordinal_present(&self) -> u64 {
2693            if let Some(_) = self.moniker {
2694                return 2;
2695            }
2696            if let Some(_) = self.source_capability {
2697                return 1;
2698            }
2699            0
2700        }
2701    }
2702
2703    impl fidl::encoding::ValueTypeMarker for Capability {
2704        type Borrowed<'a> = &'a Self;
2705        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2706            value
2707        }
2708    }
2709
2710    unsafe impl fidl::encoding::TypeMarker for Capability {
2711        type Owned = Self;
2712
2713        #[inline(always)]
2714        fn inline_align(_context: fidl::encoding::Context) -> usize {
2715            8
2716        }
2717
2718        #[inline(always)]
2719        fn inline_size(_context: fidl::encoding::Context) -> usize {
2720            16
2721        }
2722    }
2723
2724    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Capability, D>
2725        for &Capability
2726    {
2727        unsafe fn encode(
2728            self,
2729            encoder: &mut fidl::encoding::Encoder<'_, D>,
2730            offset: usize,
2731            mut depth: fidl::encoding::Depth,
2732        ) -> fidl::Result<()> {
2733            encoder.debug_check_bounds::<Capability>(offset);
2734            // Vector header
2735            let max_ordinal: u64 = self.max_ordinal_present();
2736            encoder.write_num(max_ordinal, offset);
2737            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2738            // Calling encoder.out_of_line_offset(0) is not allowed.
2739            if max_ordinal == 0 {
2740                return Ok(());
2741            }
2742            depth.increment()?;
2743            let envelope_size = 8;
2744            let bytes_len = max_ordinal as usize * envelope_size;
2745            #[allow(unused_variables)]
2746            let offset = encoder.out_of_line_offset(bytes_len);
2747            let mut _prev_end_offset: usize = 0;
2748            if 1 > max_ordinal {
2749                return Ok(());
2750            }
2751
2752            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2753            // are envelope_size bytes.
2754            let cur_offset: usize = (1 - 1) * envelope_size;
2755
2756            // Zero reserved fields.
2757            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2758
2759            // Safety:
2760            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2761            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2762            //   envelope_size bytes, there is always sufficient room.
2763            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
2764                self.source_capability
2765                    .as_ref()
2766                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
2767                encoder,
2768                offset + cur_offset,
2769                depth,
2770            )?;
2771
2772            _prev_end_offset = cur_offset + envelope_size;
2773            if 2 > max_ordinal {
2774                return Ok(());
2775            }
2776
2777            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2778            // are envelope_size bytes.
2779            let cur_offset: usize = (2 - 1) * envelope_size;
2780
2781            // Zero reserved fields.
2782            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2783
2784            // Safety:
2785            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2786            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2787            //   envelope_size bytes, there is always sufficient room.
2788            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
2789            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
2790            encoder, offset + cur_offset, depth
2791        )?;
2792
2793            _prev_end_offset = cur_offset + envelope_size;
2794
2795            Ok(())
2796        }
2797    }
2798
2799    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Capability {
2800        #[inline(always)]
2801        fn new_empty() -> Self {
2802            Self::default()
2803        }
2804
2805        unsafe fn decode(
2806            &mut self,
2807            decoder: &mut fidl::encoding::Decoder<'_, D>,
2808            offset: usize,
2809            mut depth: fidl::encoding::Depth,
2810        ) -> fidl::Result<()> {
2811            decoder.debug_check_bounds::<Self>(offset);
2812            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2813                None => return Err(fidl::Error::NotNullable),
2814                Some(len) => len,
2815            };
2816            // Calling decoder.out_of_line_offset(0) is not allowed.
2817            if len == 0 {
2818                return Ok(());
2819            };
2820            depth.increment()?;
2821            let envelope_size = 8;
2822            let bytes_len = len * envelope_size;
2823            let offset = decoder.out_of_line_offset(bytes_len)?;
2824            // Decode the envelope for each type.
2825            let mut _next_ordinal_to_read = 0;
2826            let mut next_offset = offset;
2827            let end_offset = offset + bytes_len;
2828            _next_ordinal_to_read += 1;
2829            if next_offset >= end_offset {
2830                return Ok(());
2831            }
2832
2833            // Decode unknown envelopes for gaps in ordinals.
2834            while _next_ordinal_to_read < 1 {
2835                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2836                _next_ordinal_to_read += 1;
2837                next_offset += envelope_size;
2838            }
2839
2840            let next_out_of_line = decoder.next_out_of_line();
2841            let handles_before = decoder.remaining_handles();
2842            if let Some((inlined, num_bytes, num_handles)) =
2843                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2844            {
2845                let member_inline_size =
2846                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
2847                        decoder.context,
2848                    );
2849                if inlined != (member_inline_size <= 4) {
2850                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2851                }
2852                let inner_offset;
2853                let mut inner_depth = depth.clone();
2854                if inlined {
2855                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2856                    inner_offset = next_offset;
2857                } else {
2858                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2859                    inner_depth.increment()?;
2860                }
2861                let val_ref = self
2862                    .source_capability
2863                    .get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
2864                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
2865                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2866                {
2867                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2868                }
2869                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2870                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2871                }
2872            }
2873
2874            next_offset += envelope_size;
2875            _next_ordinal_to_read += 1;
2876            if next_offset >= end_offset {
2877                return Ok(());
2878            }
2879
2880            // Decode unknown envelopes for gaps in ordinals.
2881            while _next_ordinal_to_read < 2 {
2882                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2883                _next_ordinal_to_read += 1;
2884                next_offset += envelope_size;
2885            }
2886
2887            let next_out_of_line = decoder.next_out_of_line();
2888            let handles_before = decoder.remaining_handles();
2889            if let Some((inlined, num_bytes, num_handles)) =
2890                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2891            {
2892                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2893                if inlined != (member_inline_size <= 4) {
2894                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2895                }
2896                let inner_offset;
2897                let mut inner_depth = depth.clone();
2898                if inlined {
2899                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2900                    inner_offset = next_offset;
2901                } else {
2902                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2903                    inner_depth.increment()?;
2904                }
2905                let val_ref = self.moniker.get_or_insert_with(|| {
2906                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
2907                });
2908                fidl::decode!(
2909                    fidl::encoding::BoundedString<4096>,
2910                    D,
2911                    val_ref,
2912                    decoder,
2913                    inner_offset,
2914                    inner_depth
2915                )?;
2916                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2917                {
2918                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2919                }
2920                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2921                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2922                }
2923            }
2924
2925            next_offset += envelope_size;
2926
2927            // Decode the remaining unknown envelopes.
2928            while next_offset < end_offset {
2929                _next_ordinal_to_read += 1;
2930                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2931                next_offset += envelope_size;
2932            }
2933
2934            Ok(())
2935        }
2936    }
2937
2938    impl CapabilityAllowlistEntry {
2939        #[inline(always)]
2940        fn max_ordinal_present(&self) -> u64 {
2941            if let Some(_) = self.source {
2942                return 5;
2943            }
2944            if let Some(_) = self.target_monikers {
2945                return 4;
2946            }
2947            if let Some(_) = self.capability {
2948                return 3;
2949            }
2950            if let Some(_) = self.source_name {
2951                return 2;
2952            }
2953            if let Some(_) = self.source_moniker {
2954                return 1;
2955            }
2956            0
2957        }
2958    }
2959
2960    impl fidl::encoding::ValueTypeMarker for CapabilityAllowlistEntry {
2961        type Borrowed<'a> = &'a Self;
2962        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2963            value
2964        }
2965    }
2966
2967    unsafe impl fidl::encoding::TypeMarker for CapabilityAllowlistEntry {
2968        type Owned = Self;
2969
2970        #[inline(always)]
2971        fn inline_align(_context: fidl::encoding::Context) -> usize {
2972            8
2973        }
2974
2975        #[inline(always)]
2976        fn inline_size(_context: fidl::encoding::Context) -> usize {
2977            16
2978        }
2979    }
2980
2981    unsafe impl<D: fidl::encoding::ResourceDialect>
2982        fidl::encoding::Encode<CapabilityAllowlistEntry, D> for &CapabilityAllowlistEntry
2983    {
2984        unsafe fn encode(
2985            self,
2986            encoder: &mut fidl::encoding::Encoder<'_, D>,
2987            offset: usize,
2988            mut depth: fidl::encoding::Depth,
2989        ) -> fidl::Result<()> {
2990            encoder.debug_check_bounds::<CapabilityAllowlistEntry>(offset);
2991            // Vector header
2992            let max_ordinal: u64 = self.max_ordinal_present();
2993            encoder.write_num(max_ordinal, offset);
2994            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2995            // Calling encoder.out_of_line_offset(0) is not allowed.
2996            if max_ordinal == 0 {
2997                return Ok(());
2998            }
2999            depth.increment()?;
3000            let envelope_size = 8;
3001            let bytes_len = max_ordinal as usize * envelope_size;
3002            #[allow(unused_variables)]
3003            let offset = encoder.out_of_line_offset(bytes_len);
3004            let mut _prev_end_offset: usize = 0;
3005            if 1 > max_ordinal {
3006                return Ok(());
3007            }
3008
3009            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3010            // are envelope_size bytes.
3011            let cur_offset: usize = (1 - 1) * envelope_size;
3012
3013            // Zero reserved fields.
3014            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3015
3016            // Safety:
3017            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3018            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3019            //   envelope_size bytes, there is always sufficient room.
3020            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
3021            self.source_moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
3022            encoder, offset + cur_offset, depth
3023        )?;
3024
3025            _prev_end_offset = cur_offset + envelope_size;
3026            if 2 > max_ordinal {
3027                return Ok(());
3028            }
3029
3030            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3031            // are envelope_size bytes.
3032            let cur_offset: usize = (2 - 1) * envelope_size;
3033
3034            // Zero reserved fields.
3035            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3036
3037            // Safety:
3038            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3039            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3040            //   envelope_size bytes, there is always sufficient room.
3041            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
3042                self.source_name.as_ref().map(
3043                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
3044                ),
3045                encoder,
3046                offset + cur_offset,
3047                depth,
3048            )?;
3049
3050            _prev_end_offset = cur_offset + envelope_size;
3051            if 3 > max_ordinal {
3052                return Ok(());
3053            }
3054
3055            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3056            // are envelope_size bytes.
3057            let cur_offset: usize = (3 - 1) * envelope_size;
3058
3059            // Zero reserved fields.
3060            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3061
3062            // Safety:
3063            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3064            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3065            //   envelope_size bytes, there is always sufficient room.
3066            fidl::encoding::encode_in_envelope_optional::<AllowlistedCapability, D>(
3067                self.capability
3068                    .as_ref()
3069                    .map(<AllowlistedCapability as fidl::encoding::ValueTypeMarker>::borrow),
3070                encoder,
3071                offset + cur_offset,
3072                depth,
3073            )?;
3074
3075            _prev_end_offset = cur_offset + envelope_size;
3076            if 4 > max_ordinal {
3077                return Ok(());
3078            }
3079
3080            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3081            // are envelope_size bytes.
3082            let cur_offset: usize = (4 - 1) * envelope_size;
3083
3084            // Zero reserved fields.
3085            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3086
3087            // Safety:
3088            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3089            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3090            //   envelope_size bytes, there is always sufficient room.
3091            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
3092            self.target_monikers.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
3093            encoder, offset + cur_offset, depth
3094        )?;
3095
3096            _prev_end_offset = cur_offset + envelope_size;
3097            if 5 > max_ordinal {
3098                return Ok(());
3099            }
3100
3101            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3102            // are envelope_size bytes.
3103            let cur_offset: usize = (5 - 1) * envelope_size;
3104
3105            // Zero reserved fields.
3106            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3107
3108            // Safety:
3109            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3110            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3111            //   envelope_size bytes, there is always sufficient room.
3112            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Ref, D>(
3113            self.source.as_ref().map(<fidl_fuchsia_component_decl__common::Ref as fidl::encoding::ValueTypeMarker>::borrow),
3114            encoder, offset + cur_offset, depth
3115        )?;
3116
3117            _prev_end_offset = cur_offset + envelope_size;
3118
3119            Ok(())
3120        }
3121    }
3122
3123    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3124        for CapabilityAllowlistEntry
3125    {
3126        #[inline(always)]
3127        fn new_empty() -> Self {
3128            Self::default()
3129        }
3130
3131        unsafe fn decode(
3132            &mut self,
3133            decoder: &mut fidl::encoding::Decoder<'_, D>,
3134            offset: usize,
3135            mut depth: fidl::encoding::Depth,
3136        ) -> fidl::Result<()> {
3137            decoder.debug_check_bounds::<Self>(offset);
3138            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3139                None => return Err(fidl::Error::NotNullable),
3140                Some(len) => len,
3141            };
3142            // Calling decoder.out_of_line_offset(0) is not allowed.
3143            if len == 0 {
3144                return Ok(());
3145            };
3146            depth.increment()?;
3147            let envelope_size = 8;
3148            let bytes_len = len * envelope_size;
3149            let offset = decoder.out_of_line_offset(bytes_len)?;
3150            // Decode the envelope for each type.
3151            let mut _next_ordinal_to_read = 0;
3152            let mut next_offset = offset;
3153            let end_offset = offset + bytes_len;
3154            _next_ordinal_to_read += 1;
3155            if next_offset >= end_offset {
3156                return Ok(());
3157            }
3158
3159            // Decode unknown envelopes for gaps in ordinals.
3160            while _next_ordinal_to_read < 1 {
3161                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3162                _next_ordinal_to_read += 1;
3163                next_offset += envelope_size;
3164            }
3165
3166            let next_out_of_line = decoder.next_out_of_line();
3167            let handles_before = decoder.remaining_handles();
3168            if let Some((inlined, num_bytes, num_handles)) =
3169                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3170            {
3171                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3172                if inlined != (member_inline_size <= 4) {
3173                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3174                }
3175                let inner_offset;
3176                let mut inner_depth = depth.clone();
3177                if inlined {
3178                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3179                    inner_offset = next_offset;
3180                } else {
3181                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3182                    inner_depth.increment()?;
3183                }
3184                let val_ref = self.source_moniker.get_or_insert_with(|| {
3185                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
3186                });
3187                fidl::decode!(
3188                    fidl::encoding::BoundedString<4096>,
3189                    D,
3190                    val_ref,
3191                    decoder,
3192                    inner_offset,
3193                    inner_depth
3194                )?;
3195                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3196                {
3197                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3198                }
3199                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3200                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3201                }
3202            }
3203
3204            next_offset += envelope_size;
3205            _next_ordinal_to_read += 1;
3206            if next_offset >= end_offset {
3207                return Ok(());
3208            }
3209
3210            // Decode unknown envelopes for gaps in ordinals.
3211            while _next_ordinal_to_read < 2 {
3212                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3213                _next_ordinal_to_read += 1;
3214                next_offset += envelope_size;
3215            }
3216
3217            let next_out_of_line = decoder.next_out_of_line();
3218            let handles_before = decoder.remaining_handles();
3219            if let Some((inlined, num_bytes, num_handles)) =
3220                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3221            {
3222                let member_inline_size =
3223                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
3224                        decoder.context,
3225                    );
3226                if inlined != (member_inline_size <= 4) {
3227                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3228                }
3229                let inner_offset;
3230                let mut inner_depth = depth.clone();
3231                if inlined {
3232                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3233                    inner_offset = next_offset;
3234                } else {
3235                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3236                    inner_depth.increment()?;
3237                }
3238                let val_ref = self
3239                    .source_name
3240                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
3241                fidl::decode!(
3242                    fidl::encoding::BoundedString<255>,
3243                    D,
3244                    val_ref,
3245                    decoder,
3246                    inner_offset,
3247                    inner_depth
3248                )?;
3249                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3250                {
3251                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3252                }
3253                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3254                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3255                }
3256            }
3257
3258            next_offset += envelope_size;
3259            _next_ordinal_to_read += 1;
3260            if next_offset >= end_offset {
3261                return Ok(());
3262            }
3263
3264            // Decode unknown envelopes for gaps in ordinals.
3265            while _next_ordinal_to_read < 3 {
3266                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3267                _next_ordinal_to_read += 1;
3268                next_offset += envelope_size;
3269            }
3270
3271            let next_out_of_line = decoder.next_out_of_line();
3272            let handles_before = decoder.remaining_handles();
3273            if let Some((inlined, num_bytes, num_handles)) =
3274                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3275            {
3276                let member_inline_size =
3277                    <AllowlistedCapability as fidl::encoding::TypeMarker>::inline_size(
3278                        decoder.context,
3279                    );
3280                if inlined != (member_inline_size <= 4) {
3281                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3282                }
3283                let inner_offset;
3284                let mut inner_depth = depth.clone();
3285                if inlined {
3286                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3287                    inner_offset = next_offset;
3288                } else {
3289                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3290                    inner_depth.increment()?;
3291                }
3292                let val_ref = self
3293                    .capability
3294                    .get_or_insert_with(|| fidl::new_empty!(AllowlistedCapability, D));
3295                fidl::decode!(
3296                    AllowlistedCapability,
3297                    D,
3298                    val_ref,
3299                    decoder,
3300                    inner_offset,
3301                    inner_depth
3302                )?;
3303                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3304                {
3305                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3306                }
3307                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3308                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3309                }
3310            }
3311
3312            next_offset += envelope_size;
3313            _next_ordinal_to_read += 1;
3314            if next_offset >= end_offset {
3315                return Ok(());
3316            }
3317
3318            // Decode unknown envelopes for gaps in ordinals.
3319            while _next_ordinal_to_read < 4 {
3320                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3321                _next_ordinal_to_read += 1;
3322                next_offset += envelope_size;
3323            }
3324
3325            let next_out_of_line = decoder.next_out_of_line();
3326            let handles_before = decoder.remaining_handles();
3327            if let Some((inlined, num_bytes, num_handles)) =
3328                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3329            {
3330                let member_inline_size = <fidl::encoding::Vector<
3331                    fidl::encoding::BoundedString<4096>,
3332                    128,
3333                > as fidl::encoding::TypeMarker>::inline_size(
3334                    decoder.context
3335                );
3336                if inlined != (member_inline_size <= 4) {
3337                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3338                }
3339                let inner_offset;
3340                let mut inner_depth = depth.clone();
3341                if inlined {
3342                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3343                    inner_offset = next_offset;
3344                } else {
3345                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3346                    inner_depth.increment()?;
3347                }
3348                let val_ref = self.target_monikers.get_or_insert_with(|| {
3349                    fidl::new_empty!(
3350                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3351                        D
3352                    )
3353                });
3354                fidl::decode!(
3355                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3356                    D,
3357                    val_ref,
3358                    decoder,
3359                    inner_offset,
3360                    inner_depth
3361                )?;
3362                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3363                {
3364                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3365                }
3366                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3367                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3368                }
3369            }
3370
3371            next_offset += envelope_size;
3372            _next_ordinal_to_read += 1;
3373            if next_offset >= end_offset {
3374                return Ok(());
3375            }
3376
3377            // Decode unknown envelopes for gaps in ordinals.
3378            while _next_ordinal_to_read < 5 {
3379                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3380                _next_ordinal_to_read += 1;
3381                next_offset += envelope_size;
3382            }
3383
3384            let next_out_of_line = decoder.next_out_of_line();
3385            let handles_before = decoder.remaining_handles();
3386            if let Some((inlined, num_bytes, num_handles)) =
3387                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3388            {
3389                let member_inline_size = <fidl_fuchsia_component_decl__common::Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3390                if inlined != (member_inline_size <= 4) {
3391                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3392                }
3393                let inner_offset;
3394                let mut inner_depth = depth.clone();
3395                if inlined {
3396                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3397                    inner_offset = next_offset;
3398                } else {
3399                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3400                    inner_depth.increment()?;
3401                }
3402                let val_ref = self.source.get_or_insert_with(|| {
3403                    fidl::new_empty!(fidl_fuchsia_component_decl__common::Ref, D)
3404                });
3405                fidl::decode!(
3406                    fidl_fuchsia_component_decl__common::Ref,
3407                    D,
3408                    val_ref,
3409                    decoder,
3410                    inner_offset,
3411                    inner_depth
3412                )?;
3413                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3414                {
3415                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3416                }
3417                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3418                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3419                }
3420            }
3421
3422            next_offset += envelope_size;
3423
3424            // Decode the remaining unknown envelopes.
3425            while next_offset < end_offset {
3426                _next_ordinal_to_read += 1;
3427                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3428                next_offset += envelope_size;
3429            }
3430
3431            Ok(())
3432        }
3433    }
3434
3435    impl CapabilityPolicyAllowlists {
3436        #[inline(always)]
3437        fn max_ordinal_present(&self) -> u64 {
3438            if let Some(_) = self.allowlist {
3439                return 1;
3440            }
3441            0
3442        }
3443    }
3444
3445    impl fidl::encoding::ValueTypeMarker for CapabilityPolicyAllowlists {
3446        type Borrowed<'a> = &'a Self;
3447        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3448            value
3449        }
3450    }
3451
3452    unsafe impl fidl::encoding::TypeMarker for CapabilityPolicyAllowlists {
3453        type Owned = Self;
3454
3455        #[inline(always)]
3456        fn inline_align(_context: fidl::encoding::Context) -> usize {
3457            8
3458        }
3459
3460        #[inline(always)]
3461        fn inline_size(_context: fidl::encoding::Context) -> usize {
3462            16
3463        }
3464    }
3465
3466    unsafe impl<D: fidl::encoding::ResourceDialect>
3467        fidl::encoding::Encode<CapabilityPolicyAllowlists, D> for &CapabilityPolicyAllowlists
3468    {
3469        unsafe fn encode(
3470            self,
3471            encoder: &mut fidl::encoding::Encoder<'_, D>,
3472            offset: usize,
3473            mut depth: fidl::encoding::Depth,
3474        ) -> fidl::Result<()> {
3475            encoder.debug_check_bounds::<CapabilityPolicyAllowlists>(offset);
3476            // Vector header
3477            let max_ordinal: u64 = self.max_ordinal_present();
3478            encoder.write_num(max_ordinal, offset);
3479            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3480            // Calling encoder.out_of_line_offset(0) is not allowed.
3481            if max_ordinal == 0 {
3482                return Ok(());
3483            }
3484            depth.increment()?;
3485            let envelope_size = 8;
3486            let bytes_len = max_ordinal as usize * envelope_size;
3487            #[allow(unused_variables)]
3488            let offset = encoder.out_of_line_offset(bytes_len);
3489            let mut _prev_end_offset: usize = 0;
3490            if 1 > max_ordinal {
3491                return Ok(());
3492            }
3493
3494            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3495            // are envelope_size bytes.
3496            let cur_offset: usize = (1 - 1) * envelope_size;
3497
3498            // Zero reserved fields.
3499            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3500
3501            // Safety:
3502            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3503            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3504            //   envelope_size bytes, there is always sufficient room.
3505            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CapabilityAllowlistEntry, 128>, D>(
3506            self.allowlist.as_ref().map(<fidl::encoding::Vector<CapabilityAllowlistEntry, 128> as fidl::encoding::ValueTypeMarker>::borrow),
3507            encoder, offset + cur_offset, depth
3508        )?;
3509
3510            _prev_end_offset = cur_offset + envelope_size;
3511
3512            Ok(())
3513        }
3514    }
3515
3516    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3517        for CapabilityPolicyAllowlists
3518    {
3519        #[inline(always)]
3520        fn new_empty() -> Self {
3521            Self::default()
3522        }
3523
3524        unsafe fn decode(
3525            &mut self,
3526            decoder: &mut fidl::encoding::Decoder<'_, D>,
3527            offset: usize,
3528            mut depth: fidl::encoding::Depth,
3529        ) -> fidl::Result<()> {
3530            decoder.debug_check_bounds::<Self>(offset);
3531            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3532                None => return Err(fidl::Error::NotNullable),
3533                Some(len) => len,
3534            };
3535            // Calling decoder.out_of_line_offset(0) is not allowed.
3536            if len == 0 {
3537                return Ok(());
3538            };
3539            depth.increment()?;
3540            let envelope_size = 8;
3541            let bytes_len = len * envelope_size;
3542            let offset = decoder.out_of_line_offset(bytes_len)?;
3543            // Decode the envelope for each type.
3544            let mut _next_ordinal_to_read = 0;
3545            let mut next_offset = offset;
3546            let end_offset = offset + bytes_len;
3547            _next_ordinal_to_read += 1;
3548            if next_offset >= end_offset {
3549                return Ok(());
3550            }
3551
3552            // Decode unknown envelopes for gaps in ordinals.
3553            while _next_ordinal_to_read < 1 {
3554                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3555                _next_ordinal_to_read += 1;
3556                next_offset += envelope_size;
3557            }
3558
3559            let next_out_of_line = decoder.next_out_of_line();
3560            let handles_before = decoder.remaining_handles();
3561            if let Some((inlined, num_bytes, num_handles)) =
3562                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3563            {
3564                let member_inline_size = <fidl::encoding::Vector<CapabilityAllowlistEntry, 128> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3565                if inlined != (member_inline_size <= 4) {
3566                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3567                }
3568                let inner_offset;
3569                let mut inner_depth = depth.clone();
3570                if inlined {
3571                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3572                    inner_offset = next_offset;
3573                } else {
3574                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3575                    inner_depth.increment()?;
3576                }
3577                let val_ref = self.allowlist.get_or_insert_with(
3578                    || fidl::new_empty!(fidl::encoding::Vector<CapabilityAllowlistEntry, 128>, D),
3579                );
3580                fidl::decode!(fidl::encoding::Vector<CapabilityAllowlistEntry, 128>, D, val_ref, decoder, inner_offset, inner_depth)?;
3581                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3582                {
3583                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3584                }
3585                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3586                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3587                }
3588            }
3589
3590            next_offset += envelope_size;
3591
3592            // Decode the remaining unknown envelopes.
3593            while next_offset < end_offset {
3594                _next_ordinal_to_read += 1;
3595                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3596                next_offset += envelope_size;
3597            }
3598
3599            Ok(())
3600        }
3601    }
3602
3603    impl ChildPolicyAllowlists {
3604        #[inline(always)]
3605        fn max_ordinal_present(&self) -> u64 {
3606            if let Some(_) = self.reboot_on_terminate {
3607                return 1;
3608            }
3609            0
3610        }
3611    }
3612
3613    impl fidl::encoding::ValueTypeMarker for ChildPolicyAllowlists {
3614        type Borrowed<'a> = &'a Self;
3615        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3616            value
3617        }
3618    }
3619
3620    unsafe impl fidl::encoding::TypeMarker for ChildPolicyAllowlists {
3621        type Owned = Self;
3622
3623        #[inline(always)]
3624        fn inline_align(_context: fidl::encoding::Context) -> usize {
3625            8
3626        }
3627
3628        #[inline(always)]
3629        fn inline_size(_context: fidl::encoding::Context) -> usize {
3630            16
3631        }
3632    }
3633
3634    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChildPolicyAllowlists, D>
3635        for &ChildPolicyAllowlists
3636    {
3637        unsafe fn encode(
3638            self,
3639            encoder: &mut fidl::encoding::Encoder<'_, D>,
3640            offset: usize,
3641            mut depth: fidl::encoding::Depth,
3642        ) -> fidl::Result<()> {
3643            encoder.debug_check_bounds::<ChildPolicyAllowlists>(offset);
3644            // Vector header
3645            let max_ordinal: u64 = self.max_ordinal_present();
3646            encoder.write_num(max_ordinal, offset);
3647            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3648            // Calling encoder.out_of_line_offset(0) is not allowed.
3649            if max_ordinal == 0 {
3650                return Ok(());
3651            }
3652            depth.increment()?;
3653            let envelope_size = 8;
3654            let bytes_len = max_ordinal as usize * envelope_size;
3655            #[allow(unused_variables)]
3656            let offset = encoder.out_of_line_offset(bytes_len);
3657            let mut _prev_end_offset: usize = 0;
3658            if 1 > max_ordinal {
3659                return Ok(());
3660            }
3661
3662            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3663            // are envelope_size bytes.
3664            let cur_offset: usize = (1 - 1) * envelope_size;
3665
3666            // Zero reserved fields.
3667            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3668
3669            // Safety:
3670            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3671            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3672            //   envelope_size bytes, there is always sufficient room.
3673            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
3674            self.reboot_on_terminate.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
3675            encoder, offset + cur_offset, depth
3676        )?;
3677
3678            _prev_end_offset = cur_offset + envelope_size;
3679
3680            Ok(())
3681        }
3682    }
3683
3684    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChildPolicyAllowlists {
3685        #[inline(always)]
3686        fn new_empty() -> Self {
3687            Self::default()
3688        }
3689
3690        unsafe fn decode(
3691            &mut self,
3692            decoder: &mut fidl::encoding::Decoder<'_, D>,
3693            offset: usize,
3694            mut depth: fidl::encoding::Depth,
3695        ) -> fidl::Result<()> {
3696            decoder.debug_check_bounds::<Self>(offset);
3697            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3698                None => return Err(fidl::Error::NotNullable),
3699                Some(len) => len,
3700            };
3701            // Calling decoder.out_of_line_offset(0) is not allowed.
3702            if len == 0 {
3703                return Ok(());
3704            };
3705            depth.increment()?;
3706            let envelope_size = 8;
3707            let bytes_len = len * envelope_size;
3708            let offset = decoder.out_of_line_offset(bytes_len)?;
3709            // Decode the envelope for each type.
3710            let mut _next_ordinal_to_read = 0;
3711            let mut next_offset = offset;
3712            let end_offset = offset + bytes_len;
3713            _next_ordinal_to_read += 1;
3714            if next_offset >= end_offset {
3715                return Ok(());
3716            }
3717
3718            // Decode unknown envelopes for gaps in ordinals.
3719            while _next_ordinal_to_read < 1 {
3720                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3721                _next_ordinal_to_read += 1;
3722                next_offset += envelope_size;
3723            }
3724
3725            let next_out_of_line = decoder.next_out_of_line();
3726            let handles_before = decoder.remaining_handles();
3727            if let Some((inlined, num_bytes, num_handles)) =
3728                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3729            {
3730                let member_inline_size = <fidl::encoding::Vector<
3731                    fidl::encoding::BoundedString<4096>,
3732                    128,
3733                > as fidl::encoding::TypeMarker>::inline_size(
3734                    decoder.context
3735                );
3736                if inlined != (member_inline_size <= 4) {
3737                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3738                }
3739                let inner_offset;
3740                let mut inner_depth = depth.clone();
3741                if inlined {
3742                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3743                    inner_offset = next_offset;
3744                } else {
3745                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3746                    inner_depth.increment()?;
3747                }
3748                let val_ref = self.reboot_on_terminate.get_or_insert_with(|| {
3749                    fidl::new_empty!(
3750                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3751                        D
3752                    )
3753                });
3754                fidl::decode!(
3755                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
3756                    D,
3757                    val_ref,
3758                    decoder,
3759                    inner_offset,
3760                    inner_depth
3761                )?;
3762                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3763                {
3764                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3765                }
3766                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3767                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3768                }
3769            }
3770
3771            next_offset += envelope_size;
3772
3773            // Decode the remaining unknown envelopes.
3774            while next_offset < end_offset {
3775                _next_ordinal_to_read += 1;
3776                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3777                next_offset += envelope_size;
3778            }
3779
3780            Ok(())
3781        }
3782    }
3783
3784    impl Component {
3785        #[inline(always)]
3786        fn max_ordinal_present(&self) -> u64 {
3787            if let Some(_) = self.moniker {
3788                return 2;
3789            }
3790            if let Some(_) = self.capability {
3791                return 1;
3792            }
3793            0
3794        }
3795    }
3796
3797    impl fidl::encoding::ValueTypeMarker for Component {
3798        type Borrowed<'a> = &'a Self;
3799        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3800            value
3801        }
3802    }
3803
3804    unsafe impl fidl::encoding::TypeMarker for Component {
3805        type Owned = Self;
3806
3807        #[inline(always)]
3808        fn inline_align(_context: fidl::encoding::Context) -> usize {
3809            8
3810        }
3811
3812        #[inline(always)]
3813        fn inline_size(_context: fidl::encoding::Context) -> usize {
3814            16
3815        }
3816    }
3817
3818    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Component, D>
3819        for &Component
3820    {
3821        unsafe fn encode(
3822            self,
3823            encoder: &mut fidl::encoding::Encoder<'_, D>,
3824            offset: usize,
3825            mut depth: fidl::encoding::Depth,
3826        ) -> fidl::Result<()> {
3827            encoder.debug_check_bounds::<Component>(offset);
3828            // Vector header
3829            let max_ordinal: u64 = self.max_ordinal_present();
3830            encoder.write_num(max_ordinal, offset);
3831            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3832            // Calling encoder.out_of_line_offset(0) is not allowed.
3833            if max_ordinal == 0 {
3834                return Ok(());
3835            }
3836            depth.increment()?;
3837            let envelope_size = 8;
3838            let bytes_len = max_ordinal as usize * envelope_size;
3839            #[allow(unused_variables)]
3840            let offset = encoder.out_of_line_offset(bytes_len);
3841            let mut _prev_end_offset: usize = 0;
3842            if 1 > max_ordinal {
3843                return Ok(());
3844            }
3845
3846            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3847            // are envelope_size bytes.
3848            let cur_offset: usize = (1 - 1) * envelope_size;
3849
3850            // Zero reserved fields.
3851            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3852
3853            // Safety:
3854            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3855            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3856            //   envelope_size bytes, there is always sufficient room.
3857            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
3858                self.capability
3859                    .as_ref()
3860                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
3861                encoder,
3862                offset + cur_offset,
3863                depth,
3864            )?;
3865
3866            _prev_end_offset = cur_offset + envelope_size;
3867            if 2 > max_ordinal {
3868                return Ok(());
3869            }
3870
3871            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3872            // are envelope_size bytes.
3873            let cur_offset: usize = (2 - 1) * envelope_size;
3874
3875            // Zero reserved fields.
3876            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3877
3878            // Safety:
3879            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3880            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3881            //   envelope_size bytes, there is always sufficient room.
3882            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
3883            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
3884            encoder, offset + cur_offset, depth
3885        )?;
3886
3887            _prev_end_offset = cur_offset + envelope_size;
3888
3889            Ok(())
3890        }
3891    }
3892
3893    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Component {
3894        #[inline(always)]
3895        fn new_empty() -> Self {
3896            Self::default()
3897        }
3898
3899        unsafe fn decode(
3900            &mut self,
3901            decoder: &mut fidl::encoding::Decoder<'_, D>,
3902            offset: usize,
3903            mut depth: fidl::encoding::Depth,
3904        ) -> fidl::Result<()> {
3905            decoder.debug_check_bounds::<Self>(offset);
3906            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3907                None => return Err(fidl::Error::NotNullable),
3908                Some(len) => len,
3909            };
3910            // Calling decoder.out_of_line_offset(0) is not allowed.
3911            if len == 0 {
3912                return Ok(());
3913            };
3914            depth.increment()?;
3915            let envelope_size = 8;
3916            let bytes_len = len * envelope_size;
3917            let offset = decoder.out_of_line_offset(bytes_len)?;
3918            // Decode the envelope for each type.
3919            let mut _next_ordinal_to_read = 0;
3920            let mut next_offset = offset;
3921            let end_offset = offset + bytes_len;
3922            _next_ordinal_to_read += 1;
3923            if next_offset >= end_offset {
3924                return Ok(());
3925            }
3926
3927            // Decode unknown envelopes for gaps in ordinals.
3928            while _next_ordinal_to_read < 1 {
3929                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3930                _next_ordinal_to_read += 1;
3931                next_offset += envelope_size;
3932            }
3933
3934            let next_out_of_line = decoder.next_out_of_line();
3935            let handles_before = decoder.remaining_handles();
3936            if let Some((inlined, num_bytes, num_handles)) =
3937                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3938            {
3939                let member_inline_size =
3940                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
3941                        decoder.context,
3942                    );
3943                if inlined != (member_inline_size <= 4) {
3944                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3945                }
3946                let inner_offset;
3947                let mut inner_depth = depth.clone();
3948                if inlined {
3949                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3950                    inner_offset = next_offset;
3951                } else {
3952                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3953                    inner_depth.increment()?;
3954                }
3955                let val_ref =
3956                    self.capability.get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
3957                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
3958                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3959                {
3960                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3961                }
3962                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3963                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3964                }
3965            }
3966
3967            next_offset += envelope_size;
3968            _next_ordinal_to_read += 1;
3969            if next_offset >= end_offset {
3970                return Ok(());
3971            }
3972
3973            // Decode unknown envelopes for gaps in ordinals.
3974            while _next_ordinal_to_read < 2 {
3975                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3976                _next_ordinal_to_read += 1;
3977                next_offset += envelope_size;
3978            }
3979
3980            let next_out_of_line = decoder.next_out_of_line();
3981            let handles_before = decoder.remaining_handles();
3982            if let Some((inlined, num_bytes, num_handles)) =
3983                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3984            {
3985                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3986                if inlined != (member_inline_size <= 4) {
3987                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3988                }
3989                let inner_offset;
3990                let mut inner_depth = depth.clone();
3991                if inlined {
3992                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3993                    inner_offset = next_offset;
3994                } else {
3995                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3996                    inner_depth.increment()?;
3997                }
3998                let val_ref = self.moniker.get_or_insert_with(|| {
3999                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
4000                });
4001                fidl::decode!(
4002                    fidl::encoding::BoundedString<4096>,
4003                    D,
4004                    val_ref,
4005                    decoder,
4006                    inner_offset,
4007                    inner_depth
4008                )?;
4009                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4010                {
4011                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4012                }
4013                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4014                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4015                }
4016            }
4017
4018            next_offset += envelope_size;
4019
4020            // Decode the remaining unknown envelopes.
4021            while next_offset < end_offset {
4022                _next_ordinal_to_read += 1;
4023                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4024                next_offset += envelope_size;
4025            }
4026
4027            Ok(())
4028        }
4029    }
4030
4031    impl ComponentIdIndex {
4032        #[inline(always)]
4033        fn max_ordinal_present(&self) -> u64 {
4034            if let Some(_) = self.instances {
4035                return 2;
4036            }
4037            0
4038        }
4039    }
4040
4041    impl fidl::encoding::ValueTypeMarker for ComponentIdIndex {
4042        type Borrowed<'a> = &'a Self;
4043        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4044            value
4045        }
4046    }
4047
4048    unsafe impl fidl::encoding::TypeMarker for ComponentIdIndex {
4049        type Owned = Self;
4050
4051        #[inline(always)]
4052        fn inline_align(_context: fidl::encoding::Context) -> usize {
4053            8
4054        }
4055
4056        #[inline(always)]
4057        fn inline_size(_context: fidl::encoding::Context) -> usize {
4058            16
4059        }
4060    }
4061
4062    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ComponentIdIndex, D>
4063        for &ComponentIdIndex
4064    {
4065        unsafe fn encode(
4066            self,
4067            encoder: &mut fidl::encoding::Encoder<'_, D>,
4068            offset: usize,
4069            mut depth: fidl::encoding::Depth,
4070        ) -> fidl::Result<()> {
4071            encoder.debug_check_bounds::<ComponentIdIndex>(offset);
4072            // Vector header
4073            let max_ordinal: u64 = self.max_ordinal_present();
4074            encoder.write_num(max_ordinal, offset);
4075            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4076            // Calling encoder.out_of_line_offset(0) is not allowed.
4077            if max_ordinal == 0 {
4078                return Ok(());
4079            }
4080            depth.increment()?;
4081            let envelope_size = 8;
4082            let bytes_len = max_ordinal as usize * envelope_size;
4083            #[allow(unused_variables)]
4084            let offset = encoder.out_of_line_offset(bytes_len);
4085            let mut _prev_end_offset: usize = 0;
4086            if 2 > max_ordinal {
4087                return Ok(());
4088            }
4089
4090            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4091            // are envelope_size bytes.
4092            let cur_offset: usize = (2 - 1) * envelope_size;
4093
4094            // Zero reserved fields.
4095            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4096
4097            // Safety:
4098            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4099            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4100            //   envelope_size bytes, there is always sufficient room.
4101            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<InstanceIdEntry, 1024>, D>(
4102            self.instances.as_ref().map(<fidl::encoding::Vector<InstanceIdEntry, 1024> as fidl::encoding::ValueTypeMarker>::borrow),
4103            encoder, offset + cur_offset, depth
4104        )?;
4105
4106            _prev_end_offset = cur_offset + envelope_size;
4107
4108            Ok(())
4109        }
4110    }
4111
4112    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ComponentIdIndex {
4113        #[inline(always)]
4114        fn new_empty() -> Self {
4115            Self::default()
4116        }
4117
4118        unsafe fn decode(
4119            &mut self,
4120            decoder: &mut fidl::encoding::Decoder<'_, D>,
4121            offset: usize,
4122            mut depth: fidl::encoding::Depth,
4123        ) -> fidl::Result<()> {
4124            decoder.debug_check_bounds::<Self>(offset);
4125            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4126                None => return Err(fidl::Error::NotNullable),
4127                Some(len) => len,
4128            };
4129            // Calling decoder.out_of_line_offset(0) is not allowed.
4130            if len == 0 {
4131                return Ok(());
4132            };
4133            depth.increment()?;
4134            let envelope_size = 8;
4135            let bytes_len = len * envelope_size;
4136            let offset = decoder.out_of_line_offset(bytes_len)?;
4137            // Decode the envelope for each type.
4138            let mut _next_ordinal_to_read = 0;
4139            let mut next_offset = offset;
4140            let end_offset = offset + bytes_len;
4141            _next_ordinal_to_read += 1;
4142            if next_offset >= end_offset {
4143                return Ok(());
4144            }
4145
4146            // Decode unknown envelopes for gaps in ordinals.
4147            while _next_ordinal_to_read < 2 {
4148                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4149                _next_ordinal_to_read += 1;
4150                next_offset += envelope_size;
4151            }
4152
4153            let next_out_of_line = decoder.next_out_of_line();
4154            let handles_before = decoder.remaining_handles();
4155            if let Some((inlined, num_bytes, num_handles)) =
4156                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4157            {
4158                let member_inline_size = <fidl::encoding::Vector<InstanceIdEntry, 1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4159                if inlined != (member_inline_size <= 4) {
4160                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4161                }
4162                let inner_offset;
4163                let mut inner_depth = depth.clone();
4164                if inlined {
4165                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4166                    inner_offset = next_offset;
4167                } else {
4168                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4169                    inner_depth.increment()?;
4170                }
4171                let val_ref = self.instances.get_or_insert_with(
4172                    || fidl::new_empty!(fidl::encoding::Vector<InstanceIdEntry, 1024>, D),
4173                );
4174                fidl::decode!(fidl::encoding::Vector<InstanceIdEntry, 1024>, D, val_ref, decoder, inner_offset, inner_depth)?;
4175                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4176                {
4177                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4178                }
4179                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4180                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4181                }
4182            }
4183
4184            next_offset += envelope_size;
4185
4186            // Decode the remaining unknown envelopes.
4187            while next_offset < end_offset {
4188                _next_ordinal_to_read += 1;
4189                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4190                next_offset += envelope_size;
4191            }
4192
4193            Ok(())
4194        }
4195    }
4196
4197    impl Config {
4198        #[inline(always)]
4199        fn max_ordinal_present(&self) -> u64 {
4200            if let Some(_) = self.scudo_options {
4201                return 24;
4202            }
4203            if let Some(_) = self.inject_capabilities {
4204                return 23;
4205            }
4206            if let Some(_) = self.trace_provider {
4207                return 22;
4208            }
4209            if let Some(_) = self.health_check {
4210                return 21;
4211            }
4212            if let Some(_) = self.vmex_source {
4213                return 20;
4214            }
4215            if let Some(_) = self.abi_revision_policy {
4216                return 19;
4217            }
4218            if let Some(_) = self.enable_introspection {
4219                return 18;
4220            }
4221            if let Some(_) = self.builtin_capabilities {
4222                return 17;
4223            }
4224            if let Some(_) = self.realm_builder_resolver_and_runner {
4225                return 16;
4226            }
4227            if let Some(_) = self.builtin_boot_resolver {
4228                return 14;
4229            }
4230            if let Some(_) = self.log_all_events {
4231                return 13;
4232            }
4233            if let Some(_) = self.log_destination {
4234                return 12;
4235            }
4236            if let Some(_) = self.component_id_index_path {
4237                return 11;
4238            }
4239            if let Some(_) = self.root_component_url {
4240                return 10;
4241            }
4242            if let Some(_) = self.num_threads {
4243                return 7;
4244            }
4245            if let Some(_) = self.maintain_utc_clock {
4246                return 6;
4247            }
4248            if let Some(_) = self.use_builtin_process_launcher {
4249                return 5;
4250            }
4251            if let Some(_) = self.namespace_capabilities {
4252                return 4;
4253            }
4254            if let Some(_) = self.security_policy {
4255                return 3;
4256            }
4257            if let Some(_) = self.list_children_batch_size {
4258                return 2;
4259            }
4260            if let Some(_) = self.debug {
4261                return 1;
4262            }
4263            0
4264        }
4265    }
4266
4267    impl fidl::encoding::ValueTypeMarker for Config {
4268        type Borrowed<'a> = &'a Self;
4269        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4270            value
4271        }
4272    }
4273
4274    unsafe impl fidl::encoding::TypeMarker for Config {
4275        type Owned = Self;
4276
4277        #[inline(always)]
4278        fn inline_align(_context: fidl::encoding::Context) -> usize {
4279            8
4280        }
4281
4282        #[inline(always)]
4283        fn inline_size(_context: fidl::encoding::Context) -> usize {
4284            16
4285        }
4286    }
4287
4288    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Config, D> for &Config {
4289        unsafe fn encode(
4290            self,
4291            encoder: &mut fidl::encoding::Encoder<'_, D>,
4292            offset: usize,
4293            mut depth: fidl::encoding::Depth,
4294        ) -> fidl::Result<()> {
4295            encoder.debug_check_bounds::<Config>(offset);
4296            // Vector header
4297            let max_ordinal: u64 = self.max_ordinal_present();
4298            encoder.write_num(max_ordinal, offset);
4299            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4300            // Calling encoder.out_of_line_offset(0) is not allowed.
4301            if max_ordinal == 0 {
4302                return Ok(());
4303            }
4304            depth.increment()?;
4305            let envelope_size = 8;
4306            let bytes_len = max_ordinal as usize * envelope_size;
4307            #[allow(unused_variables)]
4308            let offset = encoder.out_of_line_offset(bytes_len);
4309            let mut _prev_end_offset: usize = 0;
4310            if 1 > max_ordinal {
4311                return Ok(());
4312            }
4313
4314            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4315            // are envelope_size bytes.
4316            let cur_offset: usize = (1 - 1) * envelope_size;
4317
4318            // Zero reserved fields.
4319            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4320
4321            // Safety:
4322            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4323            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4324            //   envelope_size bytes, there is always sufficient room.
4325            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4326                self.debug.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4327                encoder,
4328                offset + cur_offset,
4329                depth,
4330            )?;
4331
4332            _prev_end_offset = cur_offset + envelope_size;
4333            if 2 > max_ordinal {
4334                return Ok(());
4335            }
4336
4337            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4338            // are envelope_size bytes.
4339            let cur_offset: usize = (2 - 1) * envelope_size;
4340
4341            // Zero reserved fields.
4342            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4343
4344            // Safety:
4345            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4346            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4347            //   envelope_size bytes, there is always sufficient room.
4348            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4349                self.list_children_batch_size
4350                    .as_ref()
4351                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4352                encoder,
4353                offset + cur_offset,
4354                depth,
4355            )?;
4356
4357            _prev_end_offset = cur_offset + envelope_size;
4358            if 3 > max_ordinal {
4359                return Ok(());
4360            }
4361
4362            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4363            // are envelope_size bytes.
4364            let cur_offset: usize = (3 - 1) * envelope_size;
4365
4366            // Zero reserved fields.
4367            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4368
4369            // Safety:
4370            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4371            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4372            //   envelope_size bytes, there is always sufficient room.
4373            fidl::encoding::encode_in_envelope_optional::<SecurityPolicy, D>(
4374                self.security_policy
4375                    .as_ref()
4376                    .map(<SecurityPolicy as fidl::encoding::ValueTypeMarker>::borrow),
4377                encoder,
4378                offset + cur_offset,
4379                depth,
4380            )?;
4381
4382            _prev_end_offset = cur_offset + envelope_size;
4383            if 4 > max_ordinal {
4384                return Ok(());
4385            }
4386
4387            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4388            // are envelope_size bytes.
4389            let cur_offset: usize = (4 - 1) * envelope_size;
4390
4391            // Zero reserved fields.
4392            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4393
4394            // Safety:
4395            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4396            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4397            //   envelope_size bytes, there is always sufficient room.
4398            fidl::encoding::encode_in_envelope_optional::<
4399                fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Capability>,
4400                D,
4401            >(
4402                self.namespace_capabilities.as_ref().map(
4403                    <fidl::encoding::UnboundedVector<
4404                        fidl_fuchsia_component_decl__common::Capability,
4405                    > as fidl::encoding::ValueTypeMarker>::borrow,
4406                ),
4407                encoder,
4408                offset + cur_offset,
4409                depth,
4410            )?;
4411
4412            _prev_end_offset = cur_offset + envelope_size;
4413            if 5 > max_ordinal {
4414                return Ok(());
4415            }
4416
4417            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4418            // are envelope_size bytes.
4419            let cur_offset: usize = (5 - 1) * envelope_size;
4420
4421            // Zero reserved fields.
4422            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4423
4424            // Safety:
4425            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4426            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4427            //   envelope_size bytes, there is always sufficient room.
4428            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4429                self.use_builtin_process_launcher
4430                    .as_ref()
4431                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4432                encoder,
4433                offset + cur_offset,
4434                depth,
4435            )?;
4436
4437            _prev_end_offset = cur_offset + envelope_size;
4438            if 6 > max_ordinal {
4439                return Ok(());
4440            }
4441
4442            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4443            // are envelope_size bytes.
4444            let cur_offset: usize = (6 - 1) * envelope_size;
4445
4446            // Zero reserved fields.
4447            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4448
4449            // Safety:
4450            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4451            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4452            //   envelope_size bytes, there is always sufficient room.
4453            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4454                self.maintain_utc_clock
4455                    .as_ref()
4456                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4457                encoder,
4458                offset + cur_offset,
4459                depth,
4460            )?;
4461
4462            _prev_end_offset = cur_offset + envelope_size;
4463            if 7 > max_ordinal {
4464                return Ok(());
4465            }
4466
4467            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4468            // are envelope_size bytes.
4469            let cur_offset: usize = (7 - 1) * envelope_size;
4470
4471            // Zero reserved fields.
4472            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4473
4474            // Safety:
4475            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4476            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4477            //   envelope_size bytes, there is always sufficient room.
4478            fidl::encoding::encode_in_envelope_optional::<u8, D>(
4479                self.num_threads.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
4480                encoder,
4481                offset + cur_offset,
4482                depth,
4483            )?;
4484
4485            _prev_end_offset = cur_offset + envelope_size;
4486            if 10 > max_ordinal {
4487                return Ok(());
4488            }
4489
4490            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4491            // are envelope_size bytes.
4492            let cur_offset: usize = (10 - 1) * envelope_size;
4493
4494            // Zero reserved fields.
4495            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4496
4497            // Safety:
4498            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4499            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4500            //   envelope_size bytes, there is always sufficient room.
4501            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
4502            self.root_component_url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
4503            encoder, offset + cur_offset, depth
4504        )?;
4505
4506            _prev_end_offset = cur_offset + envelope_size;
4507            if 11 > max_ordinal {
4508                return Ok(());
4509            }
4510
4511            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4512            // are envelope_size bytes.
4513            let cur_offset: usize = (11 - 1) * envelope_size;
4514
4515            // Zero reserved fields.
4516            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4517
4518            // Safety:
4519            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4520            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4521            //   envelope_size bytes, there is always sufficient room.
4522            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4095>, D>(
4523            self.component_id_index_path.as_ref().map(<fidl::encoding::BoundedString<4095> as fidl::encoding::ValueTypeMarker>::borrow),
4524            encoder, offset + cur_offset, depth
4525        )?;
4526
4527            _prev_end_offset = cur_offset + envelope_size;
4528            if 12 > max_ordinal {
4529                return Ok(());
4530            }
4531
4532            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4533            // are envelope_size bytes.
4534            let cur_offset: usize = (12 - 1) * envelope_size;
4535
4536            // Zero reserved fields.
4537            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4538
4539            // Safety:
4540            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4541            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4542            //   envelope_size bytes, there is always sufficient room.
4543            fidl::encoding::encode_in_envelope_optional::<LogDestination, D>(
4544                self.log_destination
4545                    .as_ref()
4546                    .map(<LogDestination as fidl::encoding::ValueTypeMarker>::borrow),
4547                encoder,
4548                offset + cur_offset,
4549                depth,
4550            )?;
4551
4552            _prev_end_offset = cur_offset + envelope_size;
4553            if 13 > max_ordinal {
4554                return Ok(());
4555            }
4556
4557            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4558            // are envelope_size bytes.
4559            let cur_offset: usize = (13 - 1) * envelope_size;
4560
4561            // Zero reserved fields.
4562            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4563
4564            // Safety:
4565            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4566            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4567            //   envelope_size bytes, there is always sufficient room.
4568            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4569                self.log_all_events.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4570                encoder,
4571                offset + cur_offset,
4572                depth,
4573            )?;
4574
4575            _prev_end_offset = cur_offset + envelope_size;
4576            if 14 > max_ordinal {
4577                return Ok(());
4578            }
4579
4580            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4581            // are envelope_size bytes.
4582            let cur_offset: usize = (14 - 1) * envelope_size;
4583
4584            // Zero reserved fields.
4585            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4586
4587            // Safety:
4588            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4589            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4590            //   envelope_size bytes, there is always sufficient room.
4591            fidl::encoding::encode_in_envelope_optional::<BuiltinBootResolver, D>(
4592                self.builtin_boot_resolver
4593                    .as_ref()
4594                    .map(<BuiltinBootResolver as fidl::encoding::ValueTypeMarker>::borrow),
4595                encoder,
4596                offset + cur_offset,
4597                depth,
4598            )?;
4599
4600            _prev_end_offset = cur_offset + envelope_size;
4601            if 16 > max_ordinal {
4602                return Ok(());
4603            }
4604
4605            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4606            // are envelope_size bytes.
4607            let cur_offset: usize = (16 - 1) * envelope_size;
4608
4609            // Zero reserved fields.
4610            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4611
4612            // Safety:
4613            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4614            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4615            //   envelope_size bytes, there is always sufficient room.
4616            fidl::encoding::encode_in_envelope_optional::<RealmBuilderResolverAndRunner, D>(
4617                self.realm_builder_resolver_and_runner.as_ref().map(
4618                    <RealmBuilderResolverAndRunner as fidl::encoding::ValueTypeMarker>::borrow,
4619                ),
4620                encoder,
4621                offset + cur_offset,
4622                depth,
4623            )?;
4624
4625            _prev_end_offset = cur_offset + envelope_size;
4626            if 17 > max_ordinal {
4627                return Ok(());
4628            }
4629
4630            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4631            // are envelope_size bytes.
4632            let cur_offset: usize = (17 - 1) * envelope_size;
4633
4634            // Zero reserved fields.
4635            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4636
4637            // Safety:
4638            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4639            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4640            //   envelope_size bytes, there is always sufficient room.
4641            fidl::encoding::encode_in_envelope_optional::<
4642                fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Capability>,
4643                D,
4644            >(
4645                self.builtin_capabilities.as_ref().map(
4646                    <fidl::encoding::UnboundedVector<
4647                        fidl_fuchsia_component_decl__common::Capability,
4648                    > as fidl::encoding::ValueTypeMarker>::borrow,
4649                ),
4650                encoder,
4651                offset + cur_offset,
4652                depth,
4653            )?;
4654
4655            _prev_end_offset = cur_offset + envelope_size;
4656            if 18 > max_ordinal {
4657                return Ok(());
4658            }
4659
4660            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4661            // are envelope_size bytes.
4662            let cur_offset: usize = (18 - 1) * envelope_size;
4663
4664            // Zero reserved fields.
4665            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4666
4667            // Safety:
4668            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4669            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4670            //   envelope_size bytes, there is always sufficient room.
4671            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4672                self.enable_introspection
4673                    .as_ref()
4674                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4675                encoder,
4676                offset + cur_offset,
4677                depth,
4678            )?;
4679
4680            _prev_end_offset = cur_offset + envelope_size;
4681            if 19 > max_ordinal {
4682                return Ok(());
4683            }
4684
4685            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4686            // are envelope_size bytes.
4687            let cur_offset: usize = (19 - 1) * envelope_size;
4688
4689            // Zero reserved fields.
4690            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4691
4692            // Safety:
4693            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4694            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4695            //   envelope_size bytes, there is always sufficient room.
4696            fidl::encoding::encode_in_envelope_optional::<AbiRevisionPolicy, D>(
4697                self.abi_revision_policy
4698                    .as_ref()
4699                    .map(<AbiRevisionPolicy as fidl::encoding::ValueTypeMarker>::borrow),
4700                encoder,
4701                offset + cur_offset,
4702                depth,
4703            )?;
4704
4705            _prev_end_offset = cur_offset + envelope_size;
4706            if 20 > max_ordinal {
4707                return Ok(());
4708            }
4709
4710            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4711            // are envelope_size bytes.
4712            let cur_offset: usize = (20 - 1) * envelope_size;
4713
4714            // Zero reserved fields.
4715            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4716
4717            // Safety:
4718            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4719            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4720            //   envelope_size bytes, there is always sufficient room.
4721            fidl::encoding::encode_in_envelope_optional::<VmexSource, D>(
4722                self.vmex_source
4723                    .as_ref()
4724                    .map(<VmexSource as fidl::encoding::ValueTypeMarker>::borrow),
4725                encoder,
4726                offset + cur_offset,
4727                depth,
4728            )?;
4729
4730            _prev_end_offset = cur_offset + envelope_size;
4731            if 21 > max_ordinal {
4732                return Ok(());
4733            }
4734
4735            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4736            // are envelope_size bytes.
4737            let cur_offset: usize = (21 - 1) * envelope_size;
4738
4739            // Zero reserved fields.
4740            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4741
4742            // Safety:
4743            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4744            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4745            //   envelope_size bytes, there is always sufficient room.
4746            fidl::encoding::encode_in_envelope_optional::<HealthCheck, D>(
4747                self.health_check
4748                    .as_ref()
4749                    .map(<HealthCheck as fidl::encoding::ValueTypeMarker>::borrow),
4750                encoder,
4751                offset + cur_offset,
4752                depth,
4753            )?;
4754
4755            _prev_end_offset = cur_offset + envelope_size;
4756            if 22 > max_ordinal {
4757                return Ok(());
4758            }
4759
4760            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4761            // are envelope_size bytes.
4762            let cur_offset: usize = (22 - 1) * envelope_size;
4763
4764            // Zero reserved fields.
4765            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4766
4767            // Safety:
4768            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4769            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4770            //   envelope_size bytes, there is always sufficient room.
4771            fidl::encoding::encode_in_envelope_optional::<TraceProvider, D>(
4772                self.trace_provider
4773                    .as_ref()
4774                    .map(<TraceProvider as fidl::encoding::ValueTypeMarker>::borrow),
4775                encoder,
4776                offset + cur_offset,
4777                depth,
4778            )?;
4779
4780            _prev_end_offset = cur_offset + envelope_size;
4781            if 23 > max_ordinal {
4782                return Ok(());
4783            }
4784
4785            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4786            // are envelope_size bytes.
4787            let cur_offset: usize = (23 - 1) * envelope_size;
4788
4789            // Zero reserved fields.
4790            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4791
4792            // Safety:
4793            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4794            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4795            //   envelope_size bytes, there is always sufficient room.
4796            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<InjectedCapabilities>, D>(
4797            self.inject_capabilities.as_ref().map(<fidl::encoding::UnboundedVector<InjectedCapabilities> as fidl::encoding::ValueTypeMarker>::borrow),
4798            encoder, offset + cur_offset, depth
4799        )?;
4800
4801            _prev_end_offset = cur_offset + envelope_size;
4802            if 24 > max_ordinal {
4803                return Ok(());
4804            }
4805
4806            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4807            // are envelope_size bytes.
4808            let cur_offset: usize = (24 - 1) * envelope_size;
4809
4810            // Zero reserved fields.
4811            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4812
4813            // Safety:
4814            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4815            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4816            //   envelope_size bytes, there is always sufficient room.
4817            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
4818                self.scudo_options.as_ref().map(
4819                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
4820                ),
4821                encoder,
4822                offset + cur_offset,
4823                depth,
4824            )?;
4825
4826            _prev_end_offset = cur_offset + envelope_size;
4827
4828            Ok(())
4829        }
4830    }
4831
4832    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Config {
4833        #[inline(always)]
4834        fn new_empty() -> Self {
4835            Self::default()
4836        }
4837
4838        unsafe fn decode(
4839            &mut self,
4840            decoder: &mut fidl::encoding::Decoder<'_, D>,
4841            offset: usize,
4842            mut depth: fidl::encoding::Depth,
4843        ) -> fidl::Result<()> {
4844            decoder.debug_check_bounds::<Self>(offset);
4845            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4846                None => return Err(fidl::Error::NotNullable),
4847                Some(len) => len,
4848            };
4849            // Calling decoder.out_of_line_offset(0) is not allowed.
4850            if len == 0 {
4851                return Ok(());
4852            };
4853            depth.increment()?;
4854            let envelope_size = 8;
4855            let bytes_len = len * envelope_size;
4856            let offset = decoder.out_of_line_offset(bytes_len)?;
4857            // Decode the envelope for each type.
4858            let mut _next_ordinal_to_read = 0;
4859            let mut next_offset = offset;
4860            let end_offset = offset + bytes_len;
4861            _next_ordinal_to_read += 1;
4862            if next_offset >= end_offset {
4863                return Ok(());
4864            }
4865
4866            // Decode unknown envelopes for gaps in ordinals.
4867            while _next_ordinal_to_read < 1 {
4868                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4869                _next_ordinal_to_read += 1;
4870                next_offset += envelope_size;
4871            }
4872
4873            let next_out_of_line = decoder.next_out_of_line();
4874            let handles_before = decoder.remaining_handles();
4875            if let Some((inlined, num_bytes, num_handles)) =
4876                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4877            {
4878                let member_inline_size =
4879                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4880                if inlined != (member_inline_size <= 4) {
4881                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4882                }
4883                let inner_offset;
4884                let mut inner_depth = depth.clone();
4885                if inlined {
4886                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4887                    inner_offset = next_offset;
4888                } else {
4889                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4890                    inner_depth.increment()?;
4891                }
4892                let val_ref = self.debug.get_or_insert_with(|| fidl::new_empty!(bool, D));
4893                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4894                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4895                {
4896                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4897                }
4898                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4899                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4900                }
4901            }
4902
4903            next_offset += envelope_size;
4904            _next_ordinal_to_read += 1;
4905            if next_offset >= end_offset {
4906                return Ok(());
4907            }
4908
4909            // Decode unknown envelopes for gaps in ordinals.
4910            while _next_ordinal_to_read < 2 {
4911                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4912                _next_ordinal_to_read += 1;
4913                next_offset += envelope_size;
4914            }
4915
4916            let next_out_of_line = decoder.next_out_of_line();
4917            let handles_before = decoder.remaining_handles();
4918            if let Some((inlined, num_bytes, num_handles)) =
4919                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4920            {
4921                let member_inline_size =
4922                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4923                if inlined != (member_inline_size <= 4) {
4924                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4925                }
4926                let inner_offset;
4927                let mut inner_depth = depth.clone();
4928                if inlined {
4929                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4930                    inner_offset = next_offset;
4931                } else {
4932                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4933                    inner_depth.increment()?;
4934                }
4935                let val_ref =
4936                    self.list_children_batch_size.get_or_insert_with(|| fidl::new_empty!(u32, D));
4937                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4938                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4939                {
4940                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4941                }
4942                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4943                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4944                }
4945            }
4946
4947            next_offset += envelope_size;
4948            _next_ordinal_to_read += 1;
4949            if next_offset >= end_offset {
4950                return Ok(());
4951            }
4952
4953            // Decode unknown envelopes for gaps in ordinals.
4954            while _next_ordinal_to_read < 3 {
4955                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4956                _next_ordinal_to_read += 1;
4957                next_offset += envelope_size;
4958            }
4959
4960            let next_out_of_line = decoder.next_out_of_line();
4961            let handles_before = decoder.remaining_handles();
4962            if let Some((inlined, num_bytes, num_handles)) =
4963                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4964            {
4965                let member_inline_size =
4966                    <SecurityPolicy as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4967                if inlined != (member_inline_size <= 4) {
4968                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4969                }
4970                let inner_offset;
4971                let mut inner_depth = depth.clone();
4972                if inlined {
4973                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4974                    inner_offset = next_offset;
4975                } else {
4976                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4977                    inner_depth.increment()?;
4978                }
4979                let val_ref =
4980                    self.security_policy.get_or_insert_with(|| fidl::new_empty!(SecurityPolicy, D));
4981                fidl::decode!(SecurityPolicy, D, val_ref, decoder, inner_offset, inner_depth)?;
4982                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4983                {
4984                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4985                }
4986                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4987                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4988                }
4989            }
4990
4991            next_offset += envelope_size;
4992            _next_ordinal_to_read += 1;
4993            if next_offset >= end_offset {
4994                return Ok(());
4995            }
4996
4997            // Decode unknown envelopes for gaps in ordinals.
4998            while _next_ordinal_to_read < 4 {
4999                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5000                _next_ordinal_to_read += 1;
5001                next_offset += envelope_size;
5002            }
5003
5004            let next_out_of_line = decoder.next_out_of_line();
5005            let handles_before = decoder.remaining_handles();
5006            if let Some((inlined, num_bytes, num_handles)) =
5007                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5008            {
5009                let member_inline_size = <fidl::encoding::UnboundedVector<
5010                    fidl_fuchsia_component_decl__common::Capability,
5011                > as fidl::encoding::TypeMarker>::inline_size(
5012                    decoder.context
5013                );
5014                if inlined != (member_inline_size <= 4) {
5015                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5016                }
5017                let inner_offset;
5018                let mut inner_depth = depth.clone();
5019                if inlined {
5020                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5021                    inner_offset = next_offset;
5022                } else {
5023                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5024                    inner_depth.increment()?;
5025                }
5026                let val_ref = self.namespace_capabilities.get_or_insert_with(|| {
5027                    fidl::new_empty!(
5028                        fidl::encoding::UnboundedVector<
5029                            fidl_fuchsia_component_decl__common::Capability,
5030                        >,
5031                        D
5032                    )
5033                });
5034                fidl::decode!(
5035                    fidl::encoding::UnboundedVector<
5036                        fidl_fuchsia_component_decl__common::Capability,
5037                    >,
5038                    D,
5039                    val_ref,
5040                    decoder,
5041                    inner_offset,
5042                    inner_depth
5043                )?;
5044                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5045                {
5046                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5047                }
5048                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5049                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5050                }
5051            }
5052
5053            next_offset += envelope_size;
5054            _next_ordinal_to_read += 1;
5055            if next_offset >= end_offset {
5056                return Ok(());
5057            }
5058
5059            // Decode unknown envelopes for gaps in ordinals.
5060            while _next_ordinal_to_read < 5 {
5061                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5062                _next_ordinal_to_read += 1;
5063                next_offset += envelope_size;
5064            }
5065
5066            let next_out_of_line = decoder.next_out_of_line();
5067            let handles_before = decoder.remaining_handles();
5068            if let Some((inlined, num_bytes, num_handles)) =
5069                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5070            {
5071                let member_inline_size =
5072                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5073                if inlined != (member_inline_size <= 4) {
5074                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5075                }
5076                let inner_offset;
5077                let mut inner_depth = depth.clone();
5078                if inlined {
5079                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5080                    inner_offset = next_offset;
5081                } else {
5082                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5083                    inner_depth.increment()?;
5084                }
5085                let val_ref = self
5086                    .use_builtin_process_launcher
5087                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
5088                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5089                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5090                {
5091                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5092                }
5093                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5094                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5095                }
5096            }
5097
5098            next_offset += envelope_size;
5099            _next_ordinal_to_read += 1;
5100            if next_offset >= end_offset {
5101                return Ok(());
5102            }
5103
5104            // Decode unknown envelopes for gaps in ordinals.
5105            while _next_ordinal_to_read < 6 {
5106                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5107                _next_ordinal_to_read += 1;
5108                next_offset += envelope_size;
5109            }
5110
5111            let next_out_of_line = decoder.next_out_of_line();
5112            let handles_before = decoder.remaining_handles();
5113            if let Some((inlined, num_bytes, num_handles)) =
5114                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5115            {
5116                let member_inline_size =
5117                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5118                if inlined != (member_inline_size <= 4) {
5119                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5120                }
5121                let inner_offset;
5122                let mut inner_depth = depth.clone();
5123                if inlined {
5124                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5125                    inner_offset = next_offset;
5126                } else {
5127                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5128                    inner_depth.increment()?;
5129                }
5130                let val_ref =
5131                    self.maintain_utc_clock.get_or_insert_with(|| fidl::new_empty!(bool, D));
5132                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5133                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5134                {
5135                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5136                }
5137                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5138                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5139                }
5140            }
5141
5142            next_offset += envelope_size;
5143            _next_ordinal_to_read += 1;
5144            if next_offset >= end_offset {
5145                return Ok(());
5146            }
5147
5148            // Decode unknown envelopes for gaps in ordinals.
5149            while _next_ordinal_to_read < 7 {
5150                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5151                _next_ordinal_to_read += 1;
5152                next_offset += envelope_size;
5153            }
5154
5155            let next_out_of_line = decoder.next_out_of_line();
5156            let handles_before = decoder.remaining_handles();
5157            if let Some((inlined, num_bytes, num_handles)) =
5158                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5159            {
5160                let member_inline_size =
5161                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5162                if inlined != (member_inline_size <= 4) {
5163                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5164                }
5165                let inner_offset;
5166                let mut inner_depth = depth.clone();
5167                if inlined {
5168                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5169                    inner_offset = next_offset;
5170                } else {
5171                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5172                    inner_depth.increment()?;
5173                }
5174                let val_ref = self.num_threads.get_or_insert_with(|| fidl::new_empty!(u8, D));
5175                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
5176                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5177                {
5178                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5179                }
5180                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5181                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5182                }
5183            }
5184
5185            next_offset += envelope_size;
5186            _next_ordinal_to_read += 1;
5187            if next_offset >= end_offset {
5188                return Ok(());
5189            }
5190
5191            // Decode unknown envelopes for gaps in ordinals.
5192            while _next_ordinal_to_read < 10 {
5193                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5194                _next_ordinal_to_read += 1;
5195                next_offset += envelope_size;
5196            }
5197
5198            let next_out_of_line = decoder.next_out_of_line();
5199            let handles_before = decoder.remaining_handles();
5200            if let Some((inlined, num_bytes, num_handles)) =
5201                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5202            {
5203                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5204                if inlined != (member_inline_size <= 4) {
5205                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5206                }
5207                let inner_offset;
5208                let mut inner_depth = depth.clone();
5209                if inlined {
5210                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5211                    inner_offset = next_offset;
5212                } else {
5213                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5214                    inner_depth.increment()?;
5215                }
5216                let val_ref = self.root_component_url.get_or_insert_with(|| {
5217                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
5218                });
5219                fidl::decode!(
5220                    fidl::encoding::BoundedString<4096>,
5221                    D,
5222                    val_ref,
5223                    decoder,
5224                    inner_offset,
5225                    inner_depth
5226                )?;
5227                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5228                {
5229                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5230                }
5231                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5232                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5233                }
5234            }
5235
5236            next_offset += envelope_size;
5237            _next_ordinal_to_read += 1;
5238            if next_offset >= end_offset {
5239                return Ok(());
5240            }
5241
5242            // Decode unknown envelopes for gaps in ordinals.
5243            while _next_ordinal_to_read < 11 {
5244                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5245                _next_ordinal_to_read += 1;
5246                next_offset += envelope_size;
5247            }
5248
5249            let next_out_of_line = decoder.next_out_of_line();
5250            let handles_before = decoder.remaining_handles();
5251            if let Some((inlined, num_bytes, num_handles)) =
5252                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5253            {
5254                let member_inline_size = <fidl::encoding::BoundedString<4095> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5255                if inlined != (member_inline_size <= 4) {
5256                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5257                }
5258                let inner_offset;
5259                let mut inner_depth = depth.clone();
5260                if inlined {
5261                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5262                    inner_offset = next_offset;
5263                } else {
5264                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5265                    inner_depth.increment()?;
5266                }
5267                let val_ref = self.component_id_index_path.get_or_insert_with(|| {
5268                    fidl::new_empty!(fidl::encoding::BoundedString<4095>, D)
5269                });
5270                fidl::decode!(
5271                    fidl::encoding::BoundedString<4095>,
5272                    D,
5273                    val_ref,
5274                    decoder,
5275                    inner_offset,
5276                    inner_depth
5277                )?;
5278                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5279                {
5280                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5281                }
5282                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5283                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5284                }
5285            }
5286
5287            next_offset += envelope_size;
5288            _next_ordinal_to_read += 1;
5289            if next_offset >= end_offset {
5290                return Ok(());
5291            }
5292
5293            // Decode unknown envelopes for gaps in ordinals.
5294            while _next_ordinal_to_read < 12 {
5295                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5296                _next_ordinal_to_read += 1;
5297                next_offset += envelope_size;
5298            }
5299
5300            let next_out_of_line = decoder.next_out_of_line();
5301            let handles_before = decoder.remaining_handles();
5302            if let Some((inlined, num_bytes, num_handles)) =
5303                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5304            {
5305                let member_inline_size =
5306                    <LogDestination as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5307                if inlined != (member_inline_size <= 4) {
5308                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5309                }
5310                let inner_offset;
5311                let mut inner_depth = depth.clone();
5312                if inlined {
5313                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5314                    inner_offset = next_offset;
5315                } else {
5316                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5317                    inner_depth.increment()?;
5318                }
5319                let val_ref =
5320                    self.log_destination.get_or_insert_with(|| fidl::new_empty!(LogDestination, D));
5321                fidl::decode!(LogDestination, D, val_ref, decoder, inner_offset, inner_depth)?;
5322                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5323                {
5324                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5325                }
5326                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5327                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5328                }
5329            }
5330
5331            next_offset += envelope_size;
5332            _next_ordinal_to_read += 1;
5333            if next_offset >= end_offset {
5334                return Ok(());
5335            }
5336
5337            // Decode unknown envelopes for gaps in ordinals.
5338            while _next_ordinal_to_read < 13 {
5339                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5340                _next_ordinal_to_read += 1;
5341                next_offset += envelope_size;
5342            }
5343
5344            let next_out_of_line = decoder.next_out_of_line();
5345            let handles_before = decoder.remaining_handles();
5346            if let Some((inlined, num_bytes, num_handles)) =
5347                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5348            {
5349                let member_inline_size =
5350                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5351                if inlined != (member_inline_size <= 4) {
5352                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5353                }
5354                let inner_offset;
5355                let mut inner_depth = depth.clone();
5356                if inlined {
5357                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5358                    inner_offset = next_offset;
5359                } else {
5360                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5361                    inner_depth.increment()?;
5362                }
5363                let val_ref = self.log_all_events.get_or_insert_with(|| fidl::new_empty!(bool, D));
5364                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5365                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5366                {
5367                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5368                }
5369                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5370                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5371                }
5372            }
5373
5374            next_offset += envelope_size;
5375            _next_ordinal_to_read += 1;
5376            if next_offset >= end_offset {
5377                return Ok(());
5378            }
5379
5380            // Decode unknown envelopes for gaps in ordinals.
5381            while _next_ordinal_to_read < 14 {
5382                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5383                _next_ordinal_to_read += 1;
5384                next_offset += envelope_size;
5385            }
5386
5387            let next_out_of_line = decoder.next_out_of_line();
5388            let handles_before = decoder.remaining_handles();
5389            if let Some((inlined, num_bytes, num_handles)) =
5390                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5391            {
5392                let member_inline_size =
5393                    <BuiltinBootResolver as fidl::encoding::TypeMarker>::inline_size(
5394                        decoder.context,
5395                    );
5396                if inlined != (member_inline_size <= 4) {
5397                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5398                }
5399                let inner_offset;
5400                let mut inner_depth = depth.clone();
5401                if inlined {
5402                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5403                    inner_offset = next_offset;
5404                } else {
5405                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5406                    inner_depth.increment()?;
5407                }
5408                let val_ref = self
5409                    .builtin_boot_resolver
5410                    .get_or_insert_with(|| fidl::new_empty!(BuiltinBootResolver, D));
5411                fidl::decode!(BuiltinBootResolver, D, val_ref, decoder, inner_offset, inner_depth)?;
5412                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5413                {
5414                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5415                }
5416                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5417                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5418                }
5419            }
5420
5421            next_offset += envelope_size;
5422            _next_ordinal_to_read += 1;
5423            if next_offset >= end_offset {
5424                return Ok(());
5425            }
5426
5427            // Decode unknown envelopes for gaps in ordinals.
5428            while _next_ordinal_to_read < 16 {
5429                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5430                _next_ordinal_to_read += 1;
5431                next_offset += envelope_size;
5432            }
5433
5434            let next_out_of_line = decoder.next_out_of_line();
5435            let handles_before = decoder.remaining_handles();
5436            if let Some((inlined, num_bytes, num_handles)) =
5437                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5438            {
5439                let member_inline_size =
5440                    <RealmBuilderResolverAndRunner as fidl::encoding::TypeMarker>::inline_size(
5441                        decoder.context,
5442                    );
5443                if inlined != (member_inline_size <= 4) {
5444                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5445                }
5446                let inner_offset;
5447                let mut inner_depth = depth.clone();
5448                if inlined {
5449                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5450                    inner_offset = next_offset;
5451                } else {
5452                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5453                    inner_depth.increment()?;
5454                }
5455                let val_ref = self
5456                    .realm_builder_resolver_and_runner
5457                    .get_or_insert_with(|| fidl::new_empty!(RealmBuilderResolverAndRunner, D));
5458                fidl::decode!(
5459                    RealmBuilderResolverAndRunner,
5460                    D,
5461                    val_ref,
5462                    decoder,
5463                    inner_offset,
5464                    inner_depth
5465                )?;
5466                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5467                {
5468                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5469                }
5470                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5471                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5472                }
5473            }
5474
5475            next_offset += envelope_size;
5476            _next_ordinal_to_read += 1;
5477            if next_offset >= end_offset {
5478                return Ok(());
5479            }
5480
5481            // Decode unknown envelopes for gaps in ordinals.
5482            while _next_ordinal_to_read < 17 {
5483                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5484                _next_ordinal_to_read += 1;
5485                next_offset += envelope_size;
5486            }
5487
5488            let next_out_of_line = decoder.next_out_of_line();
5489            let handles_before = decoder.remaining_handles();
5490            if let Some((inlined, num_bytes, num_handles)) =
5491                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5492            {
5493                let member_inline_size = <fidl::encoding::UnboundedVector<
5494                    fidl_fuchsia_component_decl__common::Capability,
5495                > as fidl::encoding::TypeMarker>::inline_size(
5496                    decoder.context
5497                );
5498                if inlined != (member_inline_size <= 4) {
5499                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5500                }
5501                let inner_offset;
5502                let mut inner_depth = depth.clone();
5503                if inlined {
5504                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5505                    inner_offset = next_offset;
5506                } else {
5507                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5508                    inner_depth.increment()?;
5509                }
5510                let val_ref = self.builtin_capabilities.get_or_insert_with(|| {
5511                    fidl::new_empty!(
5512                        fidl::encoding::UnboundedVector<
5513                            fidl_fuchsia_component_decl__common::Capability,
5514                        >,
5515                        D
5516                    )
5517                });
5518                fidl::decode!(
5519                    fidl::encoding::UnboundedVector<
5520                        fidl_fuchsia_component_decl__common::Capability,
5521                    >,
5522                    D,
5523                    val_ref,
5524                    decoder,
5525                    inner_offset,
5526                    inner_depth
5527                )?;
5528                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5529                {
5530                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5531                }
5532                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5533                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5534                }
5535            }
5536
5537            next_offset += envelope_size;
5538            _next_ordinal_to_read += 1;
5539            if next_offset >= end_offset {
5540                return Ok(());
5541            }
5542
5543            // Decode unknown envelopes for gaps in ordinals.
5544            while _next_ordinal_to_read < 18 {
5545                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5546                _next_ordinal_to_read += 1;
5547                next_offset += envelope_size;
5548            }
5549
5550            let next_out_of_line = decoder.next_out_of_line();
5551            let handles_before = decoder.remaining_handles();
5552            if let Some((inlined, num_bytes, num_handles)) =
5553                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5554            {
5555                let member_inline_size =
5556                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5557                if inlined != (member_inline_size <= 4) {
5558                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5559                }
5560                let inner_offset;
5561                let mut inner_depth = depth.clone();
5562                if inlined {
5563                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5564                    inner_offset = next_offset;
5565                } else {
5566                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5567                    inner_depth.increment()?;
5568                }
5569                let val_ref =
5570                    self.enable_introspection.get_or_insert_with(|| fidl::new_empty!(bool, D));
5571                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5572                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5573                {
5574                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5575                }
5576                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5577                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5578                }
5579            }
5580
5581            next_offset += envelope_size;
5582            _next_ordinal_to_read += 1;
5583            if next_offset >= end_offset {
5584                return Ok(());
5585            }
5586
5587            // Decode unknown envelopes for gaps in ordinals.
5588            while _next_ordinal_to_read < 19 {
5589                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5590                _next_ordinal_to_read += 1;
5591                next_offset += envelope_size;
5592            }
5593
5594            let next_out_of_line = decoder.next_out_of_line();
5595            let handles_before = decoder.remaining_handles();
5596            if let Some((inlined, num_bytes, num_handles)) =
5597                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5598            {
5599                let member_inline_size =
5600                    <AbiRevisionPolicy as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5601                if inlined != (member_inline_size <= 4) {
5602                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5603                }
5604                let inner_offset;
5605                let mut inner_depth = depth.clone();
5606                if inlined {
5607                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5608                    inner_offset = next_offset;
5609                } else {
5610                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5611                    inner_depth.increment()?;
5612                }
5613                let val_ref = self
5614                    .abi_revision_policy
5615                    .get_or_insert_with(|| fidl::new_empty!(AbiRevisionPolicy, D));
5616                fidl::decode!(AbiRevisionPolicy, D, val_ref, decoder, inner_offset, inner_depth)?;
5617                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5618                {
5619                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5620                }
5621                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5622                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5623                }
5624            }
5625
5626            next_offset += envelope_size;
5627            _next_ordinal_to_read += 1;
5628            if next_offset >= end_offset {
5629                return Ok(());
5630            }
5631
5632            // Decode unknown envelopes for gaps in ordinals.
5633            while _next_ordinal_to_read < 20 {
5634                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5635                _next_ordinal_to_read += 1;
5636                next_offset += envelope_size;
5637            }
5638
5639            let next_out_of_line = decoder.next_out_of_line();
5640            let handles_before = decoder.remaining_handles();
5641            if let Some((inlined, num_bytes, num_handles)) =
5642                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5643            {
5644                let member_inline_size =
5645                    <VmexSource as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5646                if inlined != (member_inline_size <= 4) {
5647                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5648                }
5649                let inner_offset;
5650                let mut inner_depth = depth.clone();
5651                if inlined {
5652                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5653                    inner_offset = next_offset;
5654                } else {
5655                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5656                    inner_depth.increment()?;
5657                }
5658                let val_ref =
5659                    self.vmex_source.get_or_insert_with(|| fidl::new_empty!(VmexSource, D));
5660                fidl::decode!(VmexSource, D, val_ref, decoder, inner_offset, inner_depth)?;
5661                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5662                {
5663                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5664                }
5665                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5666                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5667                }
5668            }
5669
5670            next_offset += envelope_size;
5671            _next_ordinal_to_read += 1;
5672            if next_offset >= end_offset {
5673                return Ok(());
5674            }
5675
5676            // Decode unknown envelopes for gaps in ordinals.
5677            while _next_ordinal_to_read < 21 {
5678                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5679                _next_ordinal_to_read += 1;
5680                next_offset += envelope_size;
5681            }
5682
5683            let next_out_of_line = decoder.next_out_of_line();
5684            let handles_before = decoder.remaining_handles();
5685            if let Some((inlined, num_bytes, num_handles)) =
5686                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5687            {
5688                let member_inline_size =
5689                    <HealthCheck as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5690                if inlined != (member_inline_size <= 4) {
5691                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5692                }
5693                let inner_offset;
5694                let mut inner_depth = depth.clone();
5695                if inlined {
5696                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5697                    inner_offset = next_offset;
5698                } else {
5699                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5700                    inner_depth.increment()?;
5701                }
5702                let val_ref =
5703                    self.health_check.get_or_insert_with(|| fidl::new_empty!(HealthCheck, D));
5704                fidl::decode!(HealthCheck, D, val_ref, decoder, inner_offset, inner_depth)?;
5705                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5706                {
5707                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5708                }
5709                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5710                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5711                }
5712            }
5713
5714            next_offset += envelope_size;
5715            _next_ordinal_to_read += 1;
5716            if next_offset >= end_offset {
5717                return Ok(());
5718            }
5719
5720            // Decode unknown envelopes for gaps in ordinals.
5721            while _next_ordinal_to_read < 22 {
5722                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5723                _next_ordinal_to_read += 1;
5724                next_offset += envelope_size;
5725            }
5726
5727            let next_out_of_line = decoder.next_out_of_line();
5728            let handles_before = decoder.remaining_handles();
5729            if let Some((inlined, num_bytes, num_handles)) =
5730                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5731            {
5732                let member_inline_size =
5733                    <TraceProvider as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5734                if inlined != (member_inline_size <= 4) {
5735                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5736                }
5737                let inner_offset;
5738                let mut inner_depth = depth.clone();
5739                if inlined {
5740                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5741                    inner_offset = next_offset;
5742                } else {
5743                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5744                    inner_depth.increment()?;
5745                }
5746                let val_ref =
5747                    self.trace_provider.get_or_insert_with(|| fidl::new_empty!(TraceProvider, D));
5748                fidl::decode!(TraceProvider, D, val_ref, decoder, inner_offset, inner_depth)?;
5749                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5750                {
5751                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5752                }
5753                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5754                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5755                }
5756            }
5757
5758            next_offset += envelope_size;
5759            _next_ordinal_to_read += 1;
5760            if next_offset >= end_offset {
5761                return Ok(());
5762            }
5763
5764            // Decode unknown envelopes for gaps in ordinals.
5765            while _next_ordinal_to_read < 23 {
5766                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5767                _next_ordinal_to_read += 1;
5768                next_offset += envelope_size;
5769            }
5770
5771            let next_out_of_line = decoder.next_out_of_line();
5772            let handles_before = decoder.remaining_handles();
5773            if let Some((inlined, num_bytes, num_handles)) =
5774                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5775            {
5776                let member_inline_size = <fidl::encoding::UnboundedVector<InjectedCapabilities> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5777                if inlined != (member_inline_size <= 4) {
5778                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5779                }
5780                let inner_offset;
5781                let mut inner_depth = depth.clone();
5782                if inlined {
5783                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5784                    inner_offset = next_offset;
5785                } else {
5786                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5787                    inner_depth.increment()?;
5788                }
5789                let val_ref = self.inject_capabilities.get_or_insert_with(|| {
5790                    fidl::new_empty!(fidl::encoding::UnboundedVector<InjectedCapabilities>, D)
5791                });
5792                fidl::decode!(
5793                    fidl::encoding::UnboundedVector<InjectedCapabilities>,
5794                    D,
5795                    val_ref,
5796                    decoder,
5797                    inner_offset,
5798                    inner_depth
5799                )?;
5800                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5801                {
5802                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5803                }
5804                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5805                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5806                }
5807            }
5808
5809            next_offset += envelope_size;
5810            _next_ordinal_to_read += 1;
5811            if next_offset >= end_offset {
5812                return Ok(());
5813            }
5814
5815            // Decode unknown envelopes for gaps in ordinals.
5816            while _next_ordinal_to_read < 24 {
5817                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5818                _next_ordinal_to_read += 1;
5819                next_offset += envelope_size;
5820            }
5821
5822            let next_out_of_line = decoder.next_out_of_line();
5823            let handles_before = decoder.remaining_handles();
5824            if let Some((inlined, num_bytes, num_handles)) =
5825                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5826            {
5827                let member_inline_size =
5828                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
5829                        decoder.context,
5830                    );
5831                if inlined != (member_inline_size <= 4) {
5832                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5833                }
5834                let inner_offset;
5835                let mut inner_depth = depth.clone();
5836                if inlined {
5837                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5838                    inner_offset = next_offset;
5839                } else {
5840                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5841                    inner_depth.increment()?;
5842                }
5843                let val_ref = self
5844                    .scudo_options
5845                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
5846                fidl::decode!(
5847                    fidl::encoding::UnboundedString,
5848                    D,
5849                    val_ref,
5850                    decoder,
5851                    inner_offset,
5852                    inner_depth
5853                )?;
5854                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5855                {
5856                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5857                }
5858                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5859                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5860                }
5861            }
5862
5863            next_offset += envelope_size;
5864
5865            // Decode the remaining unknown envelopes.
5866            while next_offset < end_offset {
5867                _next_ordinal_to_read += 1;
5868                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5869                next_offset += envelope_size;
5870            }
5871
5872            Ok(())
5873        }
5874    }
5875
5876    impl DebugRegistrationAllowlistEntry {
5877        #[inline(always)]
5878        fn max_ordinal_present(&self) -> u64 {
5879            if let Some(_) = self.environment_name {
5880                return 4;
5881            }
5882            if let Some(_) = self.moniker {
5883                return 3;
5884            }
5885            if let Some(_) = self.debug {
5886                return 2;
5887            }
5888            if let Some(_) = self.name {
5889                return 1;
5890            }
5891            0
5892        }
5893    }
5894
5895    impl fidl::encoding::ValueTypeMarker for DebugRegistrationAllowlistEntry {
5896        type Borrowed<'a> = &'a Self;
5897        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5898            value
5899        }
5900    }
5901
5902    unsafe impl fidl::encoding::TypeMarker for DebugRegistrationAllowlistEntry {
5903        type Owned = Self;
5904
5905        #[inline(always)]
5906        fn inline_align(_context: fidl::encoding::Context) -> usize {
5907            8
5908        }
5909
5910        #[inline(always)]
5911        fn inline_size(_context: fidl::encoding::Context) -> usize {
5912            16
5913        }
5914    }
5915
5916    unsafe impl<D: fidl::encoding::ResourceDialect>
5917        fidl::encoding::Encode<DebugRegistrationAllowlistEntry, D>
5918        for &DebugRegistrationAllowlistEntry
5919    {
5920        unsafe fn encode(
5921            self,
5922            encoder: &mut fidl::encoding::Encoder<'_, D>,
5923            offset: usize,
5924            mut depth: fidl::encoding::Depth,
5925        ) -> fidl::Result<()> {
5926            encoder.debug_check_bounds::<DebugRegistrationAllowlistEntry>(offset);
5927            // Vector header
5928            let max_ordinal: u64 = self.max_ordinal_present();
5929            encoder.write_num(max_ordinal, offset);
5930            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5931            // Calling encoder.out_of_line_offset(0) is not allowed.
5932            if max_ordinal == 0 {
5933                return Ok(());
5934            }
5935            depth.increment()?;
5936            let envelope_size = 8;
5937            let bytes_len = max_ordinal as usize * envelope_size;
5938            #[allow(unused_variables)]
5939            let offset = encoder.out_of_line_offset(bytes_len);
5940            let mut _prev_end_offset: usize = 0;
5941            if 1 > max_ordinal {
5942                return Ok(());
5943            }
5944
5945            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5946            // are envelope_size bytes.
5947            let cur_offset: usize = (1 - 1) * envelope_size;
5948
5949            // Zero reserved fields.
5950            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5951
5952            // Safety:
5953            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5954            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5955            //   envelope_size bytes, there is always sufficient room.
5956            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
5957                self.name.as_ref().map(
5958                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
5959                ),
5960                encoder,
5961                offset + cur_offset,
5962                depth,
5963            )?;
5964
5965            _prev_end_offset = cur_offset + envelope_size;
5966            if 2 > max_ordinal {
5967                return Ok(());
5968            }
5969
5970            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5971            // are envelope_size bytes.
5972            let cur_offset: usize = (2 - 1) * envelope_size;
5973
5974            // Zero reserved fields.
5975            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5976
5977            // Safety:
5978            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5979            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5980            //   envelope_size bytes, there is always sufficient room.
5981            fidl::encoding::encode_in_envelope_optional::<AllowlistedDebugRegistration, D>(
5982                self.debug
5983                    .as_ref()
5984                    .map(<AllowlistedDebugRegistration as fidl::encoding::ValueTypeMarker>::borrow),
5985                encoder,
5986                offset + cur_offset,
5987                depth,
5988            )?;
5989
5990            _prev_end_offset = cur_offset + envelope_size;
5991            if 3 > max_ordinal {
5992                return Ok(());
5993            }
5994
5995            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5996            // are envelope_size bytes.
5997            let cur_offset: usize = (3 - 1) * envelope_size;
5998
5999            // Zero reserved fields.
6000            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6001
6002            // Safety:
6003            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6004            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6005            //   envelope_size bytes, there is always sufficient room.
6006            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6007            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6008            encoder, offset + cur_offset, depth
6009        )?;
6010
6011            _prev_end_offset = cur_offset + envelope_size;
6012            if 4 > max_ordinal {
6013                return Ok(());
6014            }
6015
6016            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6017            // are envelope_size bytes.
6018            let cur_offset: usize = (4 - 1) * envelope_size;
6019
6020            // Zero reserved fields.
6021            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6022
6023            // Safety:
6024            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6025            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6026            //   envelope_size bytes, there is always sufficient room.
6027            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
6028                self.environment_name.as_ref().map(
6029                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
6030                ),
6031                encoder,
6032                offset + cur_offset,
6033                depth,
6034            )?;
6035
6036            _prev_end_offset = cur_offset + envelope_size;
6037
6038            Ok(())
6039        }
6040    }
6041
6042    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6043        for DebugRegistrationAllowlistEntry
6044    {
6045        #[inline(always)]
6046        fn new_empty() -> Self {
6047            Self::default()
6048        }
6049
6050        unsafe fn decode(
6051            &mut self,
6052            decoder: &mut fidl::encoding::Decoder<'_, D>,
6053            offset: usize,
6054            mut depth: fidl::encoding::Depth,
6055        ) -> fidl::Result<()> {
6056            decoder.debug_check_bounds::<Self>(offset);
6057            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6058                None => return Err(fidl::Error::NotNullable),
6059                Some(len) => len,
6060            };
6061            // Calling decoder.out_of_line_offset(0) is not allowed.
6062            if len == 0 {
6063                return Ok(());
6064            };
6065            depth.increment()?;
6066            let envelope_size = 8;
6067            let bytes_len = len * envelope_size;
6068            let offset = decoder.out_of_line_offset(bytes_len)?;
6069            // Decode the envelope for each type.
6070            let mut _next_ordinal_to_read = 0;
6071            let mut next_offset = offset;
6072            let end_offset = offset + bytes_len;
6073            _next_ordinal_to_read += 1;
6074            if next_offset >= end_offset {
6075                return Ok(());
6076            }
6077
6078            // Decode unknown envelopes for gaps in ordinals.
6079            while _next_ordinal_to_read < 1 {
6080                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6081                _next_ordinal_to_read += 1;
6082                next_offset += envelope_size;
6083            }
6084
6085            let next_out_of_line = decoder.next_out_of_line();
6086            let handles_before = decoder.remaining_handles();
6087            if let Some((inlined, num_bytes, num_handles)) =
6088                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6089            {
6090                let member_inline_size =
6091                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6092                        decoder.context,
6093                    );
6094                if inlined != (member_inline_size <= 4) {
6095                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6096                }
6097                let inner_offset;
6098                let mut inner_depth = depth.clone();
6099                if inlined {
6100                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6101                    inner_offset = next_offset;
6102                } else {
6103                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6104                    inner_depth.increment()?;
6105                }
6106                let val_ref = self
6107                    .name
6108                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6109                fidl::decode!(
6110                    fidl::encoding::BoundedString<255>,
6111                    D,
6112                    val_ref,
6113                    decoder,
6114                    inner_offset,
6115                    inner_depth
6116                )?;
6117                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6118                {
6119                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6120                }
6121                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6122                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6123                }
6124            }
6125
6126            next_offset += envelope_size;
6127            _next_ordinal_to_read += 1;
6128            if next_offset >= end_offset {
6129                return Ok(());
6130            }
6131
6132            // Decode unknown envelopes for gaps in ordinals.
6133            while _next_ordinal_to_read < 2 {
6134                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6135                _next_ordinal_to_read += 1;
6136                next_offset += envelope_size;
6137            }
6138
6139            let next_out_of_line = decoder.next_out_of_line();
6140            let handles_before = decoder.remaining_handles();
6141            if let Some((inlined, num_bytes, num_handles)) =
6142                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6143            {
6144                let member_inline_size =
6145                    <AllowlistedDebugRegistration as fidl::encoding::TypeMarker>::inline_size(
6146                        decoder.context,
6147                    );
6148                if inlined != (member_inline_size <= 4) {
6149                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6150                }
6151                let inner_offset;
6152                let mut inner_depth = depth.clone();
6153                if inlined {
6154                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6155                    inner_offset = next_offset;
6156                } else {
6157                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6158                    inner_depth.increment()?;
6159                }
6160                let val_ref = self
6161                    .debug
6162                    .get_or_insert_with(|| fidl::new_empty!(AllowlistedDebugRegistration, D));
6163                fidl::decode!(
6164                    AllowlistedDebugRegistration,
6165                    D,
6166                    val_ref,
6167                    decoder,
6168                    inner_offset,
6169                    inner_depth
6170                )?;
6171                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6172                {
6173                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6174                }
6175                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6176                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6177                }
6178            }
6179
6180            next_offset += envelope_size;
6181            _next_ordinal_to_read += 1;
6182            if next_offset >= end_offset {
6183                return Ok(());
6184            }
6185
6186            // Decode unknown envelopes for gaps in ordinals.
6187            while _next_ordinal_to_read < 3 {
6188                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6189                _next_ordinal_to_read += 1;
6190                next_offset += envelope_size;
6191            }
6192
6193            let next_out_of_line = decoder.next_out_of_line();
6194            let handles_before = decoder.remaining_handles();
6195            if let Some((inlined, num_bytes, num_handles)) =
6196                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6197            {
6198                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6199                if inlined != (member_inline_size <= 4) {
6200                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6201                }
6202                let inner_offset;
6203                let mut inner_depth = depth.clone();
6204                if inlined {
6205                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6206                    inner_offset = next_offset;
6207                } else {
6208                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6209                    inner_depth.increment()?;
6210                }
6211                let val_ref = self.moniker.get_or_insert_with(|| {
6212                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
6213                });
6214                fidl::decode!(
6215                    fidl::encoding::BoundedString<4096>,
6216                    D,
6217                    val_ref,
6218                    decoder,
6219                    inner_offset,
6220                    inner_depth
6221                )?;
6222                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6223                {
6224                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6225                }
6226                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6227                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6228                }
6229            }
6230
6231            next_offset += envelope_size;
6232            _next_ordinal_to_read += 1;
6233            if next_offset >= end_offset {
6234                return Ok(());
6235            }
6236
6237            // Decode unknown envelopes for gaps in ordinals.
6238            while _next_ordinal_to_read < 4 {
6239                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6240                _next_ordinal_to_read += 1;
6241                next_offset += envelope_size;
6242            }
6243
6244            let next_out_of_line = decoder.next_out_of_line();
6245            let handles_before = decoder.remaining_handles();
6246            if let Some((inlined, num_bytes, num_handles)) =
6247                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6248            {
6249                let member_inline_size =
6250                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
6251                        decoder.context,
6252                    );
6253                if inlined != (member_inline_size <= 4) {
6254                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6255                }
6256                let inner_offset;
6257                let mut inner_depth = depth.clone();
6258                if inlined {
6259                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6260                    inner_offset = next_offset;
6261                } else {
6262                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6263                    inner_depth.increment()?;
6264                }
6265                let val_ref = self
6266                    .environment_name
6267                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
6268                fidl::decode!(
6269                    fidl::encoding::BoundedString<255>,
6270                    D,
6271                    val_ref,
6272                    decoder,
6273                    inner_offset,
6274                    inner_depth
6275                )?;
6276                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6277                {
6278                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6279                }
6280                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6281                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6282                }
6283            }
6284
6285            next_offset += envelope_size;
6286
6287            // Decode the remaining unknown envelopes.
6288            while next_offset < end_offset {
6289                _next_ordinal_to_read += 1;
6290                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6291                next_offset += envelope_size;
6292            }
6293
6294            Ok(())
6295        }
6296    }
6297
6298    impl DebugRegistrationPolicyAllowlists {
6299        #[inline(always)]
6300        fn max_ordinal_present(&self) -> u64 {
6301            if let Some(_) = self.allowlist {
6302                return 1;
6303            }
6304            0
6305        }
6306    }
6307
6308    impl fidl::encoding::ValueTypeMarker for DebugRegistrationPolicyAllowlists {
6309        type Borrowed<'a> = &'a Self;
6310        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6311            value
6312        }
6313    }
6314
6315    unsafe impl fidl::encoding::TypeMarker for DebugRegistrationPolicyAllowlists {
6316        type Owned = Self;
6317
6318        #[inline(always)]
6319        fn inline_align(_context: fidl::encoding::Context) -> usize {
6320            8
6321        }
6322
6323        #[inline(always)]
6324        fn inline_size(_context: fidl::encoding::Context) -> usize {
6325            16
6326        }
6327    }
6328
6329    unsafe impl<D: fidl::encoding::ResourceDialect>
6330        fidl::encoding::Encode<DebugRegistrationPolicyAllowlists, D>
6331        for &DebugRegistrationPolicyAllowlists
6332    {
6333        unsafe fn encode(
6334            self,
6335            encoder: &mut fidl::encoding::Encoder<'_, D>,
6336            offset: usize,
6337            mut depth: fidl::encoding::Depth,
6338        ) -> fidl::Result<()> {
6339            encoder.debug_check_bounds::<DebugRegistrationPolicyAllowlists>(offset);
6340            // Vector header
6341            let max_ordinal: u64 = self.max_ordinal_present();
6342            encoder.write_num(max_ordinal, offset);
6343            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6344            // Calling encoder.out_of_line_offset(0) is not allowed.
6345            if max_ordinal == 0 {
6346                return Ok(());
6347            }
6348            depth.increment()?;
6349            let envelope_size = 8;
6350            let bytes_len = max_ordinal as usize * envelope_size;
6351            #[allow(unused_variables)]
6352            let offset = encoder.out_of_line_offset(bytes_len);
6353            let mut _prev_end_offset: usize = 0;
6354            if 1 > max_ordinal {
6355                return Ok(());
6356            }
6357
6358            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6359            // are envelope_size bytes.
6360            let cur_offset: usize = (1 - 1) * envelope_size;
6361
6362            // Zero reserved fields.
6363            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6364
6365            // Safety:
6366            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6367            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6368            //   envelope_size bytes, there is always sufficient room.
6369            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128>, D>(
6370            self.allowlist.as_ref().map(<fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128> as fidl::encoding::ValueTypeMarker>::borrow),
6371            encoder, offset + cur_offset, depth
6372        )?;
6373
6374            _prev_end_offset = cur_offset + envelope_size;
6375
6376            Ok(())
6377        }
6378    }
6379
6380    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6381        for DebugRegistrationPolicyAllowlists
6382    {
6383        #[inline(always)]
6384        fn new_empty() -> Self {
6385            Self::default()
6386        }
6387
6388        unsafe fn decode(
6389            &mut self,
6390            decoder: &mut fidl::encoding::Decoder<'_, D>,
6391            offset: usize,
6392            mut depth: fidl::encoding::Depth,
6393        ) -> fidl::Result<()> {
6394            decoder.debug_check_bounds::<Self>(offset);
6395            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6396                None => return Err(fidl::Error::NotNullable),
6397                Some(len) => len,
6398            };
6399            // Calling decoder.out_of_line_offset(0) is not allowed.
6400            if len == 0 {
6401                return Ok(());
6402            };
6403            depth.increment()?;
6404            let envelope_size = 8;
6405            let bytes_len = len * envelope_size;
6406            let offset = decoder.out_of_line_offset(bytes_len)?;
6407            // Decode the envelope for each type.
6408            let mut _next_ordinal_to_read = 0;
6409            let mut next_offset = offset;
6410            let end_offset = offset + bytes_len;
6411            _next_ordinal_to_read += 1;
6412            if next_offset >= end_offset {
6413                return Ok(());
6414            }
6415
6416            // Decode unknown envelopes for gaps in ordinals.
6417            while _next_ordinal_to_read < 1 {
6418                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6419                _next_ordinal_to_read += 1;
6420                next_offset += envelope_size;
6421            }
6422
6423            let next_out_of_line = decoder.next_out_of_line();
6424            let handles_before = decoder.remaining_handles();
6425            if let Some((inlined, num_bytes, num_handles)) =
6426                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6427            {
6428                let member_inline_size = <fidl::encoding::Vector<
6429                    DebugRegistrationAllowlistEntry,
6430                    128,
6431                > as fidl::encoding::TypeMarker>::inline_size(
6432                    decoder.context
6433                );
6434                if inlined != (member_inline_size <= 4) {
6435                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6436                }
6437                let inner_offset;
6438                let mut inner_depth = depth.clone();
6439                if inlined {
6440                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6441                    inner_offset = next_offset;
6442                } else {
6443                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6444                    inner_depth.increment()?;
6445                }
6446                let val_ref =
6447                self.allowlist.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128>, D));
6448                fidl::decode!(fidl::encoding::Vector<DebugRegistrationAllowlistEntry, 128>, D, val_ref, decoder, inner_offset, inner_depth)?;
6449                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6450                {
6451                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6452                }
6453                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6454                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6455                }
6456            }
6457
6458            next_offset += envelope_size;
6459
6460            // Decode the remaining unknown envelopes.
6461            while next_offset < end_offset {
6462                _next_ordinal_to_read += 1;
6463                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6464                next_offset += envelope_size;
6465            }
6466
6467            Ok(())
6468        }
6469    }
6470
6471    impl Environment {
6472        #[inline(always)]
6473        fn max_ordinal_present(&self) -> u64 {
6474            if let Some(_) = self.moniker {
6475                return 2;
6476            }
6477            if let Some(_) = self.capability {
6478                return 1;
6479            }
6480            0
6481        }
6482    }
6483
6484    impl fidl::encoding::ValueTypeMarker for Environment {
6485        type Borrowed<'a> = &'a Self;
6486        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6487            value
6488        }
6489    }
6490
6491    unsafe impl fidl::encoding::TypeMarker for Environment {
6492        type Owned = Self;
6493
6494        #[inline(always)]
6495        fn inline_align(_context: fidl::encoding::Context) -> usize {
6496            8
6497        }
6498
6499        #[inline(always)]
6500        fn inline_size(_context: fidl::encoding::Context) -> usize {
6501            16
6502        }
6503    }
6504
6505    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Environment, D>
6506        for &Environment
6507    {
6508        unsafe fn encode(
6509            self,
6510            encoder: &mut fidl::encoding::Encoder<'_, D>,
6511            offset: usize,
6512            mut depth: fidl::encoding::Depth,
6513        ) -> fidl::Result<()> {
6514            encoder.debug_check_bounds::<Environment>(offset);
6515            // Vector header
6516            let max_ordinal: u64 = self.max_ordinal_present();
6517            encoder.write_num(max_ordinal, offset);
6518            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6519            // Calling encoder.out_of_line_offset(0) is not allowed.
6520            if max_ordinal == 0 {
6521                return Ok(());
6522            }
6523            depth.increment()?;
6524            let envelope_size = 8;
6525            let bytes_len = max_ordinal as usize * envelope_size;
6526            #[allow(unused_variables)]
6527            let offset = encoder.out_of_line_offset(bytes_len);
6528            let mut _prev_end_offset: usize = 0;
6529            if 1 > max_ordinal {
6530                return Ok(());
6531            }
6532
6533            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6534            // are envelope_size bytes.
6535            let cur_offset: usize = (1 - 1) * envelope_size;
6536
6537            // Zero reserved fields.
6538            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6539
6540            // Safety:
6541            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6542            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6543            //   envelope_size bytes, there is always sufficient room.
6544            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
6545                self.capability
6546                    .as_ref()
6547                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
6548                encoder,
6549                offset + cur_offset,
6550                depth,
6551            )?;
6552
6553            _prev_end_offset = cur_offset + envelope_size;
6554            if 2 > max_ordinal {
6555                return Ok(());
6556            }
6557
6558            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6559            // are envelope_size bytes.
6560            let cur_offset: usize = (2 - 1) * envelope_size;
6561
6562            // Zero reserved fields.
6563            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6564
6565            // Safety:
6566            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6567            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6568            //   envelope_size bytes, there is always sufficient room.
6569            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
6570            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
6571            encoder, offset + cur_offset, depth
6572        )?;
6573
6574            _prev_end_offset = cur_offset + envelope_size;
6575
6576            Ok(())
6577        }
6578    }
6579
6580    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Environment {
6581        #[inline(always)]
6582        fn new_empty() -> Self {
6583            Self::default()
6584        }
6585
6586        unsafe fn decode(
6587            &mut self,
6588            decoder: &mut fidl::encoding::Decoder<'_, D>,
6589            offset: usize,
6590            mut depth: fidl::encoding::Depth,
6591        ) -> fidl::Result<()> {
6592            decoder.debug_check_bounds::<Self>(offset);
6593            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6594                None => return Err(fidl::Error::NotNullable),
6595                Some(len) => len,
6596            };
6597            // Calling decoder.out_of_line_offset(0) is not allowed.
6598            if len == 0 {
6599                return Ok(());
6600            };
6601            depth.increment()?;
6602            let envelope_size = 8;
6603            let bytes_len = len * envelope_size;
6604            let offset = decoder.out_of_line_offset(bytes_len)?;
6605            // Decode the envelope for each type.
6606            let mut _next_ordinal_to_read = 0;
6607            let mut next_offset = offset;
6608            let end_offset = offset + bytes_len;
6609            _next_ordinal_to_read += 1;
6610            if next_offset >= end_offset {
6611                return Ok(());
6612            }
6613
6614            // Decode unknown envelopes for gaps in ordinals.
6615            while _next_ordinal_to_read < 1 {
6616                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6617                _next_ordinal_to_read += 1;
6618                next_offset += envelope_size;
6619            }
6620
6621            let next_out_of_line = decoder.next_out_of_line();
6622            let handles_before = decoder.remaining_handles();
6623            if let Some((inlined, num_bytes, num_handles)) =
6624                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6625            {
6626                let member_inline_size =
6627                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
6628                        decoder.context,
6629                    );
6630                if inlined != (member_inline_size <= 4) {
6631                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6632                }
6633                let inner_offset;
6634                let mut inner_depth = depth.clone();
6635                if inlined {
6636                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6637                    inner_offset = next_offset;
6638                } else {
6639                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6640                    inner_depth.increment()?;
6641                }
6642                let val_ref =
6643                    self.capability.get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
6644                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
6645                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6646                {
6647                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6648                }
6649                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6650                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6651                }
6652            }
6653
6654            next_offset += envelope_size;
6655            _next_ordinal_to_read += 1;
6656            if next_offset >= end_offset {
6657                return Ok(());
6658            }
6659
6660            // Decode unknown envelopes for gaps in ordinals.
6661            while _next_ordinal_to_read < 2 {
6662                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6663                _next_ordinal_to_read += 1;
6664                next_offset += envelope_size;
6665            }
6666
6667            let next_out_of_line = decoder.next_out_of_line();
6668            let handles_before = decoder.remaining_handles();
6669            if let Some((inlined, num_bytes, num_handles)) =
6670                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6671            {
6672                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6673                if inlined != (member_inline_size <= 4) {
6674                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6675                }
6676                let inner_offset;
6677                let mut inner_depth = depth.clone();
6678                if inlined {
6679                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6680                    inner_offset = next_offset;
6681                } else {
6682                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6683                    inner_depth.increment()?;
6684                }
6685                let val_ref = self.moniker.get_or_insert_with(|| {
6686                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
6687                });
6688                fidl::decode!(
6689                    fidl::encoding::BoundedString<4096>,
6690                    D,
6691                    val_ref,
6692                    decoder,
6693                    inner_offset,
6694                    inner_depth
6695                )?;
6696                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6697                {
6698                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6699                }
6700                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6701                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6702                }
6703            }
6704
6705            next_offset += envelope_size;
6706
6707            // Decode the remaining unknown envelopes.
6708            while next_offset < end_offset {
6709                _next_ordinal_to_read += 1;
6710                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6711                next_offset += envelope_size;
6712            }
6713
6714            Ok(())
6715        }
6716    }
6717
6718    impl EnvironmentSource {
6719        #[inline(always)]
6720        fn max_ordinal_present(&self) -> u64 {
6721            if let Some(_) = self.source {
6722                return 2;
6723            }
6724            if let Some(_) = self.source_name {
6725                return 1;
6726            }
6727            0
6728        }
6729    }
6730
6731    impl fidl::encoding::ValueTypeMarker for EnvironmentSource {
6732        type Borrowed<'a> = &'a Self;
6733        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6734            value
6735        }
6736    }
6737
6738    unsafe impl fidl::encoding::TypeMarker for EnvironmentSource {
6739        type Owned = Self;
6740
6741        #[inline(always)]
6742        fn inline_align(_context: fidl::encoding::Context) -> usize {
6743            8
6744        }
6745
6746        #[inline(always)]
6747        fn inline_size(_context: fidl::encoding::Context) -> usize {
6748            16
6749        }
6750    }
6751
6752    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnvironmentSource, D>
6753        for &EnvironmentSource
6754    {
6755        unsafe fn encode(
6756            self,
6757            encoder: &mut fidl::encoding::Encoder<'_, D>,
6758            offset: usize,
6759            mut depth: fidl::encoding::Depth,
6760        ) -> fidl::Result<()> {
6761            encoder.debug_check_bounds::<EnvironmentSource>(offset);
6762            // Vector header
6763            let max_ordinal: u64 = self.max_ordinal_present();
6764            encoder.write_num(max_ordinal, offset);
6765            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6766            // Calling encoder.out_of_line_offset(0) is not allowed.
6767            if max_ordinal == 0 {
6768                return Ok(());
6769            }
6770            depth.increment()?;
6771            let envelope_size = 8;
6772            let bytes_len = max_ordinal as usize * envelope_size;
6773            #[allow(unused_variables)]
6774            let offset = encoder.out_of_line_offset(bytes_len);
6775            let mut _prev_end_offset: usize = 0;
6776            if 1 > max_ordinal {
6777                return Ok(());
6778            }
6779
6780            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6781            // are envelope_size bytes.
6782            let cur_offset: usize = (1 - 1) * envelope_size;
6783
6784            // Zero reserved fields.
6785            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6786
6787            // Safety:
6788            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6789            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6790            //   envelope_size bytes, there is always sufficient room.
6791            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
6792            self.source_name.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
6793            encoder, offset + cur_offset, depth
6794        )?;
6795
6796            _prev_end_offset = cur_offset + envelope_size;
6797            if 2 > max_ordinal {
6798                return Ok(());
6799            }
6800
6801            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6802            // are envelope_size bytes.
6803            let cur_offset: usize = (2 - 1) * envelope_size;
6804
6805            // Zero reserved fields.
6806            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6807
6808            // Safety:
6809            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6810            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6811            //   envelope_size bytes, there is always sufficient room.
6812            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::Ref, D>(
6813            self.source.as_ref().map(<fidl_fuchsia_component_decl__common::Ref as fidl::encoding::ValueTypeMarker>::borrow),
6814            encoder, offset + cur_offset, depth
6815        )?;
6816
6817            _prev_end_offset = cur_offset + envelope_size;
6818
6819            Ok(())
6820        }
6821    }
6822
6823    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnvironmentSource {
6824        #[inline(always)]
6825        fn new_empty() -> Self {
6826            Self::default()
6827        }
6828
6829        unsafe fn decode(
6830            &mut self,
6831            decoder: &mut fidl::encoding::Decoder<'_, D>,
6832            offset: usize,
6833            mut depth: fidl::encoding::Depth,
6834        ) -> fidl::Result<()> {
6835            decoder.debug_check_bounds::<Self>(offset);
6836            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6837                None => return Err(fidl::Error::NotNullable),
6838                Some(len) => len,
6839            };
6840            // Calling decoder.out_of_line_offset(0) is not allowed.
6841            if len == 0 {
6842                return Ok(());
6843            };
6844            depth.increment()?;
6845            let envelope_size = 8;
6846            let bytes_len = len * envelope_size;
6847            let offset = decoder.out_of_line_offset(bytes_len)?;
6848            // Decode the envelope for each type.
6849            let mut _next_ordinal_to_read = 0;
6850            let mut next_offset = offset;
6851            let end_offset = offset + bytes_len;
6852            _next_ordinal_to_read += 1;
6853            if next_offset >= end_offset {
6854                return Ok(());
6855            }
6856
6857            // Decode unknown envelopes for gaps in ordinals.
6858            while _next_ordinal_to_read < 1 {
6859                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6860                _next_ordinal_to_read += 1;
6861                next_offset += envelope_size;
6862            }
6863
6864            let next_out_of_line = decoder.next_out_of_line();
6865            let handles_before = decoder.remaining_handles();
6866            if let Some((inlined, num_bytes, num_handles)) =
6867                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6868            {
6869                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6870                if inlined != (member_inline_size <= 4) {
6871                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6872                }
6873                let inner_offset;
6874                let mut inner_depth = depth.clone();
6875                if inlined {
6876                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6877                    inner_offset = next_offset;
6878                } else {
6879                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6880                    inner_depth.increment()?;
6881                }
6882                let val_ref = self.source_name.get_or_insert_with(|| {
6883                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
6884                });
6885                fidl::decode!(
6886                    fidl::encoding::BoundedString<1024>,
6887                    D,
6888                    val_ref,
6889                    decoder,
6890                    inner_offset,
6891                    inner_depth
6892                )?;
6893                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6894                {
6895                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6896                }
6897                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6898                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6899                }
6900            }
6901
6902            next_offset += envelope_size;
6903            _next_ordinal_to_read += 1;
6904            if next_offset >= end_offset {
6905                return Ok(());
6906            }
6907
6908            // Decode unknown envelopes for gaps in ordinals.
6909            while _next_ordinal_to_read < 2 {
6910                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6911                _next_ordinal_to_read += 1;
6912                next_offset += envelope_size;
6913            }
6914
6915            let next_out_of_line = decoder.next_out_of_line();
6916            let handles_before = decoder.remaining_handles();
6917            if let Some((inlined, num_bytes, num_handles)) =
6918                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6919            {
6920                let member_inline_size = <fidl_fuchsia_component_decl__common::Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6921                if inlined != (member_inline_size <= 4) {
6922                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6923                }
6924                let inner_offset;
6925                let mut inner_depth = depth.clone();
6926                if inlined {
6927                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6928                    inner_offset = next_offset;
6929                } else {
6930                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6931                    inner_depth.increment()?;
6932                }
6933                let val_ref = self.source.get_or_insert_with(|| {
6934                    fidl::new_empty!(fidl_fuchsia_component_decl__common::Ref, D)
6935                });
6936                fidl::decode!(
6937                    fidl_fuchsia_component_decl__common::Ref,
6938                    D,
6939                    val_ref,
6940                    decoder,
6941                    inner_offset,
6942                    inner_depth
6943                )?;
6944                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6945                {
6946                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6947                }
6948                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6949                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6950                }
6951            }
6952
6953            next_offset += envelope_size;
6954
6955            // Decode the remaining unknown envelopes.
6956            while next_offset < end_offset {
6957                _next_ordinal_to_read += 1;
6958                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6959                next_offset += envelope_size;
6960            }
6961
6962            Ok(())
6963        }
6964    }
6965
6966    impl EventStreamRouteMetadata {
6967        #[inline(always)]
6968        fn max_ordinal_present(&self) -> u64 {
6969            if let Some(_) = self.scope {
6970                return 2;
6971            }
6972            if let Some(_) = self.scope_moniker {
6973                return 1;
6974            }
6975            0
6976        }
6977    }
6978
6979    impl fidl::encoding::ValueTypeMarker for EventStreamRouteMetadata {
6980        type Borrowed<'a> = &'a Self;
6981        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6982            value
6983        }
6984    }
6985
6986    unsafe impl fidl::encoding::TypeMarker for EventStreamRouteMetadata {
6987        type Owned = Self;
6988
6989        #[inline(always)]
6990        fn inline_align(_context: fidl::encoding::Context) -> usize {
6991            8
6992        }
6993
6994        #[inline(always)]
6995        fn inline_size(_context: fidl::encoding::Context) -> usize {
6996            16
6997        }
6998    }
6999
7000    unsafe impl<D: fidl::encoding::ResourceDialect>
7001        fidl::encoding::Encode<EventStreamRouteMetadata, D> for &EventStreamRouteMetadata
7002    {
7003        unsafe fn encode(
7004            self,
7005            encoder: &mut fidl::encoding::Encoder<'_, D>,
7006            offset: usize,
7007            mut depth: fidl::encoding::Depth,
7008        ) -> fidl::Result<()> {
7009            encoder.debug_check_bounds::<EventStreamRouteMetadata>(offset);
7010            // Vector header
7011            let max_ordinal: u64 = self.max_ordinal_present();
7012            encoder.write_num(max_ordinal, offset);
7013            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7014            // Calling encoder.out_of_line_offset(0) is not allowed.
7015            if max_ordinal == 0 {
7016                return Ok(());
7017            }
7018            depth.increment()?;
7019            let envelope_size = 8;
7020            let bytes_len = max_ordinal as usize * envelope_size;
7021            #[allow(unused_variables)]
7022            let offset = encoder.out_of_line_offset(bytes_len);
7023            let mut _prev_end_offset: usize = 0;
7024            if 1 > max_ordinal {
7025                return Ok(());
7026            }
7027
7028            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7029            // are envelope_size bytes.
7030            let cur_offset: usize = (1 - 1) * envelope_size;
7031
7032            // Zero reserved fields.
7033            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7034
7035            // Safety:
7036            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7037            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7038            //   envelope_size bytes, there is always sufficient room.
7039            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
7040            self.scope_moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
7041            encoder, offset + cur_offset, depth
7042        )?;
7043
7044            _prev_end_offset = cur_offset + envelope_size;
7045            if 2 > max_ordinal {
7046                return Ok(());
7047            }
7048
7049            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7050            // are envelope_size bytes.
7051            let cur_offset: usize = (2 - 1) * envelope_size;
7052
7053            // Zero reserved fields.
7054            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7055
7056            // Safety:
7057            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7058            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7059            //   envelope_size bytes, there is always sufficient room.
7060            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>, D>(
7061            self.scope.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref> as fidl::encoding::ValueTypeMarker>::borrow),
7062            encoder, offset + cur_offset, depth
7063        )?;
7064
7065            _prev_end_offset = cur_offset + envelope_size;
7066
7067            Ok(())
7068        }
7069    }
7070
7071    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7072        for EventStreamRouteMetadata
7073    {
7074        #[inline(always)]
7075        fn new_empty() -> Self {
7076            Self::default()
7077        }
7078
7079        unsafe fn decode(
7080            &mut self,
7081            decoder: &mut fidl::encoding::Decoder<'_, D>,
7082            offset: usize,
7083            mut depth: fidl::encoding::Depth,
7084        ) -> fidl::Result<()> {
7085            decoder.debug_check_bounds::<Self>(offset);
7086            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7087                None => return Err(fidl::Error::NotNullable),
7088                Some(len) => len,
7089            };
7090            // Calling decoder.out_of_line_offset(0) is not allowed.
7091            if len == 0 {
7092                return Ok(());
7093            };
7094            depth.increment()?;
7095            let envelope_size = 8;
7096            let bytes_len = len * envelope_size;
7097            let offset = decoder.out_of_line_offset(bytes_len)?;
7098            // Decode the envelope for each type.
7099            let mut _next_ordinal_to_read = 0;
7100            let mut next_offset = offset;
7101            let end_offset = offset + bytes_len;
7102            _next_ordinal_to_read += 1;
7103            if next_offset >= end_offset {
7104                return Ok(());
7105            }
7106
7107            // Decode unknown envelopes for gaps in ordinals.
7108            while _next_ordinal_to_read < 1 {
7109                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7110                _next_ordinal_to_read += 1;
7111                next_offset += envelope_size;
7112            }
7113
7114            let next_out_of_line = decoder.next_out_of_line();
7115            let handles_before = decoder.remaining_handles();
7116            if let Some((inlined, num_bytes, num_handles)) =
7117                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7118            {
7119                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7120                if inlined != (member_inline_size <= 4) {
7121                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7122                }
7123                let inner_offset;
7124                let mut inner_depth = depth.clone();
7125                if inlined {
7126                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7127                    inner_offset = next_offset;
7128                } else {
7129                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7130                    inner_depth.increment()?;
7131                }
7132                let val_ref = self.scope_moniker.get_or_insert_with(|| {
7133                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
7134                });
7135                fidl::decode!(
7136                    fidl::encoding::BoundedString<4096>,
7137                    D,
7138                    val_ref,
7139                    decoder,
7140                    inner_offset,
7141                    inner_depth
7142                )?;
7143                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7144                {
7145                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7146                }
7147                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7148                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7149                }
7150            }
7151
7152            next_offset += envelope_size;
7153            _next_ordinal_to_read += 1;
7154            if next_offset >= end_offset {
7155                return Ok(());
7156            }
7157
7158            // Decode unknown envelopes for gaps in ordinals.
7159            while _next_ordinal_to_read < 2 {
7160                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7161                _next_ordinal_to_read += 1;
7162                next_offset += envelope_size;
7163            }
7164
7165            let next_out_of_line = decoder.next_out_of_line();
7166            let handles_before = decoder.remaining_handles();
7167            if let Some((inlined, num_bytes, num_handles)) =
7168                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7169            {
7170                let member_inline_size = <fidl::encoding::UnboundedVector<
7171                    fidl_fuchsia_component_decl__common::Ref,
7172                > as fidl::encoding::TypeMarker>::inline_size(
7173                    decoder.context
7174                );
7175                if inlined != (member_inline_size <= 4) {
7176                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7177                }
7178                let inner_offset;
7179                let mut inner_depth = depth.clone();
7180                if inlined {
7181                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7182                    inner_offset = next_offset;
7183                } else {
7184                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7185                    inner_depth.increment()?;
7186                }
7187                let val_ref = self.scope.get_or_insert_with(|| {
7188                    fidl::new_empty!(
7189                        fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>,
7190                        D
7191                    )
7192                });
7193                fidl::decode!(
7194                    fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::Ref>,
7195                    D,
7196                    val_ref,
7197                    decoder,
7198                    inner_offset,
7199                    inner_depth
7200                )?;
7201                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7202                {
7203                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7204                }
7205                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7206                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7207                }
7208            }
7209
7210            next_offset += envelope_size;
7211
7212            // Decode the remaining unknown envelopes.
7213            while next_offset < end_offset {
7214                _next_ordinal_to_read += 1;
7215                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7216                next_offset += envelope_size;
7217            }
7218
7219            Ok(())
7220        }
7221    }
7222
7223    impl FilteredAggregateProvider {
7224        #[inline(always)]
7225        fn max_ordinal_present(&self) -> u64 {
7226            if let Some(_) = self.offer_service_decls {
7227                return 3;
7228            }
7229            if let Some(_) = self.moniker {
7230                return 2;
7231            }
7232            if let Some(_) = self.capability {
7233                return 1;
7234            }
7235            0
7236        }
7237    }
7238
7239    impl fidl::encoding::ValueTypeMarker for FilteredAggregateProvider {
7240        type Borrowed<'a> = &'a Self;
7241        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7242            value
7243        }
7244    }
7245
7246    unsafe impl fidl::encoding::TypeMarker for FilteredAggregateProvider {
7247        type Owned = Self;
7248
7249        #[inline(always)]
7250        fn inline_align(_context: fidl::encoding::Context) -> usize {
7251            8
7252        }
7253
7254        #[inline(always)]
7255        fn inline_size(_context: fidl::encoding::Context) -> usize {
7256            16
7257        }
7258    }
7259
7260    unsafe impl<D: fidl::encoding::ResourceDialect>
7261        fidl::encoding::Encode<FilteredAggregateProvider, D> for &FilteredAggregateProvider
7262    {
7263        unsafe fn encode(
7264            self,
7265            encoder: &mut fidl::encoding::Encoder<'_, D>,
7266            offset: usize,
7267            mut depth: fidl::encoding::Depth,
7268        ) -> fidl::Result<()> {
7269            encoder.debug_check_bounds::<FilteredAggregateProvider>(offset);
7270            // Vector header
7271            let max_ordinal: u64 = self.max_ordinal_present();
7272            encoder.write_num(max_ordinal, offset);
7273            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7274            // Calling encoder.out_of_line_offset(0) is not allowed.
7275            if max_ordinal == 0 {
7276                return Ok(());
7277            }
7278            depth.increment()?;
7279            let envelope_size = 8;
7280            let bytes_len = max_ordinal as usize * envelope_size;
7281            #[allow(unused_variables)]
7282            let offset = encoder.out_of_line_offset(bytes_len);
7283            let mut _prev_end_offset: usize = 0;
7284            if 1 > max_ordinal {
7285                return Ok(());
7286            }
7287
7288            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7289            // are envelope_size bytes.
7290            let cur_offset: usize = (1 - 1) * envelope_size;
7291
7292            // Zero reserved fields.
7293            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7294
7295            // Safety:
7296            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7297            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7298            //   envelope_size bytes, there is always sufficient room.
7299            fidl::encoding::encode_in_envelope_optional::<AggregateCapability, D>(
7300                self.capability
7301                    .as_ref()
7302                    .map(<AggregateCapability as fidl::encoding::ValueTypeMarker>::borrow),
7303                encoder,
7304                offset + cur_offset,
7305                depth,
7306            )?;
7307
7308            _prev_end_offset = cur_offset + envelope_size;
7309            if 2 > max_ordinal {
7310                return Ok(());
7311            }
7312
7313            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7314            // are envelope_size bytes.
7315            let cur_offset: usize = (2 - 1) * envelope_size;
7316
7317            // Zero reserved fields.
7318            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7319
7320            // Safety:
7321            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7322            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7323            //   envelope_size bytes, there is always sufficient room.
7324            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
7325            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
7326            encoder, offset + cur_offset, depth
7327        )?;
7328
7329            _prev_end_offset = cur_offset + envelope_size;
7330            if 3 > max_ordinal {
7331                return Ok(());
7332            }
7333
7334            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7335            // are envelope_size bytes.
7336            let cur_offset: usize = (3 - 1) * envelope_size;
7337
7338            // Zero reserved fields.
7339            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7340
7341            // Safety:
7342            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7343            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7344            //   envelope_size bytes, there is always sufficient room.
7345            fidl::encoding::encode_in_envelope_optional::<
7346                fidl::encoding::UnboundedVector<fidl_fuchsia_component_decl__common::OfferService>,
7347                D,
7348            >(
7349                self.offer_service_decls.as_ref().map(
7350                    <fidl::encoding::UnboundedVector<
7351                        fidl_fuchsia_component_decl__common::OfferService,
7352                    > as fidl::encoding::ValueTypeMarker>::borrow,
7353                ),
7354                encoder,
7355                offset + cur_offset,
7356                depth,
7357            )?;
7358
7359            _prev_end_offset = cur_offset + envelope_size;
7360
7361            Ok(())
7362        }
7363    }
7364
7365    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7366        for FilteredAggregateProvider
7367    {
7368        #[inline(always)]
7369        fn new_empty() -> Self {
7370            Self::default()
7371        }
7372
7373        unsafe fn decode(
7374            &mut self,
7375            decoder: &mut fidl::encoding::Decoder<'_, D>,
7376            offset: usize,
7377            mut depth: fidl::encoding::Depth,
7378        ) -> fidl::Result<()> {
7379            decoder.debug_check_bounds::<Self>(offset);
7380            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7381                None => return Err(fidl::Error::NotNullable),
7382                Some(len) => len,
7383            };
7384            // Calling decoder.out_of_line_offset(0) is not allowed.
7385            if len == 0 {
7386                return Ok(());
7387            };
7388            depth.increment()?;
7389            let envelope_size = 8;
7390            let bytes_len = len * envelope_size;
7391            let offset = decoder.out_of_line_offset(bytes_len)?;
7392            // Decode the envelope for each type.
7393            let mut _next_ordinal_to_read = 0;
7394            let mut next_offset = offset;
7395            let end_offset = offset + bytes_len;
7396            _next_ordinal_to_read += 1;
7397            if next_offset >= end_offset {
7398                return Ok(());
7399            }
7400
7401            // Decode unknown envelopes for gaps in ordinals.
7402            while _next_ordinal_to_read < 1 {
7403                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7404                _next_ordinal_to_read += 1;
7405                next_offset += envelope_size;
7406            }
7407
7408            let next_out_of_line = decoder.next_out_of_line();
7409            let handles_before = decoder.remaining_handles();
7410            if let Some((inlined, num_bytes, num_handles)) =
7411                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7412            {
7413                let member_inline_size =
7414                    <AggregateCapability as fidl::encoding::TypeMarker>::inline_size(
7415                        decoder.context,
7416                    );
7417                if inlined != (member_inline_size <= 4) {
7418                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7419                }
7420                let inner_offset;
7421                let mut inner_depth = depth.clone();
7422                if inlined {
7423                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7424                    inner_offset = next_offset;
7425                } else {
7426                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7427                    inner_depth.increment()?;
7428                }
7429                let val_ref =
7430                    self.capability.get_or_insert_with(|| fidl::new_empty!(AggregateCapability, D));
7431                fidl::decode!(AggregateCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
7432                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7433                {
7434                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7435                }
7436                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7437                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7438                }
7439            }
7440
7441            next_offset += envelope_size;
7442            _next_ordinal_to_read += 1;
7443            if next_offset >= end_offset {
7444                return Ok(());
7445            }
7446
7447            // Decode unknown envelopes for gaps in ordinals.
7448            while _next_ordinal_to_read < 2 {
7449                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7450                _next_ordinal_to_read += 1;
7451                next_offset += envelope_size;
7452            }
7453
7454            let next_out_of_line = decoder.next_out_of_line();
7455            let handles_before = decoder.remaining_handles();
7456            if let Some((inlined, num_bytes, num_handles)) =
7457                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7458            {
7459                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7460                if inlined != (member_inline_size <= 4) {
7461                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7462                }
7463                let inner_offset;
7464                let mut inner_depth = depth.clone();
7465                if inlined {
7466                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7467                    inner_offset = next_offset;
7468                } else {
7469                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7470                    inner_depth.increment()?;
7471                }
7472                let val_ref = self.moniker.get_or_insert_with(|| {
7473                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
7474                });
7475                fidl::decode!(
7476                    fidl::encoding::BoundedString<4096>,
7477                    D,
7478                    val_ref,
7479                    decoder,
7480                    inner_offset,
7481                    inner_depth
7482                )?;
7483                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7484                {
7485                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7486                }
7487                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7488                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7489                }
7490            }
7491
7492            next_offset += envelope_size;
7493            _next_ordinal_to_read += 1;
7494            if next_offset >= end_offset {
7495                return Ok(());
7496            }
7497
7498            // Decode unknown envelopes for gaps in ordinals.
7499            while _next_ordinal_to_read < 3 {
7500                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7501                _next_ordinal_to_read += 1;
7502                next_offset += envelope_size;
7503            }
7504
7505            let next_out_of_line = decoder.next_out_of_line();
7506            let handles_before = decoder.remaining_handles();
7507            if let Some((inlined, num_bytes, num_handles)) =
7508                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7509            {
7510                let member_inline_size = <fidl::encoding::UnboundedVector<
7511                    fidl_fuchsia_component_decl__common::OfferService,
7512                > as fidl::encoding::TypeMarker>::inline_size(
7513                    decoder.context
7514                );
7515                if inlined != (member_inline_size <= 4) {
7516                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7517                }
7518                let inner_offset;
7519                let mut inner_depth = depth.clone();
7520                if inlined {
7521                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7522                    inner_offset = next_offset;
7523                } else {
7524                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7525                    inner_depth.increment()?;
7526                }
7527                let val_ref = self.offer_service_decls.get_or_insert_with(|| {
7528                    fidl::new_empty!(
7529                        fidl::encoding::UnboundedVector<
7530                            fidl_fuchsia_component_decl__common::OfferService,
7531                        >,
7532                        D
7533                    )
7534                });
7535                fidl::decode!(
7536                    fidl::encoding::UnboundedVector<
7537                        fidl_fuchsia_component_decl__common::OfferService,
7538                    >,
7539                    D,
7540                    val_ref,
7541                    decoder,
7542                    inner_offset,
7543                    inner_depth
7544                )?;
7545                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7546                {
7547                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7548                }
7549                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7550                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7551                }
7552            }
7553
7554            next_offset += envelope_size;
7555
7556            // Decode the remaining unknown envelopes.
7557            while next_offset < end_offset {
7558                _next_ordinal_to_read += 1;
7559                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7560                next_offset += envelope_size;
7561            }
7562
7563            Ok(())
7564        }
7565    }
7566
7567    impl FilteredProvider {
7568        #[inline(always)]
7569        fn max_ordinal_present(&self) -> u64 {
7570            if let Some(_) = self.offer_service_decl {
7571                return 4;
7572            }
7573            if let Some(_) = self.service_capability {
7574                return 3;
7575            }
7576            if let Some(_) = self.moniker {
7577                return 2;
7578            }
7579            if let Some(_) = self.capability {
7580                return 1;
7581            }
7582            0
7583        }
7584    }
7585
7586    impl fidl::encoding::ValueTypeMarker for FilteredProvider {
7587        type Borrowed<'a> = &'a Self;
7588        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7589            value
7590        }
7591    }
7592
7593    unsafe impl fidl::encoding::TypeMarker for FilteredProvider {
7594        type Owned = Self;
7595
7596        #[inline(always)]
7597        fn inline_align(_context: fidl::encoding::Context) -> usize {
7598            8
7599        }
7600
7601        #[inline(always)]
7602        fn inline_size(_context: fidl::encoding::Context) -> usize {
7603            16
7604        }
7605    }
7606
7607    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FilteredProvider, D>
7608        for &FilteredProvider
7609    {
7610        unsafe fn encode(
7611            self,
7612            encoder: &mut fidl::encoding::Encoder<'_, D>,
7613            offset: usize,
7614            mut depth: fidl::encoding::Depth,
7615        ) -> fidl::Result<()> {
7616            encoder.debug_check_bounds::<FilteredProvider>(offset);
7617            // Vector header
7618            let max_ordinal: u64 = self.max_ordinal_present();
7619            encoder.write_num(max_ordinal, offset);
7620            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7621            // Calling encoder.out_of_line_offset(0) is not allowed.
7622            if max_ordinal == 0 {
7623                return Ok(());
7624            }
7625            depth.increment()?;
7626            let envelope_size = 8;
7627            let bytes_len = max_ordinal as usize * envelope_size;
7628            #[allow(unused_variables)]
7629            let offset = encoder.out_of_line_offset(bytes_len);
7630            let mut _prev_end_offset: usize = 0;
7631            if 1 > max_ordinal {
7632                return Ok(());
7633            }
7634
7635            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7636            // are envelope_size bytes.
7637            let cur_offset: usize = (1 - 1) * envelope_size;
7638
7639            // Zero reserved fields.
7640            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7641
7642            // Safety:
7643            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7644            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7645            //   envelope_size bytes, there is always sufficient room.
7646            fidl::encoding::encode_in_envelope_optional::<AggregateCapability, D>(
7647                self.capability
7648                    .as_ref()
7649                    .map(<AggregateCapability as fidl::encoding::ValueTypeMarker>::borrow),
7650                encoder,
7651                offset + cur_offset,
7652                depth,
7653            )?;
7654
7655            _prev_end_offset = cur_offset + envelope_size;
7656            if 2 > max_ordinal {
7657                return Ok(());
7658            }
7659
7660            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7661            // are envelope_size bytes.
7662            let cur_offset: usize = (2 - 1) * envelope_size;
7663
7664            // Zero reserved fields.
7665            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7666
7667            // Safety:
7668            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7669            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7670            //   envelope_size bytes, there is always sufficient room.
7671            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
7672            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
7673            encoder, offset + cur_offset, depth
7674        )?;
7675
7676            _prev_end_offset = cur_offset + envelope_size;
7677            if 3 > max_ordinal {
7678                return Ok(());
7679            }
7680
7681            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7682            // are envelope_size bytes.
7683            let cur_offset: usize = (3 - 1) * envelope_size;
7684
7685            // Zero reserved fields.
7686            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7687
7688            // Safety:
7689            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7690            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7691            //   envelope_size bytes, there is always sufficient room.
7692            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
7693                self.service_capability
7694                    .as_ref()
7695                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
7696                encoder,
7697                offset + cur_offset,
7698                depth,
7699            )?;
7700
7701            _prev_end_offset = cur_offset + envelope_size;
7702            if 4 > max_ordinal {
7703                return Ok(());
7704            }
7705
7706            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7707            // are envelope_size bytes.
7708            let cur_offset: usize = (4 - 1) * envelope_size;
7709
7710            // Zero reserved fields.
7711            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7712
7713            // Safety:
7714            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7715            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7716            //   envelope_size bytes, there is always sufficient room.
7717            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_component_decl__common::OfferService, D>(
7718            self.offer_service_decl.as_ref().map(<fidl_fuchsia_component_decl__common::OfferService as fidl::encoding::ValueTypeMarker>::borrow),
7719            encoder, offset + cur_offset, depth
7720        )?;
7721
7722            _prev_end_offset = cur_offset + envelope_size;
7723
7724            Ok(())
7725        }
7726    }
7727
7728    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FilteredProvider {
7729        #[inline(always)]
7730        fn new_empty() -> Self {
7731            Self::default()
7732        }
7733
7734        unsafe fn decode(
7735            &mut self,
7736            decoder: &mut fidl::encoding::Decoder<'_, D>,
7737            offset: usize,
7738            mut depth: fidl::encoding::Depth,
7739        ) -> fidl::Result<()> {
7740            decoder.debug_check_bounds::<Self>(offset);
7741            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7742                None => return Err(fidl::Error::NotNullable),
7743                Some(len) => len,
7744            };
7745            // Calling decoder.out_of_line_offset(0) is not allowed.
7746            if len == 0 {
7747                return Ok(());
7748            };
7749            depth.increment()?;
7750            let envelope_size = 8;
7751            let bytes_len = len * envelope_size;
7752            let offset = decoder.out_of_line_offset(bytes_len)?;
7753            // Decode the envelope for each type.
7754            let mut _next_ordinal_to_read = 0;
7755            let mut next_offset = offset;
7756            let end_offset = offset + bytes_len;
7757            _next_ordinal_to_read += 1;
7758            if next_offset >= end_offset {
7759                return Ok(());
7760            }
7761
7762            // Decode unknown envelopes for gaps in ordinals.
7763            while _next_ordinal_to_read < 1 {
7764                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7765                _next_ordinal_to_read += 1;
7766                next_offset += envelope_size;
7767            }
7768
7769            let next_out_of_line = decoder.next_out_of_line();
7770            let handles_before = decoder.remaining_handles();
7771            if let Some((inlined, num_bytes, num_handles)) =
7772                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7773            {
7774                let member_inline_size =
7775                    <AggregateCapability as fidl::encoding::TypeMarker>::inline_size(
7776                        decoder.context,
7777                    );
7778                if inlined != (member_inline_size <= 4) {
7779                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7780                }
7781                let inner_offset;
7782                let mut inner_depth = depth.clone();
7783                if inlined {
7784                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7785                    inner_offset = next_offset;
7786                } else {
7787                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7788                    inner_depth.increment()?;
7789                }
7790                let val_ref =
7791                    self.capability.get_or_insert_with(|| fidl::new_empty!(AggregateCapability, D));
7792                fidl::decode!(AggregateCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
7793                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7794                {
7795                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7796                }
7797                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7798                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7799                }
7800            }
7801
7802            next_offset += envelope_size;
7803            _next_ordinal_to_read += 1;
7804            if next_offset >= end_offset {
7805                return Ok(());
7806            }
7807
7808            // Decode unknown envelopes for gaps in ordinals.
7809            while _next_ordinal_to_read < 2 {
7810                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7811                _next_ordinal_to_read += 1;
7812                next_offset += envelope_size;
7813            }
7814
7815            let next_out_of_line = decoder.next_out_of_line();
7816            let handles_before = decoder.remaining_handles();
7817            if let Some((inlined, num_bytes, num_handles)) =
7818                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7819            {
7820                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7821                if inlined != (member_inline_size <= 4) {
7822                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7823                }
7824                let inner_offset;
7825                let mut inner_depth = depth.clone();
7826                if inlined {
7827                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7828                    inner_offset = next_offset;
7829                } else {
7830                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7831                    inner_depth.increment()?;
7832                }
7833                let val_ref = self.moniker.get_or_insert_with(|| {
7834                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
7835                });
7836                fidl::decode!(
7837                    fidl::encoding::BoundedString<4096>,
7838                    D,
7839                    val_ref,
7840                    decoder,
7841                    inner_offset,
7842                    inner_depth
7843                )?;
7844                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7845                {
7846                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7847                }
7848                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7849                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7850                }
7851            }
7852
7853            next_offset += envelope_size;
7854            _next_ordinal_to_read += 1;
7855            if next_offset >= end_offset {
7856                return Ok(());
7857            }
7858
7859            // Decode unknown envelopes for gaps in ordinals.
7860            while _next_ordinal_to_read < 3 {
7861                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7862                _next_ordinal_to_read += 1;
7863                next_offset += envelope_size;
7864            }
7865
7866            let next_out_of_line = decoder.next_out_of_line();
7867            let handles_before = decoder.remaining_handles();
7868            if let Some((inlined, num_bytes, num_handles)) =
7869                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7870            {
7871                let member_inline_size =
7872                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
7873                        decoder.context,
7874                    );
7875                if inlined != (member_inline_size <= 4) {
7876                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7877                }
7878                let inner_offset;
7879                let mut inner_depth = depth.clone();
7880                if inlined {
7881                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7882                    inner_offset = next_offset;
7883                } else {
7884                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7885                    inner_depth.increment()?;
7886                }
7887                let val_ref = self
7888                    .service_capability
7889                    .get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
7890                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
7891                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7892                {
7893                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7894                }
7895                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7896                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7897                }
7898            }
7899
7900            next_offset += envelope_size;
7901            _next_ordinal_to_read += 1;
7902            if next_offset >= end_offset {
7903                return Ok(());
7904            }
7905
7906            // Decode unknown envelopes for gaps in ordinals.
7907            while _next_ordinal_to_read < 4 {
7908                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7909                _next_ordinal_to_read += 1;
7910                next_offset += envelope_size;
7911            }
7912
7913            let next_out_of_line = decoder.next_out_of_line();
7914            let handles_before = decoder.remaining_handles();
7915            if let Some((inlined, num_bytes, num_handles)) =
7916                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7917            {
7918                let member_inline_size = <fidl_fuchsia_component_decl__common::OfferService as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7919                if inlined != (member_inline_size <= 4) {
7920                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7921                }
7922                let inner_offset;
7923                let mut inner_depth = depth.clone();
7924                if inlined {
7925                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7926                    inner_offset = next_offset;
7927                } else {
7928                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7929                    inner_depth.increment()?;
7930                }
7931                let val_ref = self.offer_service_decl.get_or_insert_with(|| {
7932                    fidl::new_empty!(fidl_fuchsia_component_decl__common::OfferService, D)
7933                });
7934                fidl::decode!(
7935                    fidl_fuchsia_component_decl__common::OfferService,
7936                    D,
7937                    val_ref,
7938                    decoder,
7939                    inner_offset,
7940                    inner_depth
7941                )?;
7942                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7943                {
7944                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7945                }
7946                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7947                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7948                }
7949            }
7950
7951            next_offset += envelope_size;
7952
7953            // Decode the remaining unknown envelopes.
7954            while next_offset < end_offset {
7955                _next_ordinal_to_read += 1;
7956                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7957                next_offset += envelope_size;
7958            }
7959
7960            Ok(())
7961        }
7962    }
7963
7964    impl Framework {
7965        #[inline(always)]
7966        fn max_ordinal_present(&self) -> u64 {
7967            if let Some(_) = self.moniker {
7968                return 2;
7969            }
7970            if let Some(_) = self.capability {
7971                return 1;
7972            }
7973            0
7974        }
7975    }
7976
7977    impl fidl::encoding::ValueTypeMarker for Framework {
7978        type Borrowed<'a> = &'a Self;
7979        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7980            value
7981        }
7982    }
7983
7984    unsafe impl fidl::encoding::TypeMarker for Framework {
7985        type Owned = Self;
7986
7987        #[inline(always)]
7988        fn inline_align(_context: fidl::encoding::Context) -> usize {
7989            8
7990        }
7991
7992        #[inline(always)]
7993        fn inline_size(_context: fidl::encoding::Context) -> usize {
7994            16
7995        }
7996    }
7997
7998    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Framework, D>
7999        for &Framework
8000    {
8001        unsafe fn encode(
8002            self,
8003            encoder: &mut fidl::encoding::Encoder<'_, D>,
8004            offset: usize,
8005            mut depth: fidl::encoding::Depth,
8006        ) -> fidl::Result<()> {
8007            encoder.debug_check_bounds::<Framework>(offset);
8008            // Vector header
8009            let max_ordinal: u64 = self.max_ordinal_present();
8010            encoder.write_num(max_ordinal, offset);
8011            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8012            // Calling encoder.out_of_line_offset(0) is not allowed.
8013            if max_ordinal == 0 {
8014                return Ok(());
8015            }
8016            depth.increment()?;
8017            let envelope_size = 8;
8018            let bytes_len = max_ordinal as usize * envelope_size;
8019            #[allow(unused_variables)]
8020            let offset = encoder.out_of_line_offset(bytes_len);
8021            let mut _prev_end_offset: usize = 0;
8022            if 1 > max_ordinal {
8023                return Ok(());
8024            }
8025
8026            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8027            // are envelope_size bytes.
8028            let cur_offset: usize = (1 - 1) * envelope_size;
8029
8030            // Zero reserved fields.
8031            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8032
8033            // Safety:
8034            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8035            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8036            //   envelope_size bytes, there is always sufficient room.
8037            fidl::encoding::encode_in_envelope_optional::<InternalCapability, D>(
8038                self.capability
8039                    .as_ref()
8040                    .map(<InternalCapability as fidl::encoding::ValueTypeMarker>::borrow),
8041                encoder,
8042                offset + cur_offset,
8043                depth,
8044            )?;
8045
8046            _prev_end_offset = cur_offset + envelope_size;
8047            if 2 > max_ordinal {
8048                return Ok(());
8049            }
8050
8051            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8052            // are envelope_size bytes.
8053            let cur_offset: usize = (2 - 1) * envelope_size;
8054
8055            // Zero reserved fields.
8056            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8057
8058            // Safety:
8059            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8060            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8061            //   envelope_size bytes, there is always sufficient room.
8062            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
8063            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
8064            encoder, offset + cur_offset, depth
8065        )?;
8066
8067            _prev_end_offset = cur_offset + envelope_size;
8068
8069            Ok(())
8070        }
8071    }
8072
8073    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Framework {
8074        #[inline(always)]
8075        fn new_empty() -> Self {
8076            Self::default()
8077        }
8078
8079        unsafe fn decode(
8080            &mut self,
8081            decoder: &mut fidl::encoding::Decoder<'_, D>,
8082            offset: usize,
8083            mut depth: fidl::encoding::Depth,
8084        ) -> fidl::Result<()> {
8085            decoder.debug_check_bounds::<Self>(offset);
8086            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8087                None => return Err(fidl::Error::NotNullable),
8088                Some(len) => len,
8089            };
8090            // Calling decoder.out_of_line_offset(0) is not allowed.
8091            if len == 0 {
8092                return Ok(());
8093            };
8094            depth.increment()?;
8095            let envelope_size = 8;
8096            let bytes_len = len * envelope_size;
8097            let offset = decoder.out_of_line_offset(bytes_len)?;
8098            // Decode the envelope for each type.
8099            let mut _next_ordinal_to_read = 0;
8100            let mut next_offset = offset;
8101            let end_offset = offset + bytes_len;
8102            _next_ordinal_to_read += 1;
8103            if next_offset >= end_offset {
8104                return Ok(());
8105            }
8106
8107            // Decode unknown envelopes for gaps in ordinals.
8108            while _next_ordinal_to_read < 1 {
8109                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8110                _next_ordinal_to_read += 1;
8111                next_offset += envelope_size;
8112            }
8113
8114            let next_out_of_line = decoder.next_out_of_line();
8115            let handles_before = decoder.remaining_handles();
8116            if let Some((inlined, num_bytes, num_handles)) =
8117                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8118            {
8119                let member_inline_size =
8120                    <InternalCapability as fidl::encoding::TypeMarker>::inline_size(
8121                        decoder.context,
8122                    );
8123                if inlined != (member_inline_size <= 4) {
8124                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8125                }
8126                let inner_offset;
8127                let mut inner_depth = depth.clone();
8128                if inlined {
8129                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8130                    inner_offset = next_offset;
8131                } else {
8132                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8133                    inner_depth.increment()?;
8134                }
8135                let val_ref =
8136                    self.capability.get_or_insert_with(|| fidl::new_empty!(InternalCapability, D));
8137                fidl::decode!(InternalCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
8138                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8139                {
8140                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8141                }
8142                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8143                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8144                }
8145            }
8146
8147            next_offset += envelope_size;
8148            _next_ordinal_to_read += 1;
8149            if next_offset >= end_offset {
8150                return Ok(());
8151            }
8152
8153            // Decode unknown envelopes for gaps in ordinals.
8154            while _next_ordinal_to_read < 2 {
8155                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8156                _next_ordinal_to_read += 1;
8157                next_offset += envelope_size;
8158            }
8159
8160            let next_out_of_line = decoder.next_out_of_line();
8161            let handles_before = decoder.remaining_handles();
8162            if let Some((inlined, num_bytes, num_handles)) =
8163                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8164            {
8165                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8166                if inlined != (member_inline_size <= 4) {
8167                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8168                }
8169                let inner_offset;
8170                let mut inner_depth = depth.clone();
8171                if inlined {
8172                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8173                    inner_offset = next_offset;
8174                } else {
8175                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8176                    inner_depth.increment()?;
8177                }
8178                let val_ref = self.moniker.get_or_insert_with(|| {
8179                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
8180                });
8181                fidl::decode!(
8182                    fidl::encoding::BoundedString<4096>,
8183                    D,
8184                    val_ref,
8185                    decoder,
8186                    inner_offset,
8187                    inner_depth
8188                )?;
8189                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8190                {
8191                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8192                }
8193                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8194                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8195                }
8196            }
8197
8198            next_offset += envelope_size;
8199
8200            // Decode the remaining unknown envelopes.
8201            while next_offset < end_offset {
8202                _next_ordinal_to_read += 1;
8203                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8204                next_offset += envelope_size;
8205            }
8206
8207            Ok(())
8208        }
8209    }
8210
8211    impl HealthCheck {
8212        #[inline(always)]
8213        fn max_ordinal_present(&self) -> u64 {
8214            if let Some(_) = self.monikers {
8215                return 1;
8216            }
8217            0
8218        }
8219    }
8220
8221    impl fidl::encoding::ValueTypeMarker for HealthCheck {
8222        type Borrowed<'a> = &'a Self;
8223        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8224            value
8225        }
8226    }
8227
8228    unsafe impl fidl::encoding::TypeMarker for HealthCheck {
8229        type Owned = Self;
8230
8231        #[inline(always)]
8232        fn inline_align(_context: fidl::encoding::Context) -> usize {
8233            8
8234        }
8235
8236        #[inline(always)]
8237        fn inline_size(_context: fidl::encoding::Context) -> usize {
8238            16
8239        }
8240    }
8241
8242    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HealthCheck, D>
8243        for &HealthCheck
8244    {
8245        unsafe fn encode(
8246            self,
8247            encoder: &mut fidl::encoding::Encoder<'_, D>,
8248            offset: usize,
8249            mut depth: fidl::encoding::Depth,
8250        ) -> fidl::Result<()> {
8251            encoder.debug_check_bounds::<HealthCheck>(offset);
8252            // Vector header
8253            let max_ordinal: u64 = self.max_ordinal_present();
8254            encoder.write_num(max_ordinal, offset);
8255            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8256            // Calling encoder.out_of_line_offset(0) is not allowed.
8257            if max_ordinal == 0 {
8258                return Ok(());
8259            }
8260            depth.increment()?;
8261            let envelope_size = 8;
8262            let bytes_len = max_ordinal as usize * envelope_size;
8263            #[allow(unused_variables)]
8264            let offset = encoder.out_of_line_offset(bytes_len);
8265            let mut _prev_end_offset: usize = 0;
8266            if 1 > max_ordinal {
8267                return Ok(());
8268            }
8269
8270            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8271            // are envelope_size bytes.
8272            let cur_offset: usize = (1 - 1) * envelope_size;
8273
8274            // Zero reserved fields.
8275            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8276
8277            // Safety:
8278            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8279            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8280            //   envelope_size bytes, there is always sufficient room.
8281            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>>, D>(
8282            self.monikers.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>> as fidl::encoding::ValueTypeMarker>::borrow),
8283            encoder, offset + cur_offset, depth
8284        )?;
8285
8286            _prev_end_offset = cur_offset + envelope_size;
8287
8288            Ok(())
8289        }
8290    }
8291
8292    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HealthCheck {
8293        #[inline(always)]
8294        fn new_empty() -> Self {
8295            Self::default()
8296        }
8297
8298        unsafe fn decode(
8299            &mut self,
8300            decoder: &mut fidl::encoding::Decoder<'_, D>,
8301            offset: usize,
8302            mut depth: fidl::encoding::Depth,
8303        ) -> fidl::Result<()> {
8304            decoder.debug_check_bounds::<Self>(offset);
8305            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8306                None => return Err(fidl::Error::NotNullable),
8307                Some(len) => len,
8308            };
8309            // Calling decoder.out_of_line_offset(0) is not allowed.
8310            if len == 0 {
8311                return Ok(());
8312            };
8313            depth.increment()?;
8314            let envelope_size = 8;
8315            let bytes_len = len * envelope_size;
8316            let offset = decoder.out_of_line_offset(bytes_len)?;
8317            // Decode the envelope for each type.
8318            let mut _next_ordinal_to_read = 0;
8319            let mut next_offset = offset;
8320            let end_offset = offset + bytes_len;
8321            _next_ordinal_to_read += 1;
8322            if next_offset >= end_offset {
8323                return Ok(());
8324            }
8325
8326            // Decode unknown envelopes for gaps in ordinals.
8327            while _next_ordinal_to_read < 1 {
8328                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8329                _next_ordinal_to_read += 1;
8330                next_offset += envelope_size;
8331            }
8332
8333            let next_out_of_line = decoder.next_out_of_line();
8334            let handles_before = decoder.remaining_handles();
8335            if let Some((inlined, num_bytes, num_handles)) =
8336                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8337            {
8338                let member_inline_size = <fidl::encoding::UnboundedVector<
8339                    fidl::encoding::BoundedString<255>,
8340                > as fidl::encoding::TypeMarker>::inline_size(
8341                    decoder.context
8342                );
8343                if inlined != (member_inline_size <= 4) {
8344                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8345                }
8346                let inner_offset;
8347                let mut inner_depth = depth.clone();
8348                if inlined {
8349                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8350                    inner_offset = next_offset;
8351                } else {
8352                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8353                    inner_depth.increment()?;
8354                }
8355                let val_ref = self.monikers.get_or_insert_with(|| {
8356                    fidl::new_empty!(
8357                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>>,
8358                        D
8359                    )
8360                });
8361                fidl::decode!(
8362                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<255>>,
8363                    D,
8364                    val_ref,
8365                    decoder,
8366                    inner_offset,
8367                    inner_depth
8368                )?;
8369                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8370                {
8371                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8372                }
8373                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8374                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8375                }
8376            }
8377
8378            next_offset += envelope_size;
8379
8380            // Decode the remaining unknown envelopes.
8381            while next_offset < end_offset {
8382                _next_ordinal_to_read += 1;
8383                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8384                next_offset += envelope_size;
8385            }
8386
8387            Ok(())
8388        }
8389    }
8390
8391    impl InjectedCapabilities {
8392        #[inline(always)]
8393        fn max_ordinal_present(&self) -> u64 {
8394            if let Some(_) = self.use_ {
8395                return 2;
8396            }
8397            if let Some(_) = self.components {
8398                return 1;
8399            }
8400            0
8401        }
8402    }
8403
8404    impl fidl::encoding::ValueTypeMarker for InjectedCapabilities {
8405        type Borrowed<'a> = &'a Self;
8406        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8407            value
8408        }
8409    }
8410
8411    unsafe impl fidl::encoding::TypeMarker for InjectedCapabilities {
8412        type Owned = Self;
8413
8414        #[inline(always)]
8415        fn inline_align(_context: fidl::encoding::Context) -> usize {
8416            8
8417        }
8418
8419        #[inline(always)]
8420        fn inline_size(_context: fidl::encoding::Context) -> usize {
8421            16
8422        }
8423    }
8424
8425    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InjectedCapabilities, D>
8426        for &InjectedCapabilities
8427    {
8428        unsafe fn encode(
8429            self,
8430            encoder: &mut fidl::encoding::Encoder<'_, D>,
8431            offset: usize,
8432            mut depth: fidl::encoding::Depth,
8433        ) -> fidl::Result<()> {
8434            encoder.debug_check_bounds::<InjectedCapabilities>(offset);
8435            // Vector header
8436            let max_ordinal: u64 = self.max_ordinal_present();
8437            encoder.write_num(max_ordinal, offset);
8438            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8439            // Calling encoder.out_of_line_offset(0) is not allowed.
8440            if max_ordinal == 0 {
8441                return Ok(());
8442            }
8443            depth.increment()?;
8444            let envelope_size = 8;
8445            let bytes_len = max_ordinal as usize * envelope_size;
8446            #[allow(unused_variables)]
8447            let offset = encoder.out_of_line_offset(bytes_len);
8448            let mut _prev_end_offset: usize = 0;
8449            if 1 > max_ordinal {
8450                return Ok(());
8451            }
8452
8453            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8454            // are envelope_size bytes.
8455            let cur_offset: usize = (1 - 1) * envelope_size;
8456
8457            // Zero reserved fields.
8458            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8459
8460            // Safety:
8461            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8462            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8463            //   envelope_size bytes, there is always sufficient room.
8464            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
8465            self.components.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
8466            encoder, offset + cur_offset, depth
8467        )?;
8468
8469            _prev_end_offset = cur_offset + envelope_size;
8470            if 2 > max_ordinal {
8471                return Ok(());
8472            }
8473
8474            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8475            // are envelope_size bytes.
8476            let cur_offset: usize = (2 - 1) * envelope_size;
8477
8478            // Zero reserved fields.
8479            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8480
8481            // Safety:
8482            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8483            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8484            //   envelope_size bytes, there is always sufficient room.
8485            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<InjectedUse>, D>(
8486            self.use_.as_ref().map(<fidl::encoding::UnboundedVector<InjectedUse> as fidl::encoding::ValueTypeMarker>::borrow),
8487            encoder, offset + cur_offset, depth
8488        )?;
8489
8490            _prev_end_offset = cur_offset + envelope_size;
8491
8492            Ok(())
8493        }
8494    }
8495
8496    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InjectedCapabilities {
8497        #[inline(always)]
8498        fn new_empty() -> Self {
8499            Self::default()
8500        }
8501
8502        unsafe fn decode(
8503            &mut self,
8504            decoder: &mut fidl::encoding::Decoder<'_, D>,
8505            offset: usize,
8506            mut depth: fidl::encoding::Depth,
8507        ) -> fidl::Result<()> {
8508            decoder.debug_check_bounds::<Self>(offset);
8509            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8510                None => return Err(fidl::Error::NotNullable),
8511                Some(len) => len,
8512            };
8513            // Calling decoder.out_of_line_offset(0) is not allowed.
8514            if len == 0 {
8515                return Ok(());
8516            };
8517            depth.increment()?;
8518            let envelope_size = 8;
8519            let bytes_len = len * envelope_size;
8520            let offset = decoder.out_of_line_offset(bytes_len)?;
8521            // Decode the envelope for each type.
8522            let mut _next_ordinal_to_read = 0;
8523            let mut next_offset = offset;
8524            let end_offset = offset + bytes_len;
8525            _next_ordinal_to_read += 1;
8526            if next_offset >= end_offset {
8527                return Ok(());
8528            }
8529
8530            // Decode unknown envelopes for gaps in ordinals.
8531            while _next_ordinal_to_read < 1 {
8532                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8533                _next_ordinal_to_read += 1;
8534                next_offset += envelope_size;
8535            }
8536
8537            let next_out_of_line = decoder.next_out_of_line();
8538            let handles_before = decoder.remaining_handles();
8539            if let Some((inlined, num_bytes, num_handles)) =
8540                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8541            {
8542                let member_inline_size = <fidl::encoding::Vector<
8543                    fidl::encoding::BoundedString<4096>,
8544                    128,
8545                > as fidl::encoding::TypeMarker>::inline_size(
8546                    decoder.context
8547                );
8548                if inlined != (member_inline_size <= 4) {
8549                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8550                }
8551                let inner_offset;
8552                let mut inner_depth = depth.clone();
8553                if inlined {
8554                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8555                    inner_offset = next_offset;
8556                } else {
8557                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8558                    inner_depth.increment()?;
8559                }
8560                let val_ref = self.components.get_or_insert_with(|| {
8561                    fidl::new_empty!(
8562                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8563                        D
8564                    )
8565                });
8566                fidl::decode!(
8567                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
8568                    D,
8569                    val_ref,
8570                    decoder,
8571                    inner_offset,
8572                    inner_depth
8573                )?;
8574                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8575                {
8576                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8577                }
8578                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8579                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8580                }
8581            }
8582
8583            next_offset += envelope_size;
8584            _next_ordinal_to_read += 1;
8585            if next_offset >= end_offset {
8586                return Ok(());
8587            }
8588
8589            // Decode unknown envelopes for gaps in ordinals.
8590            while _next_ordinal_to_read < 2 {
8591                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8592                _next_ordinal_to_read += 1;
8593                next_offset += envelope_size;
8594            }
8595
8596            let next_out_of_line = decoder.next_out_of_line();
8597            let handles_before = decoder.remaining_handles();
8598            if let Some((inlined, num_bytes, num_handles)) =
8599                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8600            {
8601                let member_inline_size = <fidl::encoding::UnboundedVector<InjectedUse> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8602                if inlined != (member_inline_size <= 4) {
8603                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8604                }
8605                let inner_offset;
8606                let mut inner_depth = depth.clone();
8607                if inlined {
8608                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8609                    inner_offset = next_offset;
8610                } else {
8611                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8612                    inner_depth.increment()?;
8613                }
8614                let val_ref = self.use_.get_or_insert_with(|| {
8615                    fidl::new_empty!(fidl::encoding::UnboundedVector<InjectedUse>, D)
8616                });
8617                fidl::decode!(
8618                    fidl::encoding::UnboundedVector<InjectedUse>,
8619                    D,
8620                    val_ref,
8621                    decoder,
8622                    inner_offset,
8623                    inner_depth
8624                )?;
8625                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8626                {
8627                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8628                }
8629                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8630                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8631                }
8632            }
8633
8634            next_offset += envelope_size;
8635
8636            // Decode the remaining unknown envelopes.
8637            while next_offset < end_offset {
8638                _next_ordinal_to_read += 1;
8639                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8640                next_offset += envelope_size;
8641            }
8642
8643            Ok(())
8644        }
8645    }
8646
8647    impl InjectedUseProtocol {
8648        #[inline(always)]
8649        fn max_ordinal_present(&self) -> u64 {
8650            if let Some(_) = self.target_path {
8651                return 2;
8652            }
8653            if let Some(_) = self.source_name {
8654                return 1;
8655            }
8656            0
8657        }
8658    }
8659
8660    impl fidl::encoding::ValueTypeMarker for InjectedUseProtocol {
8661        type Borrowed<'a> = &'a Self;
8662        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8663            value
8664        }
8665    }
8666
8667    unsafe impl fidl::encoding::TypeMarker for InjectedUseProtocol {
8668        type Owned = Self;
8669
8670        #[inline(always)]
8671        fn inline_align(_context: fidl::encoding::Context) -> usize {
8672            8
8673        }
8674
8675        #[inline(always)]
8676        fn inline_size(_context: fidl::encoding::Context) -> usize {
8677            16
8678        }
8679    }
8680
8681    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InjectedUseProtocol, D>
8682        for &InjectedUseProtocol
8683    {
8684        unsafe fn encode(
8685            self,
8686            encoder: &mut fidl::encoding::Encoder<'_, D>,
8687            offset: usize,
8688            mut depth: fidl::encoding::Depth,
8689        ) -> fidl::Result<()> {
8690            encoder.debug_check_bounds::<InjectedUseProtocol>(offset);
8691            // Vector header
8692            let max_ordinal: u64 = self.max_ordinal_present();
8693            encoder.write_num(max_ordinal, offset);
8694            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8695            // Calling encoder.out_of_line_offset(0) is not allowed.
8696            if max_ordinal == 0 {
8697                return Ok(());
8698            }
8699            depth.increment()?;
8700            let envelope_size = 8;
8701            let bytes_len = max_ordinal as usize * envelope_size;
8702            #[allow(unused_variables)]
8703            let offset = encoder.out_of_line_offset(bytes_len);
8704            let mut _prev_end_offset: usize = 0;
8705            if 1 > max_ordinal {
8706                return Ok(());
8707            }
8708
8709            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8710            // are envelope_size bytes.
8711            let cur_offset: usize = (1 - 1) * envelope_size;
8712
8713            // Zero reserved fields.
8714            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8715
8716            // Safety:
8717            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8718            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8719            //   envelope_size bytes, there is always sufficient room.
8720            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
8721                self.source_name.as_ref().map(
8722                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
8723                ),
8724                encoder,
8725                offset + cur_offset,
8726                depth,
8727            )?;
8728
8729            _prev_end_offset = cur_offset + envelope_size;
8730            if 2 > max_ordinal {
8731                return Ok(());
8732            }
8733
8734            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8735            // are envelope_size bytes.
8736            let cur_offset: usize = (2 - 1) * envelope_size;
8737
8738            // Zero reserved fields.
8739            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8740
8741            // Safety:
8742            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8743            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8744            //   envelope_size bytes, there is always sufficient room.
8745            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
8746            self.target_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
8747            encoder, offset + cur_offset, depth
8748        )?;
8749
8750            _prev_end_offset = cur_offset + envelope_size;
8751
8752            Ok(())
8753        }
8754    }
8755
8756    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InjectedUseProtocol {
8757        #[inline(always)]
8758        fn new_empty() -> Self {
8759            Self::default()
8760        }
8761
8762        unsafe fn decode(
8763            &mut self,
8764            decoder: &mut fidl::encoding::Decoder<'_, D>,
8765            offset: usize,
8766            mut depth: fidl::encoding::Depth,
8767        ) -> fidl::Result<()> {
8768            decoder.debug_check_bounds::<Self>(offset);
8769            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8770                None => return Err(fidl::Error::NotNullable),
8771                Some(len) => len,
8772            };
8773            // Calling decoder.out_of_line_offset(0) is not allowed.
8774            if len == 0 {
8775                return Ok(());
8776            };
8777            depth.increment()?;
8778            let envelope_size = 8;
8779            let bytes_len = len * envelope_size;
8780            let offset = decoder.out_of_line_offset(bytes_len)?;
8781            // Decode the envelope for each type.
8782            let mut _next_ordinal_to_read = 0;
8783            let mut next_offset = offset;
8784            let end_offset = offset + bytes_len;
8785            _next_ordinal_to_read += 1;
8786            if next_offset >= end_offset {
8787                return Ok(());
8788            }
8789
8790            // Decode unknown envelopes for gaps in ordinals.
8791            while _next_ordinal_to_read < 1 {
8792                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8793                _next_ordinal_to_read += 1;
8794                next_offset += envelope_size;
8795            }
8796
8797            let next_out_of_line = decoder.next_out_of_line();
8798            let handles_before = decoder.remaining_handles();
8799            if let Some((inlined, num_bytes, num_handles)) =
8800                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8801            {
8802                let member_inline_size =
8803                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
8804                        decoder.context,
8805                    );
8806                if inlined != (member_inline_size <= 4) {
8807                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8808                }
8809                let inner_offset;
8810                let mut inner_depth = depth.clone();
8811                if inlined {
8812                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8813                    inner_offset = next_offset;
8814                } else {
8815                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8816                    inner_depth.increment()?;
8817                }
8818                let val_ref = self
8819                    .source_name
8820                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
8821                fidl::decode!(
8822                    fidl::encoding::BoundedString<100>,
8823                    D,
8824                    val_ref,
8825                    decoder,
8826                    inner_offset,
8827                    inner_depth
8828                )?;
8829                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8830                {
8831                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8832                }
8833                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8834                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8835                }
8836            }
8837
8838            next_offset += envelope_size;
8839            _next_ordinal_to_read += 1;
8840            if next_offset >= end_offset {
8841                return Ok(());
8842            }
8843
8844            // Decode unknown envelopes for gaps in ordinals.
8845            while _next_ordinal_to_read < 2 {
8846                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8847                _next_ordinal_to_read += 1;
8848                next_offset += envelope_size;
8849            }
8850
8851            let next_out_of_line = decoder.next_out_of_line();
8852            let handles_before = decoder.remaining_handles();
8853            if let Some((inlined, num_bytes, num_handles)) =
8854                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8855            {
8856                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8857                if inlined != (member_inline_size <= 4) {
8858                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8859                }
8860                let inner_offset;
8861                let mut inner_depth = depth.clone();
8862                if inlined {
8863                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8864                    inner_offset = next_offset;
8865                } else {
8866                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8867                    inner_depth.increment()?;
8868                }
8869                let val_ref = self.target_path.get_or_insert_with(|| {
8870                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
8871                });
8872                fidl::decode!(
8873                    fidl::encoding::BoundedString<1024>,
8874                    D,
8875                    val_ref,
8876                    decoder,
8877                    inner_offset,
8878                    inner_depth
8879                )?;
8880                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8881                {
8882                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8883                }
8884                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8885                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8886                }
8887            }
8888
8889            next_offset += envelope_size;
8890
8891            // Decode the remaining unknown envelopes.
8892            while next_offset < end_offset {
8893                _next_ordinal_to_read += 1;
8894                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8895                next_offset += envelope_size;
8896            }
8897
8898            Ok(())
8899        }
8900    }
8901
8902    impl InstanceIdEntry {
8903        #[inline(always)]
8904        fn max_ordinal_present(&self) -> u64 {
8905            if let Some(_) = self.ignore_duplicate_id {
8906                return 4;
8907            }
8908            if let Some(_) = self.moniker {
8909                return 3;
8910            }
8911            if let Some(_) = self.instance_id {
8912                return 1;
8913            }
8914            0
8915        }
8916    }
8917
8918    impl fidl::encoding::ValueTypeMarker for InstanceIdEntry {
8919        type Borrowed<'a> = &'a Self;
8920        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8921            value
8922        }
8923    }
8924
8925    unsafe impl fidl::encoding::TypeMarker for InstanceIdEntry {
8926        type Owned = Self;
8927
8928        #[inline(always)]
8929        fn inline_align(_context: fidl::encoding::Context) -> usize {
8930            8
8931        }
8932
8933        #[inline(always)]
8934        fn inline_size(_context: fidl::encoding::Context) -> usize {
8935            16
8936        }
8937    }
8938
8939    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InstanceIdEntry, D>
8940        for &InstanceIdEntry
8941    {
8942        unsafe fn encode(
8943            self,
8944            encoder: &mut fidl::encoding::Encoder<'_, D>,
8945            offset: usize,
8946            mut depth: fidl::encoding::Depth,
8947        ) -> fidl::Result<()> {
8948            encoder.debug_check_bounds::<InstanceIdEntry>(offset);
8949            // Vector header
8950            let max_ordinal: u64 = self.max_ordinal_present();
8951            encoder.write_num(max_ordinal, offset);
8952            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8953            // Calling encoder.out_of_line_offset(0) is not allowed.
8954            if max_ordinal == 0 {
8955                return Ok(());
8956            }
8957            depth.increment()?;
8958            let envelope_size = 8;
8959            let bytes_len = max_ordinal as usize * envelope_size;
8960            #[allow(unused_variables)]
8961            let offset = encoder.out_of_line_offset(bytes_len);
8962            let mut _prev_end_offset: usize = 0;
8963            if 1 > max_ordinal {
8964                return Ok(());
8965            }
8966
8967            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8968            // are envelope_size bytes.
8969            let cur_offset: usize = (1 - 1) * envelope_size;
8970
8971            // Zero reserved fields.
8972            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8973
8974            // Safety:
8975            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8976            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8977            //   envelope_size bytes, there is always sufficient room.
8978            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
8979                self.instance_id.as_ref().map(
8980                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
8981                ),
8982                encoder,
8983                offset + cur_offset,
8984                depth,
8985            )?;
8986
8987            _prev_end_offset = cur_offset + envelope_size;
8988            if 3 > max_ordinal {
8989                return Ok(());
8990            }
8991
8992            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8993            // are envelope_size bytes.
8994            let cur_offset: usize = (3 - 1) * envelope_size;
8995
8996            // Zero reserved fields.
8997            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8998
8999            // Safety:
9000            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9001            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9002            //   envelope_size bytes, there is always sufficient room.
9003            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
9004            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
9005            encoder, offset + cur_offset, depth
9006        )?;
9007
9008            _prev_end_offset = cur_offset + envelope_size;
9009            if 4 > max_ordinal {
9010                return Ok(());
9011            }
9012
9013            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9014            // are envelope_size bytes.
9015            let cur_offset: usize = (4 - 1) * envelope_size;
9016
9017            // Zero reserved fields.
9018            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9019
9020            // Safety:
9021            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9022            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9023            //   envelope_size bytes, there is always sufficient room.
9024            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9025                self.ignore_duplicate_id
9026                    .as_ref()
9027                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9028                encoder,
9029                offset + cur_offset,
9030                depth,
9031            )?;
9032
9033            _prev_end_offset = cur_offset + envelope_size;
9034
9035            Ok(())
9036        }
9037    }
9038
9039    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InstanceIdEntry {
9040        #[inline(always)]
9041        fn new_empty() -> Self {
9042            Self::default()
9043        }
9044
9045        unsafe fn decode(
9046            &mut self,
9047            decoder: &mut fidl::encoding::Decoder<'_, D>,
9048            offset: usize,
9049            mut depth: fidl::encoding::Depth,
9050        ) -> fidl::Result<()> {
9051            decoder.debug_check_bounds::<Self>(offset);
9052            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9053                None => return Err(fidl::Error::NotNullable),
9054                Some(len) => len,
9055            };
9056            // Calling decoder.out_of_line_offset(0) is not allowed.
9057            if len == 0 {
9058                return Ok(());
9059            };
9060            depth.increment()?;
9061            let envelope_size = 8;
9062            let bytes_len = len * envelope_size;
9063            let offset = decoder.out_of_line_offset(bytes_len)?;
9064            // Decode the envelope for each type.
9065            let mut _next_ordinal_to_read = 0;
9066            let mut next_offset = offset;
9067            let end_offset = offset + bytes_len;
9068            _next_ordinal_to_read += 1;
9069            if next_offset >= end_offset {
9070                return Ok(());
9071            }
9072
9073            // Decode unknown envelopes for gaps in ordinals.
9074            while _next_ordinal_to_read < 1 {
9075                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9076                _next_ordinal_to_read += 1;
9077                next_offset += envelope_size;
9078            }
9079
9080            let next_out_of_line = decoder.next_out_of_line();
9081            let handles_before = decoder.remaining_handles();
9082            if let Some((inlined, num_bytes, num_handles)) =
9083                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9084            {
9085                let member_inline_size =
9086                    <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
9087                        decoder.context,
9088                    );
9089                if inlined != (member_inline_size <= 4) {
9090                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9091                }
9092                let inner_offset;
9093                let mut inner_depth = depth.clone();
9094                if inlined {
9095                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9096                    inner_offset = next_offset;
9097                } else {
9098                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9099                    inner_depth.increment()?;
9100                }
9101                let val_ref = self
9102                    .instance_id
9103                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
9104                fidl::decode!(
9105                    fidl::encoding::BoundedString<64>,
9106                    D,
9107                    val_ref,
9108                    decoder,
9109                    inner_offset,
9110                    inner_depth
9111                )?;
9112                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9113                {
9114                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9115                }
9116                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9117                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9118                }
9119            }
9120
9121            next_offset += envelope_size;
9122            _next_ordinal_to_read += 1;
9123            if next_offset >= end_offset {
9124                return Ok(());
9125            }
9126
9127            // Decode unknown envelopes for gaps in ordinals.
9128            while _next_ordinal_to_read < 3 {
9129                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9130                _next_ordinal_to_read += 1;
9131                next_offset += envelope_size;
9132            }
9133
9134            let next_out_of_line = decoder.next_out_of_line();
9135            let handles_before = decoder.remaining_handles();
9136            if let Some((inlined, num_bytes, num_handles)) =
9137                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9138            {
9139                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9140                if inlined != (member_inline_size <= 4) {
9141                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9142                }
9143                let inner_offset;
9144                let mut inner_depth = depth.clone();
9145                if inlined {
9146                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9147                    inner_offset = next_offset;
9148                } else {
9149                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9150                    inner_depth.increment()?;
9151                }
9152                let val_ref = self.moniker.get_or_insert_with(|| {
9153                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
9154                });
9155                fidl::decode!(
9156                    fidl::encoding::BoundedString<4096>,
9157                    D,
9158                    val_ref,
9159                    decoder,
9160                    inner_offset,
9161                    inner_depth
9162                )?;
9163                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9164                {
9165                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9166                }
9167                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9168                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9169                }
9170            }
9171
9172            next_offset += envelope_size;
9173            _next_ordinal_to_read += 1;
9174            if next_offset >= end_offset {
9175                return Ok(());
9176            }
9177
9178            // Decode unknown envelopes for gaps in ordinals.
9179            while _next_ordinal_to_read < 4 {
9180                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9181                _next_ordinal_to_read += 1;
9182                next_offset += envelope_size;
9183            }
9184
9185            let next_out_of_line = decoder.next_out_of_line();
9186            let handles_before = decoder.remaining_handles();
9187            if let Some((inlined, num_bytes, num_handles)) =
9188                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9189            {
9190                let member_inline_size =
9191                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9192                if inlined != (member_inline_size <= 4) {
9193                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9194                }
9195                let inner_offset;
9196                let mut inner_depth = depth.clone();
9197                if inlined {
9198                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9199                    inner_offset = next_offset;
9200                } else {
9201                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9202                    inner_depth.increment()?;
9203                }
9204                let val_ref =
9205                    self.ignore_duplicate_id.get_or_insert_with(|| fidl::new_empty!(bool, D));
9206                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9207                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9208                {
9209                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9210                }
9211                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9212                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9213                }
9214            }
9215
9216            next_offset += envelope_size;
9217
9218            // Decode the remaining unknown envelopes.
9219            while next_offset < end_offset {
9220                _next_ordinal_to_read += 1;
9221                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9222                next_offset += envelope_size;
9223            }
9224
9225            Ok(())
9226        }
9227    }
9228
9229    impl InternalEventStreamCapability {
9230        #[inline(always)]
9231        fn max_ordinal_present(&self) -> u64 {
9232            if let Some(_) = self.route_metadata {
9233                return 2;
9234            }
9235            if let Some(_) = self.name {
9236                return 1;
9237            }
9238            0
9239        }
9240    }
9241
9242    impl fidl::encoding::ValueTypeMarker for InternalEventStreamCapability {
9243        type Borrowed<'a> = &'a Self;
9244        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9245            value
9246        }
9247    }
9248
9249    unsafe impl fidl::encoding::TypeMarker for InternalEventStreamCapability {
9250        type Owned = Self;
9251
9252        #[inline(always)]
9253        fn inline_align(_context: fidl::encoding::Context) -> usize {
9254            8
9255        }
9256
9257        #[inline(always)]
9258        fn inline_size(_context: fidl::encoding::Context) -> usize {
9259            16
9260        }
9261    }
9262
9263    unsafe impl<D: fidl::encoding::ResourceDialect>
9264        fidl::encoding::Encode<InternalEventStreamCapability, D>
9265        for &InternalEventStreamCapability
9266    {
9267        unsafe fn encode(
9268            self,
9269            encoder: &mut fidl::encoding::Encoder<'_, D>,
9270            offset: usize,
9271            mut depth: fidl::encoding::Depth,
9272        ) -> fidl::Result<()> {
9273            encoder.debug_check_bounds::<InternalEventStreamCapability>(offset);
9274            // Vector header
9275            let max_ordinal: u64 = self.max_ordinal_present();
9276            encoder.write_num(max_ordinal, offset);
9277            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9278            // Calling encoder.out_of_line_offset(0) is not allowed.
9279            if max_ordinal == 0 {
9280                return Ok(());
9281            }
9282            depth.increment()?;
9283            let envelope_size = 8;
9284            let bytes_len = max_ordinal as usize * envelope_size;
9285            #[allow(unused_variables)]
9286            let offset = encoder.out_of_line_offset(bytes_len);
9287            let mut _prev_end_offset: usize = 0;
9288            if 1 > max_ordinal {
9289                return Ok(());
9290            }
9291
9292            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9293            // are envelope_size bytes.
9294            let cur_offset: usize = (1 - 1) * envelope_size;
9295
9296            // Zero reserved fields.
9297            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9298
9299            // Safety:
9300            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9301            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9302            //   envelope_size bytes, there is always sufficient room.
9303            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
9304                self.name.as_ref().map(
9305                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
9306                ),
9307                encoder,
9308                offset + cur_offset,
9309                depth,
9310            )?;
9311
9312            _prev_end_offset = cur_offset + envelope_size;
9313            if 2 > max_ordinal {
9314                return Ok(());
9315            }
9316
9317            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9318            // are envelope_size bytes.
9319            let cur_offset: usize = (2 - 1) * envelope_size;
9320
9321            // Zero reserved fields.
9322            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9323
9324            // Safety:
9325            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9326            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9327            //   envelope_size bytes, there is always sufficient room.
9328            fidl::encoding::encode_in_envelope_optional::<EventStreamRouteMetadata, D>(
9329                self.route_metadata
9330                    .as_ref()
9331                    .map(<EventStreamRouteMetadata as fidl::encoding::ValueTypeMarker>::borrow),
9332                encoder,
9333                offset + cur_offset,
9334                depth,
9335            )?;
9336
9337            _prev_end_offset = cur_offset + envelope_size;
9338
9339            Ok(())
9340        }
9341    }
9342
9343    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9344        for InternalEventStreamCapability
9345    {
9346        #[inline(always)]
9347        fn new_empty() -> Self {
9348            Self::default()
9349        }
9350
9351        unsafe fn decode(
9352            &mut self,
9353            decoder: &mut fidl::encoding::Decoder<'_, D>,
9354            offset: usize,
9355            mut depth: fidl::encoding::Depth,
9356        ) -> fidl::Result<()> {
9357            decoder.debug_check_bounds::<Self>(offset);
9358            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9359                None => return Err(fidl::Error::NotNullable),
9360                Some(len) => len,
9361            };
9362            // Calling decoder.out_of_line_offset(0) is not allowed.
9363            if len == 0 {
9364                return Ok(());
9365            };
9366            depth.increment()?;
9367            let envelope_size = 8;
9368            let bytes_len = len * envelope_size;
9369            let offset = decoder.out_of_line_offset(bytes_len)?;
9370            // Decode the envelope for each type.
9371            let mut _next_ordinal_to_read = 0;
9372            let mut next_offset = offset;
9373            let end_offset = offset + bytes_len;
9374            _next_ordinal_to_read += 1;
9375            if next_offset >= end_offset {
9376                return Ok(());
9377            }
9378
9379            // Decode unknown envelopes for gaps in ordinals.
9380            while _next_ordinal_to_read < 1 {
9381                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9382                _next_ordinal_to_read += 1;
9383                next_offset += envelope_size;
9384            }
9385
9386            let next_out_of_line = decoder.next_out_of_line();
9387            let handles_before = decoder.remaining_handles();
9388            if let Some((inlined, num_bytes, num_handles)) =
9389                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9390            {
9391                let member_inline_size =
9392                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
9393                        decoder.context,
9394                    );
9395                if inlined != (member_inline_size <= 4) {
9396                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9397                }
9398                let inner_offset;
9399                let mut inner_depth = depth.clone();
9400                if inlined {
9401                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9402                    inner_offset = next_offset;
9403                } else {
9404                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9405                    inner_depth.increment()?;
9406                }
9407                let val_ref = self
9408                    .name
9409                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
9410                fidl::decode!(
9411                    fidl::encoding::UnboundedString,
9412                    D,
9413                    val_ref,
9414                    decoder,
9415                    inner_offset,
9416                    inner_depth
9417                )?;
9418                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9419                {
9420                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9421                }
9422                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9423                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9424                }
9425            }
9426
9427            next_offset += envelope_size;
9428            _next_ordinal_to_read += 1;
9429            if next_offset >= end_offset {
9430                return Ok(());
9431            }
9432
9433            // Decode unknown envelopes for gaps in ordinals.
9434            while _next_ordinal_to_read < 2 {
9435                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9436                _next_ordinal_to_read += 1;
9437                next_offset += envelope_size;
9438            }
9439
9440            let next_out_of_line = decoder.next_out_of_line();
9441            let handles_before = decoder.remaining_handles();
9442            if let Some((inlined, num_bytes, num_handles)) =
9443                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9444            {
9445                let member_inline_size =
9446                    <EventStreamRouteMetadata as fidl::encoding::TypeMarker>::inline_size(
9447                        decoder.context,
9448                    );
9449                if inlined != (member_inline_size <= 4) {
9450                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9451                }
9452                let inner_offset;
9453                let mut inner_depth = depth.clone();
9454                if inlined {
9455                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9456                    inner_offset = next_offset;
9457                } else {
9458                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9459                    inner_depth.increment()?;
9460                }
9461                let val_ref = self
9462                    .route_metadata
9463                    .get_or_insert_with(|| fidl::new_empty!(EventStreamRouteMetadata, D));
9464                fidl::decode!(
9465                    EventStreamRouteMetadata,
9466                    D,
9467                    val_ref,
9468                    decoder,
9469                    inner_offset,
9470                    inner_depth
9471                )?;
9472                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9473                {
9474                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9475                }
9476                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9477                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9478                }
9479            }
9480
9481            next_offset += envelope_size;
9482
9483            // Decode the remaining unknown envelopes.
9484            while next_offset < end_offset {
9485                _next_ordinal_to_read += 1;
9486                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9487                next_offset += envelope_size;
9488            }
9489
9490            Ok(())
9491        }
9492    }
9493
9494    impl JobPolicyAllowlists {
9495        #[inline(always)]
9496        fn max_ordinal_present(&self) -> u64 {
9497            if let Some(_) = self.create_raw_processes {
9498                return 3;
9499            }
9500            if let Some(_) = self.main_process_critical {
9501                return 2;
9502            }
9503            if let Some(_) = self.ambient_mark_vmo_exec {
9504                return 1;
9505            }
9506            0
9507        }
9508    }
9509
9510    impl fidl::encoding::ValueTypeMarker for JobPolicyAllowlists {
9511        type Borrowed<'a> = &'a Self;
9512        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9513            value
9514        }
9515    }
9516
9517    unsafe impl fidl::encoding::TypeMarker for JobPolicyAllowlists {
9518        type Owned = Self;
9519
9520        #[inline(always)]
9521        fn inline_align(_context: fidl::encoding::Context) -> usize {
9522            8
9523        }
9524
9525        #[inline(always)]
9526        fn inline_size(_context: fidl::encoding::Context) -> usize {
9527            16
9528        }
9529    }
9530
9531    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<JobPolicyAllowlists, D>
9532        for &JobPolicyAllowlists
9533    {
9534        unsafe fn encode(
9535            self,
9536            encoder: &mut fidl::encoding::Encoder<'_, D>,
9537            offset: usize,
9538            mut depth: fidl::encoding::Depth,
9539        ) -> fidl::Result<()> {
9540            encoder.debug_check_bounds::<JobPolicyAllowlists>(offset);
9541            // Vector header
9542            let max_ordinal: u64 = self.max_ordinal_present();
9543            encoder.write_num(max_ordinal, offset);
9544            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9545            // Calling encoder.out_of_line_offset(0) is not allowed.
9546            if max_ordinal == 0 {
9547                return Ok(());
9548            }
9549            depth.increment()?;
9550            let envelope_size = 8;
9551            let bytes_len = max_ordinal as usize * envelope_size;
9552            #[allow(unused_variables)]
9553            let offset = encoder.out_of_line_offset(bytes_len);
9554            let mut _prev_end_offset: usize = 0;
9555            if 1 > max_ordinal {
9556                return Ok(());
9557            }
9558
9559            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9560            // are envelope_size bytes.
9561            let cur_offset: usize = (1 - 1) * envelope_size;
9562
9563            // Zero reserved fields.
9564            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9565
9566            // Safety:
9567            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9568            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9569            //   envelope_size bytes, there is always sufficient room.
9570            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
9571            self.ambient_mark_vmo_exec.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
9572            encoder, offset + cur_offset, depth
9573        )?;
9574
9575            _prev_end_offset = cur_offset + envelope_size;
9576            if 2 > max_ordinal {
9577                return Ok(());
9578            }
9579
9580            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9581            // are envelope_size bytes.
9582            let cur_offset: usize = (2 - 1) * envelope_size;
9583
9584            // Zero reserved fields.
9585            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9586
9587            // Safety:
9588            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9589            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9590            //   envelope_size bytes, there is always sufficient room.
9591            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
9592            self.main_process_critical.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
9593            encoder, offset + cur_offset, depth
9594        )?;
9595
9596            _prev_end_offset = cur_offset + envelope_size;
9597            if 3 > max_ordinal {
9598                return Ok(());
9599            }
9600
9601            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9602            // are envelope_size bytes.
9603            let cur_offset: usize = (3 - 1) * envelope_size;
9604
9605            // Zero reserved fields.
9606            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9607
9608            // Safety:
9609            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9610            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9611            //   envelope_size bytes, there is always sufficient room.
9612            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>, D>(
9613            self.create_raw_processes.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128> as fidl::encoding::ValueTypeMarker>::borrow),
9614            encoder, offset + cur_offset, depth
9615        )?;
9616
9617            _prev_end_offset = cur_offset + envelope_size;
9618
9619            Ok(())
9620        }
9621    }
9622
9623    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for JobPolicyAllowlists {
9624        #[inline(always)]
9625        fn new_empty() -> Self {
9626            Self::default()
9627        }
9628
9629        unsafe fn decode(
9630            &mut self,
9631            decoder: &mut fidl::encoding::Decoder<'_, D>,
9632            offset: usize,
9633            mut depth: fidl::encoding::Depth,
9634        ) -> fidl::Result<()> {
9635            decoder.debug_check_bounds::<Self>(offset);
9636            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9637                None => return Err(fidl::Error::NotNullable),
9638                Some(len) => len,
9639            };
9640            // Calling decoder.out_of_line_offset(0) is not allowed.
9641            if len == 0 {
9642                return Ok(());
9643            };
9644            depth.increment()?;
9645            let envelope_size = 8;
9646            let bytes_len = len * envelope_size;
9647            let offset = decoder.out_of_line_offset(bytes_len)?;
9648            // Decode the envelope for each type.
9649            let mut _next_ordinal_to_read = 0;
9650            let mut next_offset = offset;
9651            let end_offset = offset + bytes_len;
9652            _next_ordinal_to_read += 1;
9653            if next_offset >= end_offset {
9654                return Ok(());
9655            }
9656
9657            // Decode unknown envelopes for gaps in ordinals.
9658            while _next_ordinal_to_read < 1 {
9659                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9660                _next_ordinal_to_read += 1;
9661                next_offset += envelope_size;
9662            }
9663
9664            let next_out_of_line = decoder.next_out_of_line();
9665            let handles_before = decoder.remaining_handles();
9666            if let Some((inlined, num_bytes, num_handles)) =
9667                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9668            {
9669                let member_inline_size = <fidl::encoding::Vector<
9670                    fidl::encoding::BoundedString<4096>,
9671                    128,
9672                > as fidl::encoding::TypeMarker>::inline_size(
9673                    decoder.context
9674                );
9675                if inlined != (member_inline_size <= 4) {
9676                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9677                }
9678                let inner_offset;
9679                let mut inner_depth = depth.clone();
9680                if inlined {
9681                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9682                    inner_offset = next_offset;
9683                } else {
9684                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9685                    inner_depth.increment()?;
9686                }
9687                let val_ref = self.ambient_mark_vmo_exec.get_or_insert_with(|| {
9688                    fidl::new_empty!(
9689                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
9690                        D
9691                    )
9692                });
9693                fidl::decode!(
9694                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
9695                    D,
9696                    val_ref,
9697                    decoder,
9698                    inner_offset,
9699                    inner_depth
9700                )?;
9701                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9702                {
9703                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9704                }
9705                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9706                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9707                }
9708            }
9709
9710            next_offset += envelope_size;
9711            _next_ordinal_to_read += 1;
9712            if next_offset >= end_offset {
9713                return Ok(());
9714            }
9715
9716            // Decode unknown envelopes for gaps in ordinals.
9717            while _next_ordinal_to_read < 2 {
9718                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9719                _next_ordinal_to_read += 1;
9720                next_offset += envelope_size;
9721            }
9722
9723            let next_out_of_line = decoder.next_out_of_line();
9724            let handles_before = decoder.remaining_handles();
9725            if let Some((inlined, num_bytes, num_handles)) =
9726                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9727            {
9728                let member_inline_size = <fidl::encoding::Vector<
9729                    fidl::encoding::BoundedString<4096>,
9730                    128,
9731                > as fidl::encoding::TypeMarker>::inline_size(
9732                    decoder.context
9733                );
9734                if inlined != (member_inline_size <= 4) {
9735                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9736                }
9737                let inner_offset;
9738                let mut inner_depth = depth.clone();
9739                if inlined {
9740                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9741                    inner_offset = next_offset;
9742                } else {
9743                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9744                    inner_depth.increment()?;
9745                }
9746                let val_ref = self.main_process_critical.get_or_insert_with(|| {
9747                    fidl::new_empty!(
9748                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
9749                        D
9750                    )
9751                });
9752                fidl::decode!(
9753                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
9754                    D,
9755                    val_ref,
9756                    decoder,
9757                    inner_offset,
9758                    inner_depth
9759                )?;
9760                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9761                {
9762                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9763                }
9764                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9765                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9766                }
9767            }
9768
9769            next_offset += envelope_size;
9770            _next_ordinal_to_read += 1;
9771            if next_offset >= end_offset {
9772                return Ok(());
9773            }
9774
9775            // Decode unknown envelopes for gaps in ordinals.
9776            while _next_ordinal_to_read < 3 {
9777                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9778                _next_ordinal_to_read += 1;
9779                next_offset += envelope_size;
9780            }
9781
9782            let next_out_of_line = decoder.next_out_of_line();
9783            let handles_before = decoder.remaining_handles();
9784            if let Some((inlined, num_bytes, num_handles)) =
9785                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9786            {
9787                let member_inline_size = <fidl::encoding::Vector<
9788                    fidl::encoding::BoundedString<4096>,
9789                    128,
9790                > as fidl::encoding::TypeMarker>::inline_size(
9791                    decoder.context
9792                );
9793                if inlined != (member_inline_size <= 4) {
9794                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9795                }
9796                let inner_offset;
9797                let mut inner_depth = depth.clone();
9798                if inlined {
9799                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9800                    inner_offset = next_offset;
9801                } else {
9802                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9803                    inner_depth.increment()?;
9804                }
9805                let val_ref = self.create_raw_processes.get_or_insert_with(|| {
9806                    fidl::new_empty!(
9807                        fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
9808                        D
9809                    )
9810                });
9811                fidl::decode!(
9812                    fidl::encoding::Vector<fidl::encoding::BoundedString<4096>, 128>,
9813                    D,
9814                    val_ref,
9815                    decoder,
9816                    inner_offset,
9817                    inner_depth
9818                )?;
9819                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9820                {
9821                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9822                }
9823                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9824                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9825                }
9826            }
9827
9828            next_offset += envelope_size;
9829
9830            // Decode the remaining unknown envelopes.
9831            while next_offset < end_offset {
9832                _next_ordinal_to_read += 1;
9833                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9834                next_offset += envelope_size;
9835            }
9836
9837            Ok(())
9838        }
9839    }
9840
9841    impl Namespace {
9842        #[inline(always)]
9843        fn max_ordinal_present(&self) -> u64 {
9844            if let Some(_) = self.capability {
9845                return 1;
9846            }
9847            0
9848        }
9849    }
9850
9851    impl fidl::encoding::ValueTypeMarker for Namespace {
9852        type Borrowed<'a> = &'a Self;
9853        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9854            value
9855        }
9856    }
9857
9858    unsafe impl fidl::encoding::TypeMarker for Namespace {
9859        type Owned = Self;
9860
9861        #[inline(always)]
9862        fn inline_align(_context: fidl::encoding::Context) -> usize {
9863            8
9864        }
9865
9866        #[inline(always)]
9867        fn inline_size(_context: fidl::encoding::Context) -> usize {
9868            16
9869        }
9870    }
9871
9872    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Namespace, D>
9873        for &Namespace
9874    {
9875        unsafe fn encode(
9876            self,
9877            encoder: &mut fidl::encoding::Encoder<'_, D>,
9878            offset: usize,
9879            mut depth: fidl::encoding::Depth,
9880        ) -> fidl::Result<()> {
9881            encoder.debug_check_bounds::<Namespace>(offset);
9882            // Vector header
9883            let max_ordinal: u64 = self.max_ordinal_present();
9884            encoder.write_num(max_ordinal, offset);
9885            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9886            // Calling encoder.out_of_line_offset(0) is not allowed.
9887            if max_ordinal == 0 {
9888                return Ok(());
9889            }
9890            depth.increment()?;
9891            let envelope_size = 8;
9892            let bytes_len = max_ordinal as usize * envelope_size;
9893            #[allow(unused_variables)]
9894            let offset = encoder.out_of_line_offset(bytes_len);
9895            let mut _prev_end_offset: usize = 0;
9896            if 1 > max_ordinal {
9897                return Ok(());
9898            }
9899
9900            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9901            // are envelope_size bytes.
9902            let cur_offset: usize = (1 - 1) * envelope_size;
9903
9904            // Zero reserved fields.
9905            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9906
9907            // Safety:
9908            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9909            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9910            //   envelope_size bytes, there is always sufficient room.
9911            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
9912                self.capability
9913                    .as_ref()
9914                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
9915                encoder,
9916                offset + cur_offset,
9917                depth,
9918            )?;
9919
9920            _prev_end_offset = cur_offset + envelope_size;
9921
9922            Ok(())
9923        }
9924    }
9925
9926    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Namespace {
9927        #[inline(always)]
9928        fn new_empty() -> Self {
9929            Self::default()
9930        }
9931
9932        unsafe fn decode(
9933            &mut self,
9934            decoder: &mut fidl::encoding::Decoder<'_, D>,
9935            offset: usize,
9936            mut depth: fidl::encoding::Depth,
9937        ) -> fidl::Result<()> {
9938            decoder.debug_check_bounds::<Self>(offset);
9939            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9940                None => return Err(fidl::Error::NotNullable),
9941                Some(len) => len,
9942            };
9943            // Calling decoder.out_of_line_offset(0) is not allowed.
9944            if len == 0 {
9945                return Ok(());
9946            };
9947            depth.increment()?;
9948            let envelope_size = 8;
9949            let bytes_len = len * envelope_size;
9950            let offset = decoder.out_of_line_offset(bytes_len)?;
9951            // Decode the envelope for each type.
9952            let mut _next_ordinal_to_read = 0;
9953            let mut next_offset = offset;
9954            let end_offset = offset + bytes_len;
9955            _next_ordinal_to_read += 1;
9956            if next_offset >= end_offset {
9957                return Ok(());
9958            }
9959
9960            // Decode unknown envelopes for gaps in ordinals.
9961            while _next_ordinal_to_read < 1 {
9962                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9963                _next_ordinal_to_read += 1;
9964                next_offset += envelope_size;
9965            }
9966
9967            let next_out_of_line = decoder.next_out_of_line();
9968            let handles_before = decoder.remaining_handles();
9969            if let Some((inlined, num_bytes, num_handles)) =
9970                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9971            {
9972                let member_inline_size =
9973                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
9974                        decoder.context,
9975                    );
9976                if inlined != (member_inline_size <= 4) {
9977                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9978                }
9979                let inner_offset;
9980                let mut inner_depth = depth.clone();
9981                if inlined {
9982                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9983                    inner_offset = next_offset;
9984                } else {
9985                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9986                    inner_depth.increment()?;
9987                }
9988                let val_ref =
9989                    self.capability.get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
9990                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
9991                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9992                {
9993                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9994                }
9995                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9996                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9997                }
9998            }
9999
10000            next_offset += envelope_size;
10001
10002            // Decode the remaining unknown envelopes.
10003            while next_offset < end_offset {
10004                _next_ordinal_to_read += 1;
10005                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10006                next_offset += envelope_size;
10007            }
10008
10009            Ok(())
10010        }
10011    }
10012
10013    impl RemotedAt {
10014        #[inline(always)]
10015        fn max_ordinal_present(&self) -> u64 {
10016            if let Some(_) = self.type_name {
10017                return 2;
10018            }
10019            if let Some(_) = self.moniker {
10020                return 1;
10021            }
10022            0
10023        }
10024    }
10025
10026    impl fidl::encoding::ValueTypeMarker for RemotedAt {
10027        type Borrowed<'a> = &'a Self;
10028        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10029            value
10030        }
10031    }
10032
10033    unsafe impl fidl::encoding::TypeMarker for RemotedAt {
10034        type Owned = Self;
10035
10036        #[inline(always)]
10037        fn inline_align(_context: fidl::encoding::Context) -> usize {
10038            8
10039        }
10040
10041        #[inline(always)]
10042        fn inline_size(_context: fidl::encoding::Context) -> usize {
10043            16
10044        }
10045    }
10046
10047    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RemotedAt, D>
10048        for &RemotedAt
10049    {
10050        unsafe fn encode(
10051            self,
10052            encoder: &mut fidl::encoding::Encoder<'_, D>,
10053            offset: usize,
10054            mut depth: fidl::encoding::Depth,
10055        ) -> fidl::Result<()> {
10056            encoder.debug_check_bounds::<RemotedAt>(offset);
10057            // Vector header
10058            let max_ordinal: u64 = self.max_ordinal_present();
10059            encoder.write_num(max_ordinal, offset);
10060            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10061            // Calling encoder.out_of_line_offset(0) is not allowed.
10062            if max_ordinal == 0 {
10063                return Ok(());
10064            }
10065            depth.increment()?;
10066            let envelope_size = 8;
10067            let bytes_len = max_ordinal as usize * envelope_size;
10068            #[allow(unused_variables)]
10069            let offset = encoder.out_of_line_offset(bytes_len);
10070            let mut _prev_end_offset: usize = 0;
10071            if 1 > max_ordinal {
10072                return Ok(());
10073            }
10074
10075            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10076            // are envelope_size bytes.
10077            let cur_offset: usize = (1 - 1) * envelope_size;
10078
10079            // Zero reserved fields.
10080            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10081
10082            // Safety:
10083            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10084            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10085            //   envelope_size bytes, there is always sufficient room.
10086            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
10087            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
10088            encoder, offset + cur_offset, depth
10089        )?;
10090
10091            _prev_end_offset = cur_offset + envelope_size;
10092            if 2 > max_ordinal {
10093                return Ok(());
10094            }
10095
10096            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10097            // are envelope_size bytes.
10098            let cur_offset: usize = (2 - 1) * envelope_size;
10099
10100            // Zero reserved fields.
10101            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10102
10103            // Safety:
10104            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10105            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10106            //   envelope_size bytes, there is always sufficient room.
10107            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
10108                self.type_name.as_ref().map(
10109                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
10110                ),
10111                encoder,
10112                offset + cur_offset,
10113                depth,
10114            )?;
10115
10116            _prev_end_offset = cur_offset + envelope_size;
10117
10118            Ok(())
10119        }
10120    }
10121
10122    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RemotedAt {
10123        #[inline(always)]
10124        fn new_empty() -> Self {
10125            Self::default()
10126        }
10127
10128        unsafe fn decode(
10129            &mut self,
10130            decoder: &mut fidl::encoding::Decoder<'_, D>,
10131            offset: usize,
10132            mut depth: fidl::encoding::Depth,
10133        ) -> fidl::Result<()> {
10134            decoder.debug_check_bounds::<Self>(offset);
10135            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10136                None => return Err(fidl::Error::NotNullable),
10137                Some(len) => len,
10138            };
10139            // Calling decoder.out_of_line_offset(0) is not allowed.
10140            if len == 0 {
10141                return Ok(());
10142            };
10143            depth.increment()?;
10144            let envelope_size = 8;
10145            let bytes_len = len * envelope_size;
10146            let offset = decoder.out_of_line_offset(bytes_len)?;
10147            // Decode the envelope for each type.
10148            let mut _next_ordinal_to_read = 0;
10149            let mut next_offset = offset;
10150            let end_offset = offset + bytes_len;
10151            _next_ordinal_to_read += 1;
10152            if next_offset >= end_offset {
10153                return Ok(());
10154            }
10155
10156            // Decode unknown envelopes for gaps in ordinals.
10157            while _next_ordinal_to_read < 1 {
10158                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10159                _next_ordinal_to_read += 1;
10160                next_offset += envelope_size;
10161            }
10162
10163            let next_out_of_line = decoder.next_out_of_line();
10164            let handles_before = decoder.remaining_handles();
10165            if let Some((inlined, num_bytes, num_handles)) =
10166                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10167            {
10168                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10169                if inlined != (member_inline_size <= 4) {
10170                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10171                }
10172                let inner_offset;
10173                let mut inner_depth = depth.clone();
10174                if inlined {
10175                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10176                    inner_offset = next_offset;
10177                } else {
10178                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10179                    inner_depth.increment()?;
10180                }
10181                let val_ref = self.moniker.get_or_insert_with(|| {
10182                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
10183                });
10184                fidl::decode!(
10185                    fidl::encoding::BoundedString<4096>,
10186                    D,
10187                    val_ref,
10188                    decoder,
10189                    inner_offset,
10190                    inner_depth
10191                )?;
10192                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10193                {
10194                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10195                }
10196                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10197                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10198                }
10199            }
10200
10201            next_offset += envelope_size;
10202            _next_ordinal_to_read += 1;
10203            if next_offset >= end_offset {
10204                return Ok(());
10205            }
10206
10207            // Decode unknown envelopes for gaps in ordinals.
10208            while _next_ordinal_to_read < 2 {
10209                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10210                _next_ordinal_to_read += 1;
10211                next_offset += envelope_size;
10212            }
10213
10214            let next_out_of_line = decoder.next_out_of_line();
10215            let handles_before = decoder.remaining_handles();
10216            if let Some((inlined, num_bytes, num_handles)) =
10217                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10218            {
10219                let member_inline_size =
10220                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
10221                        decoder.context,
10222                    );
10223                if inlined != (member_inline_size <= 4) {
10224                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10225                }
10226                let inner_offset;
10227                let mut inner_depth = depth.clone();
10228                if inlined {
10229                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10230                    inner_offset = next_offset;
10231                } else {
10232                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10233                    inner_depth.increment()?;
10234                }
10235                let val_ref = self
10236                    .type_name
10237                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
10238                fidl::decode!(
10239                    fidl::encoding::UnboundedString,
10240                    D,
10241                    val_ref,
10242                    decoder,
10243                    inner_offset,
10244                    inner_depth
10245                )?;
10246                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10247                {
10248                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10249                }
10250                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10251                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10252                }
10253            }
10254
10255            next_offset += envelope_size;
10256
10257            // Decode the remaining unknown envelopes.
10258            while next_offset < end_offset {
10259                _next_ordinal_to_read += 1;
10260                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10261                next_offset += envelope_size;
10262            }
10263
10264            Ok(())
10265        }
10266    }
10267
10268    impl SecurityPolicy {
10269        #[inline(always)]
10270        fn max_ordinal_present(&self) -> u64 {
10271            if let Some(_) = self.child_policy {
10272                return 4;
10273            }
10274            if let Some(_) = self.debug_registration_policy {
10275                return 3;
10276            }
10277            if let Some(_) = self.capability_policy {
10278                return 2;
10279            }
10280            if let Some(_) = self.job_policy {
10281                return 1;
10282            }
10283            0
10284        }
10285    }
10286
10287    impl fidl::encoding::ValueTypeMarker for SecurityPolicy {
10288        type Borrowed<'a> = &'a Self;
10289        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10290            value
10291        }
10292    }
10293
10294    unsafe impl fidl::encoding::TypeMarker for SecurityPolicy {
10295        type Owned = Self;
10296
10297        #[inline(always)]
10298        fn inline_align(_context: fidl::encoding::Context) -> usize {
10299            8
10300        }
10301
10302        #[inline(always)]
10303        fn inline_size(_context: fidl::encoding::Context) -> usize {
10304            16
10305        }
10306    }
10307
10308    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SecurityPolicy, D>
10309        for &SecurityPolicy
10310    {
10311        unsafe fn encode(
10312            self,
10313            encoder: &mut fidl::encoding::Encoder<'_, D>,
10314            offset: usize,
10315            mut depth: fidl::encoding::Depth,
10316        ) -> fidl::Result<()> {
10317            encoder.debug_check_bounds::<SecurityPolicy>(offset);
10318            // Vector header
10319            let max_ordinal: u64 = self.max_ordinal_present();
10320            encoder.write_num(max_ordinal, offset);
10321            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10322            // Calling encoder.out_of_line_offset(0) is not allowed.
10323            if max_ordinal == 0 {
10324                return Ok(());
10325            }
10326            depth.increment()?;
10327            let envelope_size = 8;
10328            let bytes_len = max_ordinal as usize * envelope_size;
10329            #[allow(unused_variables)]
10330            let offset = encoder.out_of_line_offset(bytes_len);
10331            let mut _prev_end_offset: usize = 0;
10332            if 1 > max_ordinal {
10333                return Ok(());
10334            }
10335
10336            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10337            // are envelope_size bytes.
10338            let cur_offset: usize = (1 - 1) * envelope_size;
10339
10340            // Zero reserved fields.
10341            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10342
10343            // Safety:
10344            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10345            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10346            //   envelope_size bytes, there is always sufficient room.
10347            fidl::encoding::encode_in_envelope_optional::<JobPolicyAllowlists, D>(
10348                self.job_policy
10349                    .as_ref()
10350                    .map(<JobPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow),
10351                encoder,
10352                offset + cur_offset,
10353                depth,
10354            )?;
10355
10356            _prev_end_offset = cur_offset + envelope_size;
10357            if 2 > max_ordinal {
10358                return Ok(());
10359            }
10360
10361            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10362            // are envelope_size bytes.
10363            let cur_offset: usize = (2 - 1) * envelope_size;
10364
10365            // Zero reserved fields.
10366            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10367
10368            // Safety:
10369            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10370            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10371            //   envelope_size bytes, there is always sufficient room.
10372            fidl::encoding::encode_in_envelope_optional::<CapabilityPolicyAllowlists, D>(
10373                self.capability_policy
10374                    .as_ref()
10375                    .map(<CapabilityPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow),
10376                encoder,
10377                offset + cur_offset,
10378                depth,
10379            )?;
10380
10381            _prev_end_offset = cur_offset + envelope_size;
10382            if 3 > max_ordinal {
10383                return Ok(());
10384            }
10385
10386            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10387            // are envelope_size bytes.
10388            let cur_offset: usize = (3 - 1) * envelope_size;
10389
10390            // Zero reserved fields.
10391            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10392
10393            // Safety:
10394            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10395            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10396            //   envelope_size bytes, there is always sufficient room.
10397            fidl::encoding::encode_in_envelope_optional::<DebugRegistrationPolicyAllowlists, D>(
10398                self.debug_registration_policy.as_ref().map(
10399                    <DebugRegistrationPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow,
10400                ),
10401                encoder,
10402                offset + cur_offset,
10403                depth,
10404            )?;
10405
10406            _prev_end_offset = cur_offset + envelope_size;
10407            if 4 > max_ordinal {
10408                return Ok(());
10409            }
10410
10411            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10412            // are envelope_size bytes.
10413            let cur_offset: usize = (4 - 1) * envelope_size;
10414
10415            // Zero reserved fields.
10416            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10417
10418            // Safety:
10419            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10420            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10421            //   envelope_size bytes, there is always sufficient room.
10422            fidl::encoding::encode_in_envelope_optional::<ChildPolicyAllowlists, D>(
10423                self.child_policy
10424                    .as_ref()
10425                    .map(<ChildPolicyAllowlists as fidl::encoding::ValueTypeMarker>::borrow),
10426                encoder,
10427                offset + cur_offset,
10428                depth,
10429            )?;
10430
10431            _prev_end_offset = cur_offset + envelope_size;
10432
10433            Ok(())
10434        }
10435    }
10436
10437    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SecurityPolicy {
10438        #[inline(always)]
10439        fn new_empty() -> Self {
10440            Self::default()
10441        }
10442
10443        unsafe fn decode(
10444            &mut self,
10445            decoder: &mut fidl::encoding::Decoder<'_, D>,
10446            offset: usize,
10447            mut depth: fidl::encoding::Depth,
10448        ) -> fidl::Result<()> {
10449            decoder.debug_check_bounds::<Self>(offset);
10450            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10451                None => return Err(fidl::Error::NotNullable),
10452                Some(len) => len,
10453            };
10454            // Calling decoder.out_of_line_offset(0) is not allowed.
10455            if len == 0 {
10456                return Ok(());
10457            };
10458            depth.increment()?;
10459            let envelope_size = 8;
10460            let bytes_len = len * envelope_size;
10461            let offset = decoder.out_of_line_offset(bytes_len)?;
10462            // Decode the envelope for each type.
10463            let mut _next_ordinal_to_read = 0;
10464            let mut next_offset = offset;
10465            let end_offset = offset + bytes_len;
10466            _next_ordinal_to_read += 1;
10467            if next_offset >= end_offset {
10468                return Ok(());
10469            }
10470
10471            // Decode unknown envelopes for gaps in ordinals.
10472            while _next_ordinal_to_read < 1 {
10473                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10474                _next_ordinal_to_read += 1;
10475                next_offset += envelope_size;
10476            }
10477
10478            let next_out_of_line = decoder.next_out_of_line();
10479            let handles_before = decoder.remaining_handles();
10480            if let Some((inlined, num_bytes, num_handles)) =
10481                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10482            {
10483                let member_inline_size =
10484                    <JobPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
10485                        decoder.context,
10486                    );
10487                if inlined != (member_inline_size <= 4) {
10488                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10489                }
10490                let inner_offset;
10491                let mut inner_depth = depth.clone();
10492                if inlined {
10493                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10494                    inner_offset = next_offset;
10495                } else {
10496                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10497                    inner_depth.increment()?;
10498                }
10499                let val_ref =
10500                    self.job_policy.get_or_insert_with(|| fidl::new_empty!(JobPolicyAllowlists, D));
10501                fidl::decode!(JobPolicyAllowlists, D, val_ref, decoder, inner_offset, inner_depth)?;
10502                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10503                {
10504                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10505                }
10506                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10507                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10508                }
10509            }
10510
10511            next_offset += envelope_size;
10512            _next_ordinal_to_read += 1;
10513            if next_offset >= end_offset {
10514                return Ok(());
10515            }
10516
10517            // Decode unknown envelopes for gaps in ordinals.
10518            while _next_ordinal_to_read < 2 {
10519                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10520                _next_ordinal_to_read += 1;
10521                next_offset += envelope_size;
10522            }
10523
10524            let next_out_of_line = decoder.next_out_of_line();
10525            let handles_before = decoder.remaining_handles();
10526            if let Some((inlined, num_bytes, num_handles)) =
10527                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10528            {
10529                let member_inline_size =
10530                    <CapabilityPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
10531                        decoder.context,
10532                    );
10533                if inlined != (member_inline_size <= 4) {
10534                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10535                }
10536                let inner_offset;
10537                let mut inner_depth = depth.clone();
10538                if inlined {
10539                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10540                    inner_offset = next_offset;
10541                } else {
10542                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10543                    inner_depth.increment()?;
10544                }
10545                let val_ref = self
10546                    .capability_policy
10547                    .get_or_insert_with(|| fidl::new_empty!(CapabilityPolicyAllowlists, D));
10548                fidl::decode!(
10549                    CapabilityPolicyAllowlists,
10550                    D,
10551                    val_ref,
10552                    decoder,
10553                    inner_offset,
10554                    inner_depth
10555                )?;
10556                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10557                {
10558                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10559                }
10560                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10561                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10562                }
10563            }
10564
10565            next_offset += envelope_size;
10566            _next_ordinal_to_read += 1;
10567            if next_offset >= end_offset {
10568                return Ok(());
10569            }
10570
10571            // Decode unknown envelopes for gaps in ordinals.
10572            while _next_ordinal_to_read < 3 {
10573                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10574                _next_ordinal_to_read += 1;
10575                next_offset += envelope_size;
10576            }
10577
10578            let next_out_of_line = decoder.next_out_of_line();
10579            let handles_before = decoder.remaining_handles();
10580            if let Some((inlined, num_bytes, num_handles)) =
10581                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10582            {
10583                let member_inline_size =
10584                    <DebugRegistrationPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
10585                        decoder.context,
10586                    );
10587                if inlined != (member_inline_size <= 4) {
10588                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10589                }
10590                let inner_offset;
10591                let mut inner_depth = depth.clone();
10592                if inlined {
10593                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10594                    inner_offset = next_offset;
10595                } else {
10596                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10597                    inner_depth.increment()?;
10598                }
10599                let val_ref = self
10600                    .debug_registration_policy
10601                    .get_or_insert_with(|| fidl::new_empty!(DebugRegistrationPolicyAllowlists, D));
10602                fidl::decode!(
10603                    DebugRegistrationPolicyAllowlists,
10604                    D,
10605                    val_ref,
10606                    decoder,
10607                    inner_offset,
10608                    inner_depth
10609                )?;
10610                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10611                {
10612                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10613                }
10614                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10615                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10616                }
10617            }
10618
10619            next_offset += envelope_size;
10620            _next_ordinal_to_read += 1;
10621            if next_offset >= end_offset {
10622                return Ok(());
10623            }
10624
10625            // Decode unknown envelopes for gaps in ordinals.
10626            while _next_ordinal_to_read < 4 {
10627                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10628                _next_ordinal_to_read += 1;
10629                next_offset += envelope_size;
10630            }
10631
10632            let next_out_of_line = decoder.next_out_of_line();
10633            let handles_before = decoder.remaining_handles();
10634            if let Some((inlined, num_bytes, num_handles)) =
10635                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10636            {
10637                let member_inline_size =
10638                    <ChildPolicyAllowlists as fidl::encoding::TypeMarker>::inline_size(
10639                        decoder.context,
10640                    );
10641                if inlined != (member_inline_size <= 4) {
10642                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10643                }
10644                let inner_offset;
10645                let mut inner_depth = depth.clone();
10646                if inlined {
10647                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10648                    inner_offset = next_offset;
10649                } else {
10650                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10651                    inner_depth.increment()?;
10652                }
10653                let val_ref = self
10654                    .child_policy
10655                    .get_or_insert_with(|| fidl::new_empty!(ChildPolicyAllowlists, D));
10656                fidl::decode!(
10657                    ChildPolicyAllowlists,
10658                    D,
10659                    val_ref,
10660                    decoder,
10661                    inner_offset,
10662                    inner_depth
10663                )?;
10664                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10665                {
10666                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10667                }
10668                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10669                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10670                }
10671            }
10672
10673            next_offset += envelope_size;
10674
10675            // Decode the remaining unknown envelopes.
10676            while next_offset < end_offset {
10677                _next_ordinal_to_read += 1;
10678                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10679                next_offset += envelope_size;
10680            }
10681
10682            Ok(())
10683        }
10684    }
10685
10686    impl StorageBackingDirectory {
10687        #[inline(always)]
10688        fn max_ordinal_present(&self) -> u64 {
10689            if let Some(_) = self.storage_source_moniker {
10690                return 5;
10691            }
10692            if let Some(_) = self.storage_subdir {
10693                return 4;
10694            }
10695            if let Some(_) = self.backing_dir_subdir {
10696                return 3;
10697            }
10698            if let Some(_) = self.moniker {
10699                return 2;
10700            }
10701            if let Some(_) = self.capability {
10702                return 1;
10703            }
10704            0
10705        }
10706    }
10707
10708    impl fidl::encoding::ValueTypeMarker for StorageBackingDirectory {
10709        type Borrowed<'a> = &'a Self;
10710        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10711            value
10712        }
10713    }
10714
10715    unsafe impl fidl::encoding::TypeMarker for StorageBackingDirectory {
10716        type Owned = Self;
10717
10718        #[inline(always)]
10719        fn inline_align(_context: fidl::encoding::Context) -> usize {
10720            8
10721        }
10722
10723        #[inline(always)]
10724        fn inline_size(_context: fidl::encoding::Context) -> usize {
10725            16
10726        }
10727    }
10728
10729    unsafe impl<D: fidl::encoding::ResourceDialect>
10730        fidl::encoding::Encode<StorageBackingDirectory, D> for &StorageBackingDirectory
10731    {
10732        unsafe fn encode(
10733            self,
10734            encoder: &mut fidl::encoding::Encoder<'_, D>,
10735            offset: usize,
10736            mut depth: fidl::encoding::Depth,
10737        ) -> fidl::Result<()> {
10738            encoder.debug_check_bounds::<StorageBackingDirectory>(offset);
10739            // Vector header
10740            let max_ordinal: u64 = self.max_ordinal_present();
10741            encoder.write_num(max_ordinal, offset);
10742            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10743            // Calling encoder.out_of_line_offset(0) is not allowed.
10744            if max_ordinal == 0 {
10745                return Ok(());
10746            }
10747            depth.increment()?;
10748            let envelope_size = 8;
10749            let bytes_len = max_ordinal as usize * envelope_size;
10750            #[allow(unused_variables)]
10751            let offset = encoder.out_of_line_offset(bytes_len);
10752            let mut _prev_end_offset: usize = 0;
10753            if 1 > max_ordinal {
10754                return Ok(());
10755            }
10756
10757            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10758            // are envelope_size bytes.
10759            let cur_offset: usize = (1 - 1) * envelope_size;
10760
10761            // Zero reserved fields.
10762            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10763
10764            // Safety:
10765            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10766            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10767            //   envelope_size bytes, there is always sufficient room.
10768            fidl::encoding::encode_in_envelope_optional::<ComponentCapability, D>(
10769                self.capability
10770                    .as_ref()
10771                    .map(<ComponentCapability as fidl::encoding::ValueTypeMarker>::borrow),
10772                encoder,
10773                offset + cur_offset,
10774                depth,
10775            )?;
10776
10777            _prev_end_offset = cur_offset + envelope_size;
10778            if 2 > max_ordinal {
10779                return Ok(());
10780            }
10781
10782            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10783            // are envelope_size bytes.
10784            let cur_offset: usize = (2 - 1) * envelope_size;
10785
10786            // Zero reserved fields.
10787            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10788
10789            // Safety:
10790            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10791            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10792            //   envelope_size bytes, there is always sufficient room.
10793            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
10794            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
10795            encoder, offset + cur_offset, depth
10796        )?;
10797
10798            _prev_end_offset = cur_offset + envelope_size;
10799            if 3 > max_ordinal {
10800                return Ok(());
10801            }
10802
10803            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10804            // are envelope_size bytes.
10805            let cur_offset: usize = (3 - 1) * envelope_size;
10806
10807            // Zero reserved fields.
10808            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10809
10810            // Safety:
10811            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10812            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10813            //   envelope_size bytes, there is always sufficient room.
10814            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
10815            self.backing_dir_subdir.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
10816            encoder, offset + cur_offset, depth
10817        )?;
10818
10819            _prev_end_offset = cur_offset + envelope_size;
10820            if 4 > max_ordinal {
10821                return Ok(());
10822            }
10823
10824            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10825            // are envelope_size bytes.
10826            let cur_offset: usize = (4 - 1) * envelope_size;
10827
10828            // Zero reserved fields.
10829            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10830
10831            // Safety:
10832            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10833            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10834            //   envelope_size bytes, there is always sufficient room.
10835            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
10836            self.storage_subdir.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
10837            encoder, offset + cur_offset, depth
10838        )?;
10839
10840            _prev_end_offset = cur_offset + envelope_size;
10841            if 5 > max_ordinal {
10842                return Ok(());
10843            }
10844
10845            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10846            // are envelope_size bytes.
10847            let cur_offset: usize = (5 - 1) * envelope_size;
10848
10849            // Zero reserved fields.
10850            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10851
10852            // Safety:
10853            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10854            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10855            //   envelope_size bytes, there is always sufficient room.
10856            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
10857            self.storage_source_moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
10858            encoder, offset + cur_offset, depth
10859        )?;
10860
10861            _prev_end_offset = cur_offset + envelope_size;
10862
10863            Ok(())
10864        }
10865    }
10866
10867    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10868        for StorageBackingDirectory
10869    {
10870        #[inline(always)]
10871        fn new_empty() -> Self {
10872            Self::default()
10873        }
10874
10875        unsafe fn decode(
10876            &mut self,
10877            decoder: &mut fidl::encoding::Decoder<'_, D>,
10878            offset: usize,
10879            mut depth: fidl::encoding::Depth,
10880        ) -> fidl::Result<()> {
10881            decoder.debug_check_bounds::<Self>(offset);
10882            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10883                None => return Err(fidl::Error::NotNullable),
10884                Some(len) => len,
10885            };
10886            // Calling decoder.out_of_line_offset(0) is not allowed.
10887            if len == 0 {
10888                return Ok(());
10889            };
10890            depth.increment()?;
10891            let envelope_size = 8;
10892            let bytes_len = len * envelope_size;
10893            let offset = decoder.out_of_line_offset(bytes_len)?;
10894            // Decode the envelope for each type.
10895            let mut _next_ordinal_to_read = 0;
10896            let mut next_offset = offset;
10897            let end_offset = offset + bytes_len;
10898            _next_ordinal_to_read += 1;
10899            if next_offset >= end_offset {
10900                return Ok(());
10901            }
10902
10903            // Decode unknown envelopes for gaps in ordinals.
10904            while _next_ordinal_to_read < 1 {
10905                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10906                _next_ordinal_to_read += 1;
10907                next_offset += envelope_size;
10908            }
10909
10910            let next_out_of_line = decoder.next_out_of_line();
10911            let handles_before = decoder.remaining_handles();
10912            if let Some((inlined, num_bytes, num_handles)) =
10913                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10914            {
10915                let member_inline_size =
10916                    <ComponentCapability as fidl::encoding::TypeMarker>::inline_size(
10917                        decoder.context,
10918                    );
10919                if inlined != (member_inline_size <= 4) {
10920                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10921                }
10922                let inner_offset;
10923                let mut inner_depth = depth.clone();
10924                if inlined {
10925                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10926                    inner_offset = next_offset;
10927                } else {
10928                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10929                    inner_depth.increment()?;
10930                }
10931                let val_ref =
10932                    self.capability.get_or_insert_with(|| fidl::new_empty!(ComponentCapability, D));
10933                fidl::decode!(ComponentCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
10934                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10935                {
10936                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10937                }
10938                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10939                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10940                }
10941            }
10942
10943            next_offset += envelope_size;
10944            _next_ordinal_to_read += 1;
10945            if next_offset >= end_offset {
10946                return Ok(());
10947            }
10948
10949            // Decode unknown envelopes for gaps in ordinals.
10950            while _next_ordinal_to_read < 2 {
10951                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10952                _next_ordinal_to_read += 1;
10953                next_offset += envelope_size;
10954            }
10955
10956            let next_out_of_line = decoder.next_out_of_line();
10957            let handles_before = decoder.remaining_handles();
10958            if let Some((inlined, num_bytes, num_handles)) =
10959                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10960            {
10961                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10962                if inlined != (member_inline_size <= 4) {
10963                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10964                }
10965                let inner_offset;
10966                let mut inner_depth = depth.clone();
10967                if inlined {
10968                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10969                    inner_offset = next_offset;
10970                } else {
10971                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10972                    inner_depth.increment()?;
10973                }
10974                let val_ref = self.moniker.get_or_insert_with(|| {
10975                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
10976                });
10977                fidl::decode!(
10978                    fidl::encoding::BoundedString<4096>,
10979                    D,
10980                    val_ref,
10981                    decoder,
10982                    inner_offset,
10983                    inner_depth
10984                )?;
10985                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10986                {
10987                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10988                }
10989                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10990                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10991                }
10992            }
10993
10994            next_offset += envelope_size;
10995            _next_ordinal_to_read += 1;
10996            if next_offset >= end_offset {
10997                return Ok(());
10998            }
10999
11000            // Decode unknown envelopes for gaps in ordinals.
11001            while _next_ordinal_to_read < 3 {
11002                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11003                _next_ordinal_to_read += 1;
11004                next_offset += envelope_size;
11005            }
11006
11007            let next_out_of_line = decoder.next_out_of_line();
11008            let handles_before = decoder.remaining_handles();
11009            if let Some((inlined, num_bytes, num_handles)) =
11010                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11011            {
11012                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11013                if inlined != (member_inline_size <= 4) {
11014                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11015                }
11016                let inner_offset;
11017                let mut inner_depth = depth.clone();
11018                if inlined {
11019                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11020                    inner_offset = next_offset;
11021                } else {
11022                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11023                    inner_depth.increment()?;
11024                }
11025                let val_ref = self.backing_dir_subdir.get_or_insert_with(|| {
11026                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
11027                });
11028                fidl::decode!(
11029                    fidl::encoding::BoundedString<1024>,
11030                    D,
11031                    val_ref,
11032                    decoder,
11033                    inner_offset,
11034                    inner_depth
11035                )?;
11036                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11037                {
11038                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11039                }
11040                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11041                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11042                }
11043            }
11044
11045            next_offset += envelope_size;
11046            _next_ordinal_to_read += 1;
11047            if next_offset >= end_offset {
11048                return Ok(());
11049            }
11050
11051            // Decode unknown envelopes for gaps in ordinals.
11052            while _next_ordinal_to_read < 4 {
11053                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11054                _next_ordinal_to_read += 1;
11055                next_offset += envelope_size;
11056            }
11057
11058            let next_out_of_line = decoder.next_out_of_line();
11059            let handles_before = decoder.remaining_handles();
11060            if let Some((inlined, num_bytes, num_handles)) =
11061                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11062            {
11063                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11064                if inlined != (member_inline_size <= 4) {
11065                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11066                }
11067                let inner_offset;
11068                let mut inner_depth = depth.clone();
11069                if inlined {
11070                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11071                    inner_offset = next_offset;
11072                } else {
11073                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11074                    inner_depth.increment()?;
11075                }
11076                let val_ref = self.storage_subdir.get_or_insert_with(|| {
11077                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
11078                });
11079                fidl::decode!(
11080                    fidl::encoding::BoundedString<1024>,
11081                    D,
11082                    val_ref,
11083                    decoder,
11084                    inner_offset,
11085                    inner_depth
11086                )?;
11087                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11088                {
11089                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11090                }
11091                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11092                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11093                }
11094            }
11095
11096            next_offset += envelope_size;
11097            _next_ordinal_to_read += 1;
11098            if next_offset >= end_offset {
11099                return Ok(());
11100            }
11101
11102            // Decode unknown envelopes for gaps in ordinals.
11103            while _next_ordinal_to_read < 5 {
11104                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11105                _next_ordinal_to_read += 1;
11106                next_offset += envelope_size;
11107            }
11108
11109            let next_out_of_line = decoder.next_out_of_line();
11110            let handles_before = decoder.remaining_handles();
11111            if let Some((inlined, num_bytes, num_handles)) =
11112                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11113            {
11114                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11115                if inlined != (member_inline_size <= 4) {
11116                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11117                }
11118                let inner_offset;
11119                let mut inner_depth = depth.clone();
11120                if inlined {
11121                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11122                    inner_offset = next_offset;
11123                } else {
11124                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11125                    inner_depth.increment()?;
11126                }
11127                let val_ref = self.storage_source_moniker.get_or_insert_with(|| {
11128                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
11129                });
11130                fidl::decode!(
11131                    fidl::encoding::BoundedString<4096>,
11132                    D,
11133                    val_ref,
11134                    decoder,
11135                    inner_offset,
11136                    inner_depth
11137                )?;
11138                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11139                {
11140                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11141                }
11142                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11143                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11144                }
11145            }
11146
11147            next_offset += envelope_size;
11148
11149            // Decode the remaining unknown envelopes.
11150            while next_offset < end_offset {
11151                _next_ordinal_to_read += 1;
11152                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11153                next_offset += envelope_size;
11154            }
11155
11156            Ok(())
11157        }
11158    }
11159
11160    impl Void {
11161        #[inline(always)]
11162        fn max_ordinal_present(&self) -> u64 {
11163            if let Some(_) = self.moniker {
11164                return 2;
11165            }
11166            if let Some(_) = self.capability {
11167                return 1;
11168            }
11169            0
11170        }
11171    }
11172
11173    impl fidl::encoding::ValueTypeMarker for Void {
11174        type Borrowed<'a> = &'a Self;
11175        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11176            value
11177        }
11178    }
11179
11180    unsafe impl fidl::encoding::TypeMarker for Void {
11181        type Owned = Self;
11182
11183        #[inline(always)]
11184        fn inline_align(_context: fidl::encoding::Context) -> usize {
11185            8
11186        }
11187
11188        #[inline(always)]
11189        fn inline_size(_context: fidl::encoding::Context) -> usize {
11190            16
11191        }
11192    }
11193
11194    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Void, D> for &Void {
11195        unsafe fn encode(
11196            self,
11197            encoder: &mut fidl::encoding::Encoder<'_, D>,
11198            offset: usize,
11199            mut depth: fidl::encoding::Depth,
11200        ) -> fidl::Result<()> {
11201            encoder.debug_check_bounds::<Void>(offset);
11202            // Vector header
11203            let max_ordinal: u64 = self.max_ordinal_present();
11204            encoder.write_num(max_ordinal, offset);
11205            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11206            // Calling encoder.out_of_line_offset(0) is not allowed.
11207            if max_ordinal == 0 {
11208                return Ok(());
11209            }
11210            depth.increment()?;
11211            let envelope_size = 8;
11212            let bytes_len = max_ordinal as usize * envelope_size;
11213            #[allow(unused_variables)]
11214            let offset = encoder.out_of_line_offset(bytes_len);
11215            let mut _prev_end_offset: usize = 0;
11216            if 1 > max_ordinal {
11217                return Ok(());
11218            }
11219
11220            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11221            // are envelope_size bytes.
11222            let cur_offset: usize = (1 - 1) * envelope_size;
11223
11224            // Zero reserved fields.
11225            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11226
11227            // Safety:
11228            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11229            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11230            //   envelope_size bytes, there is always sufficient room.
11231            fidl::encoding::encode_in_envelope_optional::<InternalCapability, D>(
11232                self.capability
11233                    .as_ref()
11234                    .map(<InternalCapability as fidl::encoding::ValueTypeMarker>::borrow),
11235                encoder,
11236                offset + cur_offset,
11237                depth,
11238            )?;
11239
11240            _prev_end_offset = cur_offset + envelope_size;
11241            if 2 > max_ordinal {
11242                return Ok(());
11243            }
11244
11245            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11246            // are envelope_size bytes.
11247            let cur_offset: usize = (2 - 1) * envelope_size;
11248
11249            // Zero reserved fields.
11250            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11251
11252            // Safety:
11253            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11254            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11255            //   envelope_size bytes, there is always sufficient room.
11256            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
11257            self.moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
11258            encoder, offset + cur_offset, depth
11259        )?;
11260
11261            _prev_end_offset = cur_offset + envelope_size;
11262
11263            Ok(())
11264        }
11265    }
11266
11267    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Void {
11268        #[inline(always)]
11269        fn new_empty() -> Self {
11270            Self::default()
11271        }
11272
11273        unsafe fn decode(
11274            &mut self,
11275            decoder: &mut fidl::encoding::Decoder<'_, D>,
11276            offset: usize,
11277            mut depth: fidl::encoding::Depth,
11278        ) -> fidl::Result<()> {
11279            decoder.debug_check_bounds::<Self>(offset);
11280            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11281                None => return Err(fidl::Error::NotNullable),
11282                Some(len) => len,
11283            };
11284            // Calling decoder.out_of_line_offset(0) is not allowed.
11285            if len == 0 {
11286                return Ok(());
11287            };
11288            depth.increment()?;
11289            let envelope_size = 8;
11290            let bytes_len = len * envelope_size;
11291            let offset = decoder.out_of_line_offset(bytes_len)?;
11292            // Decode the envelope for each type.
11293            let mut _next_ordinal_to_read = 0;
11294            let mut next_offset = offset;
11295            let end_offset = offset + bytes_len;
11296            _next_ordinal_to_read += 1;
11297            if next_offset >= end_offset {
11298                return Ok(());
11299            }
11300
11301            // Decode unknown envelopes for gaps in ordinals.
11302            while _next_ordinal_to_read < 1 {
11303                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11304                _next_ordinal_to_read += 1;
11305                next_offset += envelope_size;
11306            }
11307
11308            let next_out_of_line = decoder.next_out_of_line();
11309            let handles_before = decoder.remaining_handles();
11310            if let Some((inlined, num_bytes, num_handles)) =
11311                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11312            {
11313                let member_inline_size =
11314                    <InternalCapability as fidl::encoding::TypeMarker>::inline_size(
11315                        decoder.context,
11316                    );
11317                if inlined != (member_inline_size <= 4) {
11318                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11319                }
11320                let inner_offset;
11321                let mut inner_depth = depth.clone();
11322                if inlined {
11323                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11324                    inner_offset = next_offset;
11325                } else {
11326                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11327                    inner_depth.increment()?;
11328                }
11329                let val_ref =
11330                    self.capability.get_or_insert_with(|| fidl::new_empty!(InternalCapability, D));
11331                fidl::decode!(InternalCapability, D, val_ref, decoder, inner_offset, inner_depth)?;
11332                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11333                {
11334                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11335                }
11336                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11337                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11338                }
11339            }
11340
11341            next_offset += envelope_size;
11342            _next_ordinal_to_read += 1;
11343            if next_offset >= end_offset {
11344                return Ok(());
11345            }
11346
11347            // Decode unknown envelopes for gaps in ordinals.
11348            while _next_ordinal_to_read < 2 {
11349                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11350                _next_ordinal_to_read += 1;
11351                next_offset += envelope_size;
11352            }
11353
11354            let next_out_of_line = decoder.next_out_of_line();
11355            let handles_before = decoder.remaining_handles();
11356            if let Some((inlined, num_bytes, num_handles)) =
11357                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11358            {
11359                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11360                if inlined != (member_inline_size <= 4) {
11361                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11362                }
11363                let inner_offset;
11364                let mut inner_depth = depth.clone();
11365                if inlined {
11366                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11367                    inner_offset = next_offset;
11368                } else {
11369                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11370                    inner_depth.increment()?;
11371                }
11372                let val_ref = self.moniker.get_or_insert_with(|| {
11373                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
11374                });
11375                fidl::decode!(
11376                    fidl::encoding::BoundedString<4096>,
11377                    D,
11378                    val_ref,
11379                    decoder,
11380                    inner_offset,
11381                    inner_depth
11382                )?;
11383                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11384                {
11385                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11386                }
11387                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11388                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11389                }
11390            }
11391
11392            next_offset += envelope_size;
11393
11394            // Decode the remaining unknown envelopes.
11395            while next_offset < end_offset {
11396                _next_ordinal_to_read += 1;
11397                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11398                next_offset += envelope_size;
11399            }
11400
11401            Ok(())
11402        }
11403    }
11404
11405    impl fidl::encoding::ValueTypeMarker for AggregateCapability {
11406        type Borrowed<'a> = &'a Self;
11407        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11408            value
11409        }
11410    }
11411
11412    unsafe impl fidl::encoding::TypeMarker for AggregateCapability {
11413        type Owned = Self;
11414
11415        #[inline(always)]
11416        fn inline_align(_context: fidl::encoding::Context) -> usize {
11417            8
11418        }
11419
11420        #[inline(always)]
11421        fn inline_size(_context: fidl::encoding::Context) -> usize {
11422            16
11423        }
11424    }
11425
11426    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AggregateCapability, D>
11427        for &AggregateCapability
11428    {
11429        #[inline]
11430        unsafe fn encode(
11431            self,
11432            encoder: &mut fidl::encoding::Encoder<'_, D>,
11433            offset: usize,
11434            _depth: fidl::encoding::Depth,
11435        ) -> fidl::Result<()> {
11436            encoder.debug_check_bounds::<AggregateCapability>(offset);
11437            encoder.write_num::<u64>(self.ordinal(), offset);
11438            match self {
11439                AggregateCapability::Service(ref val) => fidl::encoding::encode_in_envelope::<
11440                    fidl::encoding::BoundedString<100>,
11441                    D,
11442                >(
11443                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
11444                        val,
11445                    ),
11446                    encoder,
11447                    offset + 8,
11448                    _depth,
11449                ),
11450            }
11451        }
11452    }
11453
11454    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AggregateCapability {
11455        #[inline(always)]
11456        fn new_empty() -> Self {
11457            Self::Service(fidl::new_empty!(fidl::encoding::BoundedString<100>, D))
11458        }
11459
11460        #[inline]
11461        unsafe fn decode(
11462            &mut self,
11463            decoder: &mut fidl::encoding::Decoder<'_, D>,
11464            offset: usize,
11465            mut depth: fidl::encoding::Depth,
11466        ) -> fidl::Result<()> {
11467            decoder.debug_check_bounds::<Self>(offset);
11468            #[allow(unused_variables)]
11469            let next_out_of_line = decoder.next_out_of_line();
11470            let handles_before = decoder.remaining_handles();
11471            let (ordinal, inlined, num_bytes, num_handles) =
11472                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11473
11474            let member_inline_size = match ordinal {
11475                1 => {
11476                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11477                        decoder.context,
11478                    )
11479                }
11480                _ => return Err(fidl::Error::UnknownUnionTag),
11481            };
11482
11483            if inlined != (member_inline_size <= 4) {
11484                return Err(fidl::Error::InvalidInlineBitInEnvelope);
11485            }
11486            let _inner_offset;
11487            if inlined {
11488                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11489                _inner_offset = offset + 8;
11490            } else {
11491                depth.increment()?;
11492                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11493            }
11494            match ordinal {
11495                1 => {
11496                    #[allow(irrefutable_let_patterns)]
11497                    if let AggregateCapability::Service(_) = self {
11498                        // Do nothing, read the value into the object
11499                    } else {
11500                        // Initialize `self` to the right variant
11501                        *self = AggregateCapability::Service(fidl::new_empty!(
11502                            fidl::encoding::BoundedString<100>,
11503                            D
11504                        ));
11505                    }
11506                    #[allow(irrefutable_let_patterns)]
11507                    if let AggregateCapability::Service(ref mut val) = self {
11508                        fidl::decode!(
11509                            fidl::encoding::BoundedString<100>,
11510                            D,
11511                            val,
11512                            decoder,
11513                            _inner_offset,
11514                            depth
11515                        )?;
11516                    } else {
11517                        unreachable!()
11518                    }
11519                }
11520                ordinal => panic!("unexpected ordinal {:?}", ordinal),
11521            }
11522            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11523                return Err(fidl::Error::InvalidNumBytesInEnvelope);
11524            }
11525            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11526                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11527            }
11528            Ok(())
11529        }
11530    }
11531
11532    impl fidl::encoding::ValueTypeMarker for AggregateMember {
11533        type Borrowed<'a> = &'a Self;
11534        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11535            value
11536        }
11537    }
11538
11539    unsafe impl fidl::encoding::TypeMarker for AggregateMember {
11540        type Owned = Self;
11541
11542        #[inline(always)]
11543        fn inline_align(_context: fidl::encoding::Context) -> usize {
11544            8
11545        }
11546
11547        #[inline(always)]
11548        fn inline_size(_context: fidl::encoding::Context) -> usize {
11549            16
11550        }
11551    }
11552
11553    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AggregateMember, D>
11554        for &AggregateMember
11555    {
11556        #[inline]
11557        unsafe fn encode(
11558            self,
11559            encoder: &mut fidl::encoding::Encoder<'_, D>,
11560            offset: usize,
11561            _depth: fidl::encoding::Depth,
11562        ) -> fidl::Result<()> {
11563            encoder.debug_check_bounds::<AggregateMember>(offset);
11564            encoder.write_num::<u64>(self.ordinal(), offset);
11565            match self {
11566            AggregateMember::Child(ref val) => {
11567                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::ChildRef, D>(
11568                    <fidl_fuchsia_component_decl__common::ChildRef as fidl::encoding::ValueTypeMarker>::borrow(val),
11569                    encoder, offset + 8, _depth
11570                )
11571            }
11572            AggregateMember::Collection(ref val) => {
11573                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<100>, D>(
11574                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(val),
11575                    encoder, offset + 8, _depth
11576                )
11577            }
11578            AggregateMember::Parent(ref val) => {
11579                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::ParentRef, D>(
11580                    <fidl_fuchsia_component_decl__common::ParentRef as fidl::encoding::ValueTypeMarker>::borrow(val),
11581                    encoder, offset + 8, _depth
11582                )
11583            }
11584            AggregateMember::Self_(ref val) => {
11585                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::SelfRef, D>(
11586                    <fidl_fuchsia_component_decl__common::SelfRef as fidl::encoding::ValueTypeMarker>::borrow(val),
11587                    encoder, offset + 8, _depth
11588                )
11589            }
11590        }
11591        }
11592    }
11593
11594    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AggregateMember {
11595        #[inline(always)]
11596        fn new_empty() -> Self {
11597            Self::Child(fidl::new_empty!(fidl_fuchsia_component_decl__common::ChildRef, D))
11598        }
11599
11600        #[inline]
11601        unsafe fn decode(
11602            &mut self,
11603            decoder: &mut fidl::encoding::Decoder<'_, D>,
11604            offset: usize,
11605            mut depth: fidl::encoding::Depth,
11606        ) -> fidl::Result<()> {
11607            decoder.debug_check_bounds::<Self>(offset);
11608            #[allow(unused_variables)]
11609            let next_out_of_line = decoder.next_out_of_line();
11610            let handles_before = decoder.remaining_handles();
11611            let (ordinal, inlined, num_bytes, num_handles) =
11612                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11613
11614            let member_inline_size = match ordinal {
11615            1 => <fidl_fuchsia_component_decl__common::ChildRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11616            2 => <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11617            3 => <fidl_fuchsia_component_decl__common::ParentRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11618            4 => <fidl_fuchsia_component_decl__common::SelfRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11619            _ => return Err(fidl::Error::UnknownUnionTag),
11620        };
11621
11622            if inlined != (member_inline_size <= 4) {
11623                return Err(fidl::Error::InvalidInlineBitInEnvelope);
11624            }
11625            let _inner_offset;
11626            if inlined {
11627                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11628                _inner_offset = offset + 8;
11629            } else {
11630                depth.increment()?;
11631                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11632            }
11633            match ordinal {
11634                1 => {
11635                    #[allow(irrefutable_let_patterns)]
11636                    if let AggregateMember::Child(_) = self {
11637                        // Do nothing, read the value into the object
11638                    } else {
11639                        // Initialize `self` to the right variant
11640                        *self = AggregateMember::Child(fidl::new_empty!(
11641                            fidl_fuchsia_component_decl__common::ChildRef,
11642                            D
11643                        ));
11644                    }
11645                    #[allow(irrefutable_let_patterns)]
11646                    if let AggregateMember::Child(ref mut val) = self {
11647                        fidl::decode!(
11648                            fidl_fuchsia_component_decl__common::ChildRef,
11649                            D,
11650                            val,
11651                            decoder,
11652                            _inner_offset,
11653                            depth
11654                        )?;
11655                    } else {
11656                        unreachable!()
11657                    }
11658                }
11659                2 => {
11660                    #[allow(irrefutable_let_patterns)]
11661                    if let AggregateMember::Collection(_) = self {
11662                        // Do nothing, read the value into the object
11663                    } else {
11664                        // Initialize `self` to the right variant
11665                        *self = AggregateMember::Collection(fidl::new_empty!(
11666                            fidl::encoding::BoundedString<100>,
11667                            D
11668                        ));
11669                    }
11670                    #[allow(irrefutable_let_patterns)]
11671                    if let AggregateMember::Collection(ref mut val) = self {
11672                        fidl::decode!(
11673                            fidl::encoding::BoundedString<100>,
11674                            D,
11675                            val,
11676                            decoder,
11677                            _inner_offset,
11678                            depth
11679                        )?;
11680                    } else {
11681                        unreachable!()
11682                    }
11683                }
11684                3 => {
11685                    #[allow(irrefutable_let_patterns)]
11686                    if let AggregateMember::Parent(_) = self {
11687                        // Do nothing, read the value into the object
11688                    } else {
11689                        // Initialize `self` to the right variant
11690                        *self = AggregateMember::Parent(fidl::new_empty!(
11691                            fidl_fuchsia_component_decl__common::ParentRef,
11692                            D
11693                        ));
11694                    }
11695                    #[allow(irrefutable_let_patterns)]
11696                    if let AggregateMember::Parent(ref mut val) = self {
11697                        fidl::decode!(
11698                            fidl_fuchsia_component_decl__common::ParentRef,
11699                            D,
11700                            val,
11701                            decoder,
11702                            _inner_offset,
11703                            depth
11704                        )?;
11705                    } else {
11706                        unreachable!()
11707                    }
11708                }
11709                4 => {
11710                    #[allow(irrefutable_let_patterns)]
11711                    if let AggregateMember::Self_(_) = self {
11712                        // Do nothing, read the value into the object
11713                    } else {
11714                        // Initialize `self` to the right variant
11715                        *self = AggregateMember::Self_(fidl::new_empty!(
11716                            fidl_fuchsia_component_decl__common::SelfRef,
11717                            D
11718                        ));
11719                    }
11720                    #[allow(irrefutable_let_patterns)]
11721                    if let AggregateMember::Self_(ref mut val) = self {
11722                        fidl::decode!(
11723                            fidl_fuchsia_component_decl__common::SelfRef,
11724                            D,
11725                            val,
11726                            decoder,
11727                            _inner_offset,
11728                            depth
11729                        )?;
11730                    } else {
11731                        unreachable!()
11732                    }
11733                }
11734                ordinal => panic!("unexpected ordinal {:?}", ordinal),
11735            }
11736            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11737                return Err(fidl::Error::InvalidNumBytesInEnvelope);
11738            }
11739            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11740                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11741            }
11742            Ok(())
11743        }
11744    }
11745
11746    impl fidl::encoding::ValueTypeMarker for AllowlistedCapability {
11747        type Borrowed<'a> = &'a Self;
11748        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11749            value
11750        }
11751    }
11752
11753    unsafe impl fidl::encoding::TypeMarker for AllowlistedCapability {
11754        type Owned = Self;
11755
11756        #[inline(always)]
11757        fn inline_align(_context: fidl::encoding::Context) -> usize {
11758            8
11759        }
11760
11761        #[inline(always)]
11762        fn inline_size(_context: fidl::encoding::Context) -> usize {
11763            16
11764        }
11765    }
11766
11767    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllowlistedCapability, D>
11768        for &AllowlistedCapability
11769    {
11770        #[inline]
11771        unsafe fn encode(
11772            self,
11773            encoder: &mut fidl::encoding::Encoder<'_, D>,
11774            offset: usize,
11775            _depth: fidl::encoding::Depth,
11776        ) -> fidl::Result<()> {
11777            encoder.debug_check_bounds::<AllowlistedCapability>(offset);
11778            encoder.write_num::<u64>(self.ordinal(), offset);
11779            match self {
11780                AllowlistedCapability::Directory(ref val) => {
11781                    fidl::encoding::encode_in_envelope::<AllowlistedDirectory, D>(
11782                        <AllowlistedDirectory as fidl::encoding::ValueTypeMarker>::borrow(val),
11783                        encoder,
11784                        offset + 8,
11785                        _depth,
11786                    )
11787                }
11788                AllowlistedCapability::Protocol(ref val) => {
11789                    fidl::encoding::encode_in_envelope::<AllowlistedProtocol, D>(
11790                        <AllowlistedProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
11791                        encoder,
11792                        offset + 8,
11793                        _depth,
11794                    )
11795                }
11796                AllowlistedCapability::Service(ref val) => {
11797                    fidl::encoding::encode_in_envelope::<AllowlistedService, D>(
11798                        <AllowlistedService as fidl::encoding::ValueTypeMarker>::borrow(val),
11799                        encoder,
11800                        offset + 8,
11801                        _depth,
11802                    )
11803                }
11804                AllowlistedCapability::Storage(ref val) => {
11805                    fidl::encoding::encode_in_envelope::<AllowlistedStorage, D>(
11806                        <AllowlistedStorage as fidl::encoding::ValueTypeMarker>::borrow(val),
11807                        encoder,
11808                        offset + 8,
11809                        _depth,
11810                    )
11811                }
11812                AllowlistedCapability::Runner(ref val) => {
11813                    fidl::encoding::encode_in_envelope::<AllowlistedRunner, D>(
11814                        <AllowlistedRunner as fidl::encoding::ValueTypeMarker>::borrow(val),
11815                        encoder,
11816                        offset + 8,
11817                        _depth,
11818                    )
11819                }
11820                AllowlistedCapability::Resolver(ref val) => {
11821                    fidl::encoding::encode_in_envelope::<AllowlistedResolver, D>(
11822                        <AllowlistedResolver as fidl::encoding::ValueTypeMarker>::borrow(val),
11823                        encoder,
11824                        offset + 8,
11825                        _depth,
11826                    )
11827                }
11828                AllowlistedCapability::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
11829            }
11830        }
11831    }
11832
11833    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowlistedCapability {
11834        #[inline(always)]
11835        fn new_empty() -> Self {
11836            Self::__SourceBreaking { unknown_ordinal: 0 }
11837        }
11838
11839        #[inline]
11840        unsafe fn decode(
11841            &mut self,
11842            decoder: &mut fidl::encoding::Decoder<'_, D>,
11843            offset: usize,
11844            mut depth: fidl::encoding::Depth,
11845        ) -> fidl::Result<()> {
11846            decoder.debug_check_bounds::<Self>(offset);
11847            #[allow(unused_variables)]
11848            let next_out_of_line = decoder.next_out_of_line();
11849            let handles_before = decoder.remaining_handles();
11850            let (ordinal, inlined, num_bytes, num_handles) =
11851                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11852
11853            let member_inline_size = match ordinal {
11854                1 => <AllowlistedDirectory as fidl::encoding::TypeMarker>::inline_size(
11855                    decoder.context,
11856                ),
11857                3 => <AllowlistedProtocol as fidl::encoding::TypeMarker>::inline_size(
11858                    decoder.context,
11859                ),
11860                4 => {
11861                    <AllowlistedService as fidl::encoding::TypeMarker>::inline_size(decoder.context)
11862                }
11863                5 => {
11864                    <AllowlistedStorage as fidl::encoding::TypeMarker>::inline_size(decoder.context)
11865                }
11866                6 => {
11867                    <AllowlistedRunner as fidl::encoding::TypeMarker>::inline_size(decoder.context)
11868                }
11869                7 => <AllowlistedResolver as fidl::encoding::TypeMarker>::inline_size(
11870                    decoder.context,
11871                ),
11872                0 => return Err(fidl::Error::UnknownUnionTag),
11873                _ => num_bytes as usize,
11874            };
11875
11876            if inlined != (member_inline_size <= 4) {
11877                return Err(fidl::Error::InvalidInlineBitInEnvelope);
11878            }
11879            let _inner_offset;
11880            if inlined {
11881                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11882                _inner_offset = offset + 8;
11883            } else {
11884                depth.increment()?;
11885                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11886            }
11887            match ordinal {
11888                1 => {
11889                    #[allow(irrefutable_let_patterns)]
11890                    if let AllowlistedCapability::Directory(_) = self {
11891                        // Do nothing, read the value into the object
11892                    } else {
11893                        // Initialize `self` to the right variant
11894                        *self = AllowlistedCapability::Directory(fidl::new_empty!(
11895                            AllowlistedDirectory,
11896                            D
11897                        ));
11898                    }
11899                    #[allow(irrefutable_let_patterns)]
11900                    if let AllowlistedCapability::Directory(ref mut val) = self {
11901                        fidl::decode!(AllowlistedDirectory, D, val, decoder, _inner_offset, depth)?;
11902                    } else {
11903                        unreachable!()
11904                    }
11905                }
11906                3 => {
11907                    #[allow(irrefutable_let_patterns)]
11908                    if let AllowlistedCapability::Protocol(_) = self {
11909                        // Do nothing, read the value into the object
11910                    } else {
11911                        // Initialize `self` to the right variant
11912                        *self = AllowlistedCapability::Protocol(fidl::new_empty!(
11913                            AllowlistedProtocol,
11914                            D
11915                        ));
11916                    }
11917                    #[allow(irrefutable_let_patterns)]
11918                    if let AllowlistedCapability::Protocol(ref mut val) = self {
11919                        fidl::decode!(AllowlistedProtocol, D, val, decoder, _inner_offset, depth)?;
11920                    } else {
11921                        unreachable!()
11922                    }
11923                }
11924                4 => {
11925                    #[allow(irrefutable_let_patterns)]
11926                    if let AllowlistedCapability::Service(_) = self {
11927                        // Do nothing, read the value into the object
11928                    } else {
11929                        // Initialize `self` to the right variant
11930                        *self =
11931                            AllowlistedCapability::Service(fidl::new_empty!(AllowlistedService, D));
11932                    }
11933                    #[allow(irrefutable_let_patterns)]
11934                    if let AllowlistedCapability::Service(ref mut val) = self {
11935                        fidl::decode!(AllowlistedService, D, val, decoder, _inner_offset, depth)?;
11936                    } else {
11937                        unreachable!()
11938                    }
11939                }
11940                5 => {
11941                    #[allow(irrefutable_let_patterns)]
11942                    if let AllowlistedCapability::Storage(_) = self {
11943                        // Do nothing, read the value into the object
11944                    } else {
11945                        // Initialize `self` to the right variant
11946                        *self =
11947                            AllowlistedCapability::Storage(fidl::new_empty!(AllowlistedStorage, D));
11948                    }
11949                    #[allow(irrefutable_let_patterns)]
11950                    if let AllowlistedCapability::Storage(ref mut val) = self {
11951                        fidl::decode!(AllowlistedStorage, D, val, decoder, _inner_offset, depth)?;
11952                    } else {
11953                        unreachable!()
11954                    }
11955                }
11956                6 => {
11957                    #[allow(irrefutable_let_patterns)]
11958                    if let AllowlistedCapability::Runner(_) = self {
11959                        // Do nothing, read the value into the object
11960                    } else {
11961                        // Initialize `self` to the right variant
11962                        *self =
11963                            AllowlistedCapability::Runner(fidl::new_empty!(AllowlistedRunner, D));
11964                    }
11965                    #[allow(irrefutable_let_patterns)]
11966                    if let AllowlistedCapability::Runner(ref mut val) = self {
11967                        fidl::decode!(AllowlistedRunner, D, val, decoder, _inner_offset, depth)?;
11968                    } else {
11969                        unreachable!()
11970                    }
11971                }
11972                7 => {
11973                    #[allow(irrefutable_let_patterns)]
11974                    if let AllowlistedCapability::Resolver(_) = self {
11975                        // Do nothing, read the value into the object
11976                    } else {
11977                        // Initialize `self` to the right variant
11978                        *self = AllowlistedCapability::Resolver(fidl::new_empty!(
11979                            AllowlistedResolver,
11980                            D
11981                        ));
11982                    }
11983                    #[allow(irrefutable_let_patterns)]
11984                    if let AllowlistedCapability::Resolver(ref mut val) = self {
11985                        fidl::decode!(AllowlistedResolver, D, val, decoder, _inner_offset, depth)?;
11986                    } else {
11987                        unreachable!()
11988                    }
11989                }
11990                #[allow(deprecated)]
11991                ordinal => {
11992                    for _ in 0..num_handles {
11993                        decoder.drop_next_handle()?;
11994                    }
11995                    *self = AllowlistedCapability::__SourceBreaking { unknown_ordinal: ordinal };
11996                }
11997            }
11998            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11999                return Err(fidl::Error::InvalidNumBytesInEnvelope);
12000            }
12001            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12002                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12003            }
12004            Ok(())
12005        }
12006    }
12007
12008    impl fidl::encoding::ValueTypeMarker for AllowlistedDebugRegistration {
12009        type Borrowed<'a> = &'a Self;
12010        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12011            value
12012        }
12013    }
12014
12015    unsafe impl fidl::encoding::TypeMarker for AllowlistedDebugRegistration {
12016        type Owned = Self;
12017
12018        #[inline(always)]
12019        fn inline_align(_context: fidl::encoding::Context) -> usize {
12020            8
12021        }
12022
12023        #[inline(always)]
12024        fn inline_size(_context: fidl::encoding::Context) -> usize {
12025            16
12026        }
12027    }
12028
12029    unsafe impl<D: fidl::encoding::ResourceDialect>
12030        fidl::encoding::Encode<AllowlistedDebugRegistration, D> for &AllowlistedDebugRegistration
12031    {
12032        #[inline]
12033        unsafe fn encode(
12034            self,
12035            encoder: &mut fidl::encoding::Encoder<'_, D>,
12036            offset: usize,
12037            _depth: fidl::encoding::Depth,
12038        ) -> fidl::Result<()> {
12039            encoder.debug_check_bounds::<AllowlistedDebugRegistration>(offset);
12040            encoder.write_num::<u64>(self.ordinal(), offset);
12041            match self {
12042                AllowlistedDebugRegistration::Protocol(ref val) => {
12043                    fidl::encoding::encode_in_envelope::<AllowlistedProtocol, D>(
12044                        <AllowlistedProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
12045                        encoder,
12046                        offset + 8,
12047                        _depth,
12048                    )
12049                }
12050                AllowlistedDebugRegistration::__SourceBreaking { .. } => {
12051                    Err(fidl::Error::UnknownUnionTag)
12052                }
12053            }
12054        }
12055    }
12056
12057    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12058        for AllowlistedDebugRegistration
12059    {
12060        #[inline(always)]
12061        fn new_empty() -> Self {
12062            Self::__SourceBreaking { unknown_ordinal: 0 }
12063        }
12064
12065        #[inline]
12066        unsafe fn decode(
12067            &mut self,
12068            decoder: &mut fidl::encoding::Decoder<'_, D>,
12069            offset: usize,
12070            mut depth: fidl::encoding::Depth,
12071        ) -> fidl::Result<()> {
12072            decoder.debug_check_bounds::<Self>(offset);
12073            #[allow(unused_variables)]
12074            let next_out_of_line = decoder.next_out_of_line();
12075            let handles_before = decoder.remaining_handles();
12076            let (ordinal, inlined, num_bytes, num_handles) =
12077                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
12078
12079            let member_inline_size = match ordinal {
12080                1 => <AllowlistedProtocol as fidl::encoding::TypeMarker>::inline_size(
12081                    decoder.context,
12082                ),
12083                0 => return Err(fidl::Error::UnknownUnionTag),
12084                _ => num_bytes as usize,
12085            };
12086
12087            if inlined != (member_inline_size <= 4) {
12088                return Err(fidl::Error::InvalidInlineBitInEnvelope);
12089            }
12090            let _inner_offset;
12091            if inlined {
12092                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
12093                _inner_offset = offset + 8;
12094            } else {
12095                depth.increment()?;
12096                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12097            }
12098            match ordinal {
12099                1 => {
12100                    #[allow(irrefutable_let_patterns)]
12101                    if let AllowlistedDebugRegistration::Protocol(_) = self {
12102                        // Do nothing, read the value into the object
12103                    } else {
12104                        // Initialize `self` to the right variant
12105                        *self = AllowlistedDebugRegistration::Protocol(fidl::new_empty!(
12106                            AllowlistedProtocol,
12107                            D
12108                        ));
12109                    }
12110                    #[allow(irrefutable_let_patterns)]
12111                    if let AllowlistedDebugRegistration::Protocol(ref mut val) = self {
12112                        fidl::decode!(AllowlistedProtocol, D, val, decoder, _inner_offset, depth)?;
12113                    } else {
12114                        unreachable!()
12115                    }
12116                }
12117                #[allow(deprecated)]
12118                ordinal => {
12119                    for _ in 0..num_handles {
12120                        decoder.drop_next_handle()?;
12121                    }
12122                    *self =
12123                        AllowlistedDebugRegistration::__SourceBreaking { unknown_ordinal: ordinal };
12124                }
12125            }
12126            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
12127                return Err(fidl::Error::InvalidNumBytesInEnvelope);
12128            }
12129            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12130                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12131            }
12132            Ok(())
12133        }
12134    }
12135
12136    impl fidl::encoding::ValueTypeMarker for CapabilitySource {
12137        type Borrowed<'a> = &'a Self;
12138        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12139            value
12140        }
12141    }
12142
12143    unsafe impl fidl::encoding::TypeMarker for CapabilitySource {
12144        type Owned = Self;
12145
12146        #[inline(always)]
12147        fn inline_align(_context: fidl::encoding::Context) -> usize {
12148            8
12149        }
12150
12151        #[inline(always)]
12152        fn inline_size(_context: fidl::encoding::Context) -> usize {
12153            16
12154        }
12155    }
12156
12157    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CapabilitySource, D>
12158        for &CapabilitySource
12159    {
12160        #[inline]
12161        unsafe fn encode(
12162            self,
12163            encoder: &mut fidl::encoding::Encoder<'_, D>,
12164            offset: usize,
12165            _depth: fidl::encoding::Depth,
12166        ) -> fidl::Result<()> {
12167            encoder.debug_check_bounds::<CapabilitySource>(offset);
12168            encoder.write_num::<u64>(self.ordinal(), offset);
12169            match self {
12170                CapabilitySource::Component(ref val) => {
12171                    fidl::encoding::encode_in_envelope::<Component, D>(
12172                        <Component as fidl::encoding::ValueTypeMarker>::borrow(val),
12173                        encoder,
12174                        offset + 8,
12175                        _depth,
12176                    )
12177                }
12178                CapabilitySource::Framework(ref val) => {
12179                    fidl::encoding::encode_in_envelope::<Framework, D>(
12180                        <Framework as fidl::encoding::ValueTypeMarker>::borrow(val),
12181                        encoder,
12182                        offset + 8,
12183                        _depth,
12184                    )
12185                }
12186                CapabilitySource::Builtin(ref val) => {
12187                    fidl::encoding::encode_in_envelope::<Builtin, D>(
12188                        <Builtin as fidl::encoding::ValueTypeMarker>::borrow(val),
12189                        encoder,
12190                        offset + 8,
12191                        _depth,
12192                    )
12193                }
12194                CapabilitySource::Namespace(ref val) => {
12195                    fidl::encoding::encode_in_envelope::<Namespace, D>(
12196                        <Namespace as fidl::encoding::ValueTypeMarker>::borrow(val),
12197                        encoder,
12198                        offset + 8,
12199                        _depth,
12200                    )
12201                }
12202                CapabilitySource::Capability(ref val) => {
12203                    fidl::encoding::encode_in_envelope::<Capability, D>(
12204                        <Capability as fidl::encoding::ValueTypeMarker>::borrow(val),
12205                        encoder,
12206                        offset + 8,
12207                        _depth,
12208                    )
12209                }
12210                CapabilitySource::AnonymizedAggregate(ref val) => {
12211                    fidl::encoding::encode_in_envelope::<AnonymizedAggregate, D>(
12212                        <AnonymizedAggregate as fidl::encoding::ValueTypeMarker>::borrow(val),
12213                        encoder,
12214                        offset + 8,
12215                        _depth,
12216                    )
12217                }
12218                CapabilitySource::FilteredProvider(ref val) => {
12219                    fidl::encoding::encode_in_envelope::<FilteredProvider, D>(
12220                        <FilteredProvider as fidl::encoding::ValueTypeMarker>::borrow(val),
12221                        encoder,
12222                        offset + 8,
12223                        _depth,
12224                    )
12225                }
12226                CapabilitySource::FilteredAggregateProvider(ref val) => {
12227                    fidl::encoding::encode_in_envelope::<FilteredAggregateProvider, D>(
12228                        <FilteredAggregateProvider as fidl::encoding::ValueTypeMarker>::borrow(val),
12229                        encoder,
12230                        offset + 8,
12231                        _depth,
12232                    )
12233                }
12234                CapabilitySource::Environment(ref val) => {
12235                    fidl::encoding::encode_in_envelope::<Environment, D>(
12236                        <Environment as fidl::encoding::ValueTypeMarker>::borrow(val),
12237                        encoder,
12238                        offset + 8,
12239                        _depth,
12240                    )
12241                }
12242                CapabilitySource::Void(ref val) => fidl::encoding::encode_in_envelope::<Void, D>(
12243                    <Void as fidl::encoding::ValueTypeMarker>::borrow(val),
12244                    encoder,
12245                    offset + 8,
12246                    _depth,
12247                ),
12248                CapabilitySource::RemotedAt(ref val) => {
12249                    fidl::encoding::encode_in_envelope::<RemotedAt, D>(
12250                        <RemotedAt as fidl::encoding::ValueTypeMarker>::borrow(val),
12251                        encoder,
12252                        offset + 8,
12253                        _depth,
12254                    )
12255                }
12256                CapabilitySource::StorageBackingDirectory(ref val) => {
12257                    fidl::encoding::encode_in_envelope::<StorageBackingDirectory, D>(
12258                        <StorageBackingDirectory as fidl::encoding::ValueTypeMarker>::borrow(val),
12259                        encoder,
12260                        offset + 8,
12261                        _depth,
12262                    )
12263                }
12264            }
12265        }
12266    }
12267
12268    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CapabilitySource {
12269        #[inline(always)]
12270        fn new_empty() -> Self {
12271            Self::Component(fidl::new_empty!(Component, D))
12272        }
12273
12274        #[inline]
12275        unsafe fn decode(
12276            &mut self,
12277            decoder: &mut fidl::encoding::Decoder<'_, D>,
12278            offset: usize,
12279            mut depth: fidl::encoding::Depth,
12280        ) -> fidl::Result<()> {
12281            decoder.debug_check_bounds::<Self>(offset);
12282            #[allow(unused_variables)]
12283            let next_out_of_line = decoder.next_out_of_line();
12284            let handles_before = decoder.remaining_handles();
12285            let (ordinal, inlined, num_bytes, num_handles) =
12286                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
12287
12288            let member_inline_size = match ordinal {
12289                1 => <Component as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12290                2 => <Framework as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12291                3 => <Builtin as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12292                4 => <Namespace as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12293                5 => <Capability as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12294                6 => <AnonymizedAggregate as fidl::encoding::TypeMarker>::inline_size(
12295                    decoder.context,
12296                ),
12297                7 => <FilteredProvider as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12298                8 => <FilteredAggregateProvider as fidl::encoding::TypeMarker>::inline_size(
12299                    decoder.context,
12300                ),
12301                9 => <Environment as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12302                10 => <Void as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12303                11 => <RemotedAt as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12304                12 => <StorageBackingDirectory as fidl::encoding::TypeMarker>::inline_size(
12305                    decoder.context,
12306                ),
12307                _ => return Err(fidl::Error::UnknownUnionTag),
12308            };
12309
12310            if inlined != (member_inline_size <= 4) {
12311                return Err(fidl::Error::InvalidInlineBitInEnvelope);
12312            }
12313            let _inner_offset;
12314            if inlined {
12315                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
12316                _inner_offset = offset + 8;
12317            } else {
12318                depth.increment()?;
12319                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12320            }
12321            match ordinal {
12322                1 => {
12323                    #[allow(irrefutable_let_patterns)]
12324                    if let CapabilitySource::Component(_) = self {
12325                        // Do nothing, read the value into the object
12326                    } else {
12327                        // Initialize `self` to the right variant
12328                        *self = CapabilitySource::Component(fidl::new_empty!(Component, D));
12329                    }
12330                    #[allow(irrefutable_let_patterns)]
12331                    if let CapabilitySource::Component(ref mut val) = self {
12332                        fidl::decode!(Component, D, val, decoder, _inner_offset, depth)?;
12333                    } else {
12334                        unreachable!()
12335                    }
12336                }
12337                2 => {
12338                    #[allow(irrefutable_let_patterns)]
12339                    if let CapabilitySource::Framework(_) = self {
12340                        // Do nothing, read the value into the object
12341                    } else {
12342                        // Initialize `self` to the right variant
12343                        *self = CapabilitySource::Framework(fidl::new_empty!(Framework, D));
12344                    }
12345                    #[allow(irrefutable_let_patterns)]
12346                    if let CapabilitySource::Framework(ref mut val) = self {
12347                        fidl::decode!(Framework, D, val, decoder, _inner_offset, depth)?;
12348                    } else {
12349                        unreachable!()
12350                    }
12351                }
12352                3 => {
12353                    #[allow(irrefutable_let_patterns)]
12354                    if let CapabilitySource::Builtin(_) = self {
12355                        // Do nothing, read the value into the object
12356                    } else {
12357                        // Initialize `self` to the right variant
12358                        *self = CapabilitySource::Builtin(fidl::new_empty!(Builtin, D));
12359                    }
12360                    #[allow(irrefutable_let_patterns)]
12361                    if let CapabilitySource::Builtin(ref mut val) = self {
12362                        fidl::decode!(Builtin, D, val, decoder, _inner_offset, depth)?;
12363                    } else {
12364                        unreachable!()
12365                    }
12366                }
12367                4 => {
12368                    #[allow(irrefutable_let_patterns)]
12369                    if let CapabilitySource::Namespace(_) = self {
12370                        // Do nothing, read the value into the object
12371                    } else {
12372                        // Initialize `self` to the right variant
12373                        *self = CapabilitySource::Namespace(fidl::new_empty!(Namespace, D));
12374                    }
12375                    #[allow(irrefutable_let_patterns)]
12376                    if let CapabilitySource::Namespace(ref mut val) = self {
12377                        fidl::decode!(Namespace, D, val, decoder, _inner_offset, depth)?;
12378                    } else {
12379                        unreachable!()
12380                    }
12381                }
12382                5 => {
12383                    #[allow(irrefutable_let_patterns)]
12384                    if let CapabilitySource::Capability(_) = self {
12385                        // Do nothing, read the value into the object
12386                    } else {
12387                        // Initialize `self` to the right variant
12388                        *self = CapabilitySource::Capability(fidl::new_empty!(Capability, D));
12389                    }
12390                    #[allow(irrefutable_let_patterns)]
12391                    if let CapabilitySource::Capability(ref mut val) = self {
12392                        fidl::decode!(Capability, D, val, decoder, _inner_offset, depth)?;
12393                    } else {
12394                        unreachable!()
12395                    }
12396                }
12397                6 => {
12398                    #[allow(irrefutable_let_patterns)]
12399                    if let CapabilitySource::AnonymizedAggregate(_) = self {
12400                        // Do nothing, read the value into the object
12401                    } else {
12402                        // Initialize `self` to the right variant
12403                        *self = CapabilitySource::AnonymizedAggregate(fidl::new_empty!(
12404                            AnonymizedAggregate,
12405                            D
12406                        ));
12407                    }
12408                    #[allow(irrefutable_let_patterns)]
12409                    if let CapabilitySource::AnonymizedAggregate(ref mut val) = self {
12410                        fidl::decode!(AnonymizedAggregate, D, val, decoder, _inner_offset, depth)?;
12411                    } else {
12412                        unreachable!()
12413                    }
12414                }
12415                7 => {
12416                    #[allow(irrefutable_let_patterns)]
12417                    if let CapabilitySource::FilteredProvider(_) = self {
12418                        // Do nothing, read the value into the object
12419                    } else {
12420                        // Initialize `self` to the right variant
12421                        *self = CapabilitySource::FilteredProvider(fidl::new_empty!(
12422                            FilteredProvider,
12423                            D
12424                        ));
12425                    }
12426                    #[allow(irrefutable_let_patterns)]
12427                    if let CapabilitySource::FilteredProvider(ref mut val) = self {
12428                        fidl::decode!(FilteredProvider, D, val, decoder, _inner_offset, depth)?;
12429                    } else {
12430                        unreachable!()
12431                    }
12432                }
12433                8 => {
12434                    #[allow(irrefutable_let_patterns)]
12435                    if let CapabilitySource::FilteredAggregateProvider(_) = self {
12436                        // Do nothing, read the value into the object
12437                    } else {
12438                        // Initialize `self` to the right variant
12439                        *self = CapabilitySource::FilteredAggregateProvider(fidl::new_empty!(
12440                            FilteredAggregateProvider,
12441                            D
12442                        ));
12443                    }
12444                    #[allow(irrefutable_let_patterns)]
12445                    if let CapabilitySource::FilteredAggregateProvider(ref mut val) = self {
12446                        fidl::decode!(
12447                            FilteredAggregateProvider,
12448                            D,
12449                            val,
12450                            decoder,
12451                            _inner_offset,
12452                            depth
12453                        )?;
12454                    } else {
12455                        unreachable!()
12456                    }
12457                }
12458                9 => {
12459                    #[allow(irrefutable_let_patterns)]
12460                    if let CapabilitySource::Environment(_) = self {
12461                        // Do nothing, read the value into the object
12462                    } else {
12463                        // Initialize `self` to the right variant
12464                        *self = CapabilitySource::Environment(fidl::new_empty!(Environment, D));
12465                    }
12466                    #[allow(irrefutable_let_patterns)]
12467                    if let CapabilitySource::Environment(ref mut val) = self {
12468                        fidl::decode!(Environment, D, val, decoder, _inner_offset, depth)?;
12469                    } else {
12470                        unreachable!()
12471                    }
12472                }
12473                10 => {
12474                    #[allow(irrefutable_let_patterns)]
12475                    if let CapabilitySource::Void(_) = self {
12476                        // Do nothing, read the value into the object
12477                    } else {
12478                        // Initialize `self` to the right variant
12479                        *self = CapabilitySource::Void(fidl::new_empty!(Void, D));
12480                    }
12481                    #[allow(irrefutable_let_patterns)]
12482                    if let CapabilitySource::Void(ref mut val) = self {
12483                        fidl::decode!(Void, D, val, decoder, _inner_offset, depth)?;
12484                    } else {
12485                        unreachable!()
12486                    }
12487                }
12488                11 => {
12489                    #[allow(irrefutable_let_patterns)]
12490                    if let CapabilitySource::RemotedAt(_) = self {
12491                        // Do nothing, read the value into the object
12492                    } else {
12493                        // Initialize `self` to the right variant
12494                        *self = CapabilitySource::RemotedAt(fidl::new_empty!(RemotedAt, D));
12495                    }
12496                    #[allow(irrefutable_let_patterns)]
12497                    if let CapabilitySource::RemotedAt(ref mut val) = self {
12498                        fidl::decode!(RemotedAt, D, val, decoder, _inner_offset, depth)?;
12499                    } else {
12500                        unreachable!()
12501                    }
12502                }
12503                12 => {
12504                    #[allow(irrefutable_let_patterns)]
12505                    if let CapabilitySource::StorageBackingDirectory(_) = self {
12506                        // Do nothing, read the value into the object
12507                    } else {
12508                        // Initialize `self` to the right variant
12509                        *self = CapabilitySource::StorageBackingDirectory(fidl::new_empty!(
12510                            StorageBackingDirectory,
12511                            D
12512                        ));
12513                    }
12514                    #[allow(irrefutable_let_patterns)]
12515                    if let CapabilitySource::StorageBackingDirectory(ref mut val) = self {
12516                        fidl::decode!(
12517                            StorageBackingDirectory,
12518                            D,
12519                            val,
12520                            decoder,
12521                            _inner_offset,
12522                            depth
12523                        )?;
12524                    } else {
12525                        unreachable!()
12526                    }
12527                }
12528                ordinal => panic!("unexpected ordinal {:?}", ordinal),
12529            }
12530            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
12531                return Err(fidl::Error::InvalidNumBytesInEnvelope);
12532            }
12533            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12534                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12535            }
12536            Ok(())
12537        }
12538    }
12539
12540    impl fidl::encoding::ValueTypeMarker for ComponentCapability {
12541        type Borrowed<'a> = &'a Self;
12542        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12543            value
12544        }
12545    }
12546
12547    unsafe impl fidl::encoding::TypeMarker for ComponentCapability {
12548        type Owned = Self;
12549
12550        #[inline(always)]
12551        fn inline_align(_context: fidl::encoding::Context) -> usize {
12552            8
12553        }
12554
12555        #[inline(always)]
12556        fn inline_size(_context: fidl::encoding::Context) -> usize {
12557            16
12558        }
12559    }
12560
12561    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ComponentCapability, D>
12562        for &ComponentCapability
12563    {
12564        #[inline]
12565        unsafe fn encode(
12566            self,
12567            encoder: &mut fidl::encoding::Encoder<'_, D>,
12568            offset: usize,
12569            _depth: fidl::encoding::Depth,
12570        ) -> fidl::Result<()> {
12571            encoder.debug_check_bounds::<ComponentCapability>(offset);
12572            encoder.write_num::<u64>(self.ordinal(), offset);
12573            match self {
12574            ComponentCapability::Use_(ref val) => {
12575                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Use, D>(
12576                    <fidl_fuchsia_component_decl__common::Use as fidl::encoding::ValueTypeMarker>::borrow(val),
12577                    encoder, offset + 8, _depth
12578                )
12579            }
12580            ComponentCapability::Offer(ref val) => {
12581                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Offer, D>(
12582                    <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::ValueTypeMarker>::borrow(val),
12583                    encoder, offset + 8, _depth
12584                )
12585            }
12586            ComponentCapability::Expose(ref val) => {
12587                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Expose, D>(
12588                    <fidl_fuchsia_component_decl__common::Expose as fidl::encoding::ValueTypeMarker>::borrow(val),
12589                    encoder, offset + 8, _depth
12590                )
12591            }
12592            ComponentCapability::Config(ref val) => {
12593                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Configuration, D>(
12594                    <fidl_fuchsia_component_decl__common::Configuration as fidl::encoding::ValueTypeMarker>::borrow(val),
12595                    encoder, offset + 8, _depth
12596                )
12597            }
12598            ComponentCapability::Dictionary(ref val) => {
12599                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Dictionary, D>(
12600                    <fidl_fuchsia_component_decl__common::Dictionary as fidl::encoding::ValueTypeMarker>::borrow(val),
12601                    encoder, offset + 8, _depth
12602                )
12603            }
12604            ComponentCapability::Directory(ref val) => {
12605                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Directory, D>(
12606                    <fidl_fuchsia_component_decl__common::Directory as fidl::encoding::ValueTypeMarker>::borrow(val),
12607                    encoder, offset + 8, _depth
12608                )
12609            }
12610            ComponentCapability::Environment(ref val) => {
12611                fidl::encoding::encode_in_envelope::<EnvironmentCapability, D>(
12612                    <EnvironmentCapability as fidl::encoding::ValueTypeMarker>::borrow(val),
12613                    encoder, offset + 8, _depth
12614                )
12615            }
12616            ComponentCapability::EventStream(ref val) => {
12617                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::EventStream, D>(
12618                    <fidl_fuchsia_component_decl__common::EventStream as fidl::encoding::ValueTypeMarker>::borrow(val),
12619                    encoder, offset + 8, _depth
12620                )
12621            }
12622            ComponentCapability::Protocol(ref val) => {
12623                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Protocol, D>(
12624                    <fidl_fuchsia_component_decl__common::Protocol as fidl::encoding::ValueTypeMarker>::borrow(val),
12625                    encoder, offset + 8, _depth
12626                )
12627            }
12628            ComponentCapability::Resolver(ref val) => {
12629                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Resolver, D>(
12630                    <fidl_fuchsia_component_decl__common::Resolver as fidl::encoding::ValueTypeMarker>::borrow(val),
12631                    encoder, offset + 8, _depth
12632                )
12633            }
12634            ComponentCapability::Runner(ref val) => {
12635                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Runner, D>(
12636                    <fidl_fuchsia_component_decl__common::Runner as fidl::encoding::ValueTypeMarker>::borrow(val),
12637                    encoder, offset + 8, _depth
12638                )
12639            }
12640            ComponentCapability::Service(ref val) => {
12641                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Service, D>(
12642                    <fidl_fuchsia_component_decl__common::Service as fidl::encoding::ValueTypeMarker>::borrow(val),
12643                    encoder, offset + 8, _depth
12644                )
12645            }
12646            ComponentCapability::Storage(ref val) => {
12647                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Storage, D>(
12648                    <fidl_fuchsia_component_decl__common::Storage as fidl::encoding::ValueTypeMarker>::borrow(val),
12649                    encoder, offset + 8, _depth
12650                )
12651            }
12652        }
12653        }
12654    }
12655
12656    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ComponentCapability {
12657        #[inline(always)]
12658        fn new_empty() -> Self {
12659            Self::Use_(fidl::new_empty!(fidl_fuchsia_component_decl__common::Use, D))
12660        }
12661
12662        #[inline]
12663        unsafe fn decode(
12664            &mut self,
12665            decoder: &mut fidl::encoding::Decoder<'_, D>,
12666            offset: usize,
12667            mut depth: fidl::encoding::Depth,
12668        ) -> fidl::Result<()> {
12669            decoder.debug_check_bounds::<Self>(offset);
12670            #[allow(unused_variables)]
12671            let next_out_of_line = decoder.next_out_of_line();
12672            let handles_before = decoder.remaining_handles();
12673            let (ordinal, inlined, num_bytes, num_handles) =
12674                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
12675
12676            let member_inline_size = match ordinal {
12677            1 => <fidl_fuchsia_component_decl__common::Use as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12678            2 => <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12679            3 => <fidl_fuchsia_component_decl__common::Expose as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12680            4 => <fidl_fuchsia_component_decl__common::Configuration as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12681            5 => <fidl_fuchsia_component_decl__common::Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12682            6 => <fidl_fuchsia_component_decl__common::Directory as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12683            7 => <EnvironmentCapability as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12684            8 => <fidl_fuchsia_component_decl__common::EventStream as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12685            9 => <fidl_fuchsia_component_decl__common::Protocol as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12686            10 => <fidl_fuchsia_component_decl__common::Resolver as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12687            11 => <fidl_fuchsia_component_decl__common::Runner as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12688            12 => <fidl_fuchsia_component_decl__common::Service as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12689            13 => <fidl_fuchsia_component_decl__common::Storage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12690            _ => return Err(fidl::Error::UnknownUnionTag),
12691        };
12692
12693            if inlined != (member_inline_size <= 4) {
12694                return Err(fidl::Error::InvalidInlineBitInEnvelope);
12695            }
12696            let _inner_offset;
12697            if inlined {
12698                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
12699                _inner_offset = offset + 8;
12700            } else {
12701                depth.increment()?;
12702                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12703            }
12704            match ordinal {
12705                1 => {
12706                    #[allow(irrefutable_let_patterns)]
12707                    if let ComponentCapability::Use_(_) = self {
12708                        // Do nothing, read the value into the object
12709                    } else {
12710                        // Initialize `self` to the right variant
12711                        *self = ComponentCapability::Use_(fidl::new_empty!(
12712                            fidl_fuchsia_component_decl__common::Use,
12713                            D
12714                        ));
12715                    }
12716                    #[allow(irrefutable_let_patterns)]
12717                    if let ComponentCapability::Use_(ref mut val) = self {
12718                        fidl::decode!(
12719                            fidl_fuchsia_component_decl__common::Use,
12720                            D,
12721                            val,
12722                            decoder,
12723                            _inner_offset,
12724                            depth
12725                        )?;
12726                    } else {
12727                        unreachable!()
12728                    }
12729                }
12730                2 => {
12731                    #[allow(irrefutable_let_patterns)]
12732                    if let ComponentCapability::Offer(_) = self {
12733                        // Do nothing, read the value into the object
12734                    } else {
12735                        // Initialize `self` to the right variant
12736                        *self = ComponentCapability::Offer(fidl::new_empty!(
12737                            fidl_fuchsia_component_decl__common::Offer,
12738                            D
12739                        ));
12740                    }
12741                    #[allow(irrefutable_let_patterns)]
12742                    if let ComponentCapability::Offer(ref mut val) = self {
12743                        fidl::decode!(
12744                            fidl_fuchsia_component_decl__common::Offer,
12745                            D,
12746                            val,
12747                            decoder,
12748                            _inner_offset,
12749                            depth
12750                        )?;
12751                    } else {
12752                        unreachable!()
12753                    }
12754                }
12755                3 => {
12756                    #[allow(irrefutable_let_patterns)]
12757                    if let ComponentCapability::Expose(_) = self {
12758                        // Do nothing, read the value into the object
12759                    } else {
12760                        // Initialize `self` to the right variant
12761                        *self = ComponentCapability::Expose(fidl::new_empty!(
12762                            fidl_fuchsia_component_decl__common::Expose,
12763                            D
12764                        ));
12765                    }
12766                    #[allow(irrefutable_let_patterns)]
12767                    if let ComponentCapability::Expose(ref mut val) = self {
12768                        fidl::decode!(
12769                            fidl_fuchsia_component_decl__common::Expose,
12770                            D,
12771                            val,
12772                            decoder,
12773                            _inner_offset,
12774                            depth
12775                        )?;
12776                    } else {
12777                        unreachable!()
12778                    }
12779                }
12780                4 => {
12781                    #[allow(irrefutable_let_patterns)]
12782                    if let ComponentCapability::Config(_) = self {
12783                        // Do nothing, read the value into the object
12784                    } else {
12785                        // Initialize `self` to the right variant
12786                        *self = ComponentCapability::Config(fidl::new_empty!(
12787                            fidl_fuchsia_component_decl__common::Configuration,
12788                            D
12789                        ));
12790                    }
12791                    #[allow(irrefutable_let_patterns)]
12792                    if let ComponentCapability::Config(ref mut val) = self {
12793                        fidl::decode!(
12794                            fidl_fuchsia_component_decl__common::Configuration,
12795                            D,
12796                            val,
12797                            decoder,
12798                            _inner_offset,
12799                            depth
12800                        )?;
12801                    } else {
12802                        unreachable!()
12803                    }
12804                }
12805                5 => {
12806                    #[allow(irrefutable_let_patterns)]
12807                    if let ComponentCapability::Dictionary(_) = self {
12808                        // Do nothing, read the value into the object
12809                    } else {
12810                        // Initialize `self` to the right variant
12811                        *self = ComponentCapability::Dictionary(fidl::new_empty!(
12812                            fidl_fuchsia_component_decl__common::Dictionary,
12813                            D
12814                        ));
12815                    }
12816                    #[allow(irrefutable_let_patterns)]
12817                    if let ComponentCapability::Dictionary(ref mut val) = self {
12818                        fidl::decode!(
12819                            fidl_fuchsia_component_decl__common::Dictionary,
12820                            D,
12821                            val,
12822                            decoder,
12823                            _inner_offset,
12824                            depth
12825                        )?;
12826                    } else {
12827                        unreachable!()
12828                    }
12829                }
12830                6 => {
12831                    #[allow(irrefutable_let_patterns)]
12832                    if let ComponentCapability::Directory(_) = self {
12833                        // Do nothing, read the value into the object
12834                    } else {
12835                        // Initialize `self` to the right variant
12836                        *self = ComponentCapability::Directory(fidl::new_empty!(
12837                            fidl_fuchsia_component_decl__common::Directory,
12838                            D
12839                        ));
12840                    }
12841                    #[allow(irrefutable_let_patterns)]
12842                    if let ComponentCapability::Directory(ref mut val) = self {
12843                        fidl::decode!(
12844                            fidl_fuchsia_component_decl__common::Directory,
12845                            D,
12846                            val,
12847                            decoder,
12848                            _inner_offset,
12849                            depth
12850                        )?;
12851                    } else {
12852                        unreachable!()
12853                    }
12854                }
12855                7 => {
12856                    #[allow(irrefutable_let_patterns)]
12857                    if let ComponentCapability::Environment(_) = self {
12858                        // Do nothing, read the value into the object
12859                    } else {
12860                        // Initialize `self` to the right variant
12861                        *self = ComponentCapability::Environment(fidl::new_empty!(
12862                            EnvironmentCapability,
12863                            D
12864                        ));
12865                    }
12866                    #[allow(irrefutable_let_patterns)]
12867                    if let ComponentCapability::Environment(ref mut val) = self {
12868                        fidl::decode!(
12869                            EnvironmentCapability,
12870                            D,
12871                            val,
12872                            decoder,
12873                            _inner_offset,
12874                            depth
12875                        )?;
12876                    } else {
12877                        unreachable!()
12878                    }
12879                }
12880                8 => {
12881                    #[allow(irrefutable_let_patterns)]
12882                    if let ComponentCapability::EventStream(_) = self {
12883                        // Do nothing, read the value into the object
12884                    } else {
12885                        // Initialize `self` to the right variant
12886                        *self = ComponentCapability::EventStream(fidl::new_empty!(
12887                            fidl_fuchsia_component_decl__common::EventStream,
12888                            D
12889                        ));
12890                    }
12891                    #[allow(irrefutable_let_patterns)]
12892                    if let ComponentCapability::EventStream(ref mut val) = self {
12893                        fidl::decode!(
12894                            fidl_fuchsia_component_decl__common::EventStream,
12895                            D,
12896                            val,
12897                            decoder,
12898                            _inner_offset,
12899                            depth
12900                        )?;
12901                    } else {
12902                        unreachable!()
12903                    }
12904                }
12905                9 => {
12906                    #[allow(irrefutable_let_patterns)]
12907                    if let ComponentCapability::Protocol(_) = self {
12908                        // Do nothing, read the value into the object
12909                    } else {
12910                        // Initialize `self` to the right variant
12911                        *self = ComponentCapability::Protocol(fidl::new_empty!(
12912                            fidl_fuchsia_component_decl__common::Protocol,
12913                            D
12914                        ));
12915                    }
12916                    #[allow(irrefutable_let_patterns)]
12917                    if let ComponentCapability::Protocol(ref mut val) = self {
12918                        fidl::decode!(
12919                            fidl_fuchsia_component_decl__common::Protocol,
12920                            D,
12921                            val,
12922                            decoder,
12923                            _inner_offset,
12924                            depth
12925                        )?;
12926                    } else {
12927                        unreachable!()
12928                    }
12929                }
12930                10 => {
12931                    #[allow(irrefutable_let_patterns)]
12932                    if let ComponentCapability::Resolver(_) = self {
12933                        // Do nothing, read the value into the object
12934                    } else {
12935                        // Initialize `self` to the right variant
12936                        *self = ComponentCapability::Resolver(fidl::new_empty!(
12937                            fidl_fuchsia_component_decl__common::Resolver,
12938                            D
12939                        ));
12940                    }
12941                    #[allow(irrefutable_let_patterns)]
12942                    if let ComponentCapability::Resolver(ref mut val) = self {
12943                        fidl::decode!(
12944                            fidl_fuchsia_component_decl__common::Resolver,
12945                            D,
12946                            val,
12947                            decoder,
12948                            _inner_offset,
12949                            depth
12950                        )?;
12951                    } else {
12952                        unreachable!()
12953                    }
12954                }
12955                11 => {
12956                    #[allow(irrefutable_let_patterns)]
12957                    if let ComponentCapability::Runner(_) = self {
12958                        // Do nothing, read the value into the object
12959                    } else {
12960                        // Initialize `self` to the right variant
12961                        *self = ComponentCapability::Runner(fidl::new_empty!(
12962                            fidl_fuchsia_component_decl__common::Runner,
12963                            D
12964                        ));
12965                    }
12966                    #[allow(irrefutable_let_patterns)]
12967                    if let ComponentCapability::Runner(ref mut val) = self {
12968                        fidl::decode!(
12969                            fidl_fuchsia_component_decl__common::Runner,
12970                            D,
12971                            val,
12972                            decoder,
12973                            _inner_offset,
12974                            depth
12975                        )?;
12976                    } else {
12977                        unreachable!()
12978                    }
12979                }
12980                12 => {
12981                    #[allow(irrefutable_let_patterns)]
12982                    if let ComponentCapability::Service(_) = self {
12983                        // Do nothing, read the value into the object
12984                    } else {
12985                        // Initialize `self` to the right variant
12986                        *self = ComponentCapability::Service(fidl::new_empty!(
12987                            fidl_fuchsia_component_decl__common::Service,
12988                            D
12989                        ));
12990                    }
12991                    #[allow(irrefutable_let_patterns)]
12992                    if let ComponentCapability::Service(ref mut val) = self {
12993                        fidl::decode!(
12994                            fidl_fuchsia_component_decl__common::Service,
12995                            D,
12996                            val,
12997                            decoder,
12998                            _inner_offset,
12999                            depth
13000                        )?;
13001                    } else {
13002                        unreachable!()
13003                    }
13004                }
13005                13 => {
13006                    #[allow(irrefutable_let_patterns)]
13007                    if let ComponentCapability::Storage(_) = self {
13008                        // Do nothing, read the value into the object
13009                    } else {
13010                        // Initialize `self` to the right variant
13011                        *self = ComponentCapability::Storage(fidl::new_empty!(
13012                            fidl_fuchsia_component_decl__common::Storage,
13013                            D
13014                        ));
13015                    }
13016                    #[allow(irrefutable_let_patterns)]
13017                    if let ComponentCapability::Storage(ref mut val) = self {
13018                        fidl::decode!(
13019                            fidl_fuchsia_component_decl__common::Storage,
13020                            D,
13021                            val,
13022                            decoder,
13023                            _inner_offset,
13024                            depth
13025                        )?;
13026                    } else {
13027                        unreachable!()
13028                    }
13029                }
13030                ordinal => panic!("unexpected ordinal {:?}", ordinal),
13031            }
13032            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
13033                return Err(fidl::Error::InvalidNumBytesInEnvelope);
13034            }
13035            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13036                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13037            }
13038            Ok(())
13039        }
13040    }
13041
13042    impl fidl::encoding::ValueTypeMarker for EnvironmentCapability {
13043        type Borrowed<'a> = &'a Self;
13044        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13045            value
13046        }
13047    }
13048
13049    unsafe impl fidl::encoding::TypeMarker for EnvironmentCapability {
13050        type Owned = Self;
13051
13052        #[inline(always)]
13053        fn inline_align(_context: fidl::encoding::Context) -> usize {
13054            8
13055        }
13056
13057        #[inline(always)]
13058        fn inline_size(_context: fidl::encoding::Context) -> usize {
13059            16
13060        }
13061    }
13062
13063    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnvironmentCapability, D>
13064        for &EnvironmentCapability
13065    {
13066        #[inline]
13067        unsafe fn encode(
13068            self,
13069            encoder: &mut fidl::encoding::Encoder<'_, D>,
13070            offset: usize,
13071            _depth: fidl::encoding::Depth,
13072        ) -> fidl::Result<()> {
13073            encoder.debug_check_bounds::<EnvironmentCapability>(offset);
13074            encoder.write_num::<u64>(self.ordinal(), offset);
13075            match self {
13076                EnvironmentCapability::Runner(ref val) => {
13077                    fidl::encoding::encode_in_envelope::<EnvironmentSource, D>(
13078                        <EnvironmentSource as fidl::encoding::ValueTypeMarker>::borrow(val),
13079                        encoder,
13080                        offset + 8,
13081                        _depth,
13082                    )
13083                }
13084                EnvironmentCapability::Resolver(ref val) => {
13085                    fidl::encoding::encode_in_envelope::<EnvironmentSource, D>(
13086                        <EnvironmentSource as fidl::encoding::ValueTypeMarker>::borrow(val),
13087                        encoder,
13088                        offset + 8,
13089                        _depth,
13090                    )
13091                }
13092                EnvironmentCapability::Debug(ref val) => {
13093                    fidl::encoding::encode_in_envelope::<EnvironmentSource, D>(
13094                        <EnvironmentSource as fidl::encoding::ValueTypeMarker>::borrow(val),
13095                        encoder,
13096                        offset + 8,
13097                        _depth,
13098                    )
13099                }
13100            }
13101        }
13102    }
13103
13104    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnvironmentCapability {
13105        #[inline(always)]
13106        fn new_empty() -> Self {
13107            Self::Runner(fidl::new_empty!(EnvironmentSource, D))
13108        }
13109
13110        #[inline]
13111        unsafe fn decode(
13112            &mut self,
13113            decoder: &mut fidl::encoding::Decoder<'_, D>,
13114            offset: usize,
13115            mut depth: fidl::encoding::Depth,
13116        ) -> fidl::Result<()> {
13117            decoder.debug_check_bounds::<Self>(offset);
13118            #[allow(unused_variables)]
13119            let next_out_of_line = decoder.next_out_of_line();
13120            let handles_before = decoder.remaining_handles();
13121            let (ordinal, inlined, num_bytes, num_handles) =
13122                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
13123
13124            let member_inline_size = match ordinal {
13125                1 => {
13126                    <EnvironmentSource as fidl::encoding::TypeMarker>::inline_size(decoder.context)
13127                }
13128                2 => {
13129                    <EnvironmentSource as fidl::encoding::TypeMarker>::inline_size(decoder.context)
13130                }
13131                3 => {
13132                    <EnvironmentSource as fidl::encoding::TypeMarker>::inline_size(decoder.context)
13133                }
13134                _ => return Err(fidl::Error::UnknownUnionTag),
13135            };
13136
13137            if inlined != (member_inline_size <= 4) {
13138                return Err(fidl::Error::InvalidInlineBitInEnvelope);
13139            }
13140            let _inner_offset;
13141            if inlined {
13142                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
13143                _inner_offset = offset + 8;
13144            } else {
13145                depth.increment()?;
13146                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13147            }
13148            match ordinal {
13149                1 => {
13150                    #[allow(irrefutable_let_patterns)]
13151                    if let EnvironmentCapability::Runner(_) = self {
13152                        // Do nothing, read the value into the object
13153                    } else {
13154                        // Initialize `self` to the right variant
13155                        *self =
13156                            EnvironmentCapability::Runner(fidl::new_empty!(EnvironmentSource, D));
13157                    }
13158                    #[allow(irrefutable_let_patterns)]
13159                    if let EnvironmentCapability::Runner(ref mut val) = self {
13160                        fidl::decode!(EnvironmentSource, D, val, decoder, _inner_offset, depth)?;
13161                    } else {
13162                        unreachable!()
13163                    }
13164                }
13165                2 => {
13166                    #[allow(irrefutable_let_patterns)]
13167                    if let EnvironmentCapability::Resolver(_) = self {
13168                        // Do nothing, read the value into the object
13169                    } else {
13170                        // Initialize `self` to the right variant
13171                        *self =
13172                            EnvironmentCapability::Resolver(fidl::new_empty!(EnvironmentSource, D));
13173                    }
13174                    #[allow(irrefutable_let_patterns)]
13175                    if let EnvironmentCapability::Resolver(ref mut val) = self {
13176                        fidl::decode!(EnvironmentSource, D, val, decoder, _inner_offset, depth)?;
13177                    } else {
13178                        unreachable!()
13179                    }
13180                }
13181                3 => {
13182                    #[allow(irrefutable_let_patterns)]
13183                    if let EnvironmentCapability::Debug(_) = self {
13184                        // Do nothing, read the value into the object
13185                    } else {
13186                        // Initialize `self` to the right variant
13187                        *self =
13188                            EnvironmentCapability::Debug(fidl::new_empty!(EnvironmentSource, D));
13189                    }
13190                    #[allow(irrefutable_let_patterns)]
13191                    if let EnvironmentCapability::Debug(ref mut val) = self {
13192                        fidl::decode!(EnvironmentSource, D, val, decoder, _inner_offset, depth)?;
13193                    } else {
13194                        unreachable!()
13195                    }
13196                }
13197                ordinal => panic!("unexpected ordinal {:?}", ordinal),
13198            }
13199            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
13200                return Err(fidl::Error::InvalidNumBytesInEnvelope);
13201            }
13202            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13203                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13204            }
13205            Ok(())
13206        }
13207    }
13208
13209    impl fidl::encoding::ValueTypeMarker for InjectedUse {
13210        type Borrowed<'a> = &'a Self;
13211        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13212            value
13213        }
13214    }
13215
13216    unsafe impl fidl::encoding::TypeMarker for InjectedUse {
13217        type Owned = Self;
13218
13219        #[inline(always)]
13220        fn inline_align(_context: fidl::encoding::Context) -> usize {
13221            8
13222        }
13223
13224        #[inline(always)]
13225        fn inline_size(_context: fidl::encoding::Context) -> usize {
13226            16
13227        }
13228    }
13229
13230    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InjectedUse, D>
13231        for &InjectedUse
13232    {
13233        #[inline]
13234        unsafe fn encode(
13235            self,
13236            encoder: &mut fidl::encoding::Encoder<'_, D>,
13237            offset: usize,
13238            _depth: fidl::encoding::Depth,
13239        ) -> fidl::Result<()> {
13240            encoder.debug_check_bounds::<InjectedUse>(offset);
13241            encoder.write_num::<u64>(self.ordinal(), offset);
13242            match self {
13243                InjectedUse::Protocol(ref val) => {
13244                    fidl::encoding::encode_in_envelope::<InjectedUseProtocol, D>(
13245                        <InjectedUseProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
13246                        encoder,
13247                        offset + 8,
13248                        _depth,
13249                    )
13250                }
13251                InjectedUse::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
13252            }
13253        }
13254    }
13255
13256    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InjectedUse {
13257        #[inline(always)]
13258        fn new_empty() -> Self {
13259            Self::__SourceBreaking { unknown_ordinal: 0 }
13260        }
13261
13262        #[inline]
13263        unsafe fn decode(
13264            &mut self,
13265            decoder: &mut fidl::encoding::Decoder<'_, D>,
13266            offset: usize,
13267            mut depth: fidl::encoding::Depth,
13268        ) -> fidl::Result<()> {
13269            decoder.debug_check_bounds::<Self>(offset);
13270            #[allow(unused_variables)]
13271            let next_out_of_line = decoder.next_out_of_line();
13272            let handles_before = decoder.remaining_handles();
13273            let (ordinal, inlined, num_bytes, num_handles) =
13274                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
13275
13276            let member_inline_size = match ordinal {
13277                1 => <InjectedUseProtocol as fidl::encoding::TypeMarker>::inline_size(
13278                    decoder.context,
13279                ),
13280                0 => return Err(fidl::Error::UnknownUnionTag),
13281                _ => num_bytes as usize,
13282            };
13283
13284            if inlined != (member_inline_size <= 4) {
13285                return Err(fidl::Error::InvalidInlineBitInEnvelope);
13286            }
13287            let _inner_offset;
13288            if inlined {
13289                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
13290                _inner_offset = offset + 8;
13291            } else {
13292                depth.increment()?;
13293                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13294            }
13295            match ordinal {
13296                1 => {
13297                    #[allow(irrefutable_let_patterns)]
13298                    if let InjectedUse::Protocol(_) = self {
13299                        // Do nothing, read the value into the object
13300                    } else {
13301                        // Initialize `self` to the right variant
13302                        *self = InjectedUse::Protocol(fidl::new_empty!(InjectedUseProtocol, D));
13303                    }
13304                    #[allow(irrefutable_let_patterns)]
13305                    if let InjectedUse::Protocol(ref mut val) = self {
13306                        fidl::decode!(InjectedUseProtocol, D, val, decoder, _inner_offset, depth)?;
13307                    } else {
13308                        unreachable!()
13309                    }
13310                }
13311                #[allow(deprecated)]
13312                ordinal => {
13313                    for _ in 0..num_handles {
13314                        decoder.drop_next_handle()?;
13315                    }
13316                    *self = InjectedUse::__SourceBreaking { unknown_ordinal: ordinal };
13317                }
13318            }
13319            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
13320                return Err(fidl::Error::InvalidNumBytesInEnvelope);
13321            }
13322            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13323                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13324            }
13325            Ok(())
13326        }
13327    }
13328
13329    impl fidl::encoding::ValueTypeMarker for InternalCapability {
13330        type Borrowed<'a> = &'a Self;
13331        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13332            value
13333        }
13334    }
13335
13336    unsafe impl fidl::encoding::TypeMarker for InternalCapability {
13337        type Owned = Self;
13338
13339        #[inline(always)]
13340        fn inline_align(_context: fidl::encoding::Context) -> usize {
13341            8
13342        }
13343
13344        #[inline(always)]
13345        fn inline_size(_context: fidl::encoding::Context) -> usize {
13346            16
13347        }
13348    }
13349
13350    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InternalCapability, D>
13351        for &InternalCapability
13352    {
13353        #[inline]
13354        unsafe fn encode(
13355            self,
13356            encoder: &mut fidl::encoding::Encoder<'_, D>,
13357            offset: usize,
13358            _depth: fidl::encoding::Depth,
13359        ) -> fidl::Result<()> {
13360            encoder.debug_check_bounds::<InternalCapability>(offset);
13361            encoder.write_num::<u64>(self.ordinal(), offset);
13362            match self {
13363                InternalCapability::Config(ref val) => fidl::encoding::encode_in_envelope::<
13364                    fidl::encoding::BoundedString<100>,
13365                    D,
13366                >(
13367                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13368                        val,
13369                    ),
13370                    encoder,
13371                    offset + 8,
13372                    _depth,
13373                ),
13374                InternalCapability::Dictionary(ref val) => fidl::encoding::encode_in_envelope::<
13375                    fidl::encoding::BoundedString<100>,
13376                    D,
13377                >(
13378                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13379                        val,
13380                    ),
13381                    encoder,
13382                    offset + 8,
13383                    _depth,
13384                ),
13385                InternalCapability::Directory(ref val) => fidl::encoding::encode_in_envelope::<
13386                    fidl::encoding::BoundedString<100>,
13387                    D,
13388                >(
13389                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13390                        val,
13391                    ),
13392                    encoder,
13393                    offset + 8,
13394                    _depth,
13395                ),
13396                InternalCapability::EventStream(ref val) => fidl::encoding::encode_in_envelope::<
13397                    InternalEventStreamCapability,
13398                    D,
13399                >(
13400                    <InternalEventStreamCapability as fidl::encoding::ValueTypeMarker>::borrow(val),
13401                    encoder,
13402                    offset + 8,
13403                    _depth,
13404                ),
13405                InternalCapability::Protocol(ref val) => fidl::encoding::encode_in_envelope::<
13406                    fidl::encoding::BoundedString<100>,
13407                    D,
13408                >(
13409                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13410                        val,
13411                    ),
13412                    encoder,
13413                    offset + 8,
13414                    _depth,
13415                ),
13416                InternalCapability::Resolver(ref val) => fidl::encoding::encode_in_envelope::<
13417                    fidl::encoding::BoundedString<100>,
13418                    D,
13419                >(
13420                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13421                        val,
13422                    ),
13423                    encoder,
13424                    offset + 8,
13425                    _depth,
13426                ),
13427                InternalCapability::Runner(ref val) => fidl::encoding::encode_in_envelope::<
13428                    fidl::encoding::BoundedString<100>,
13429                    D,
13430                >(
13431                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13432                        val,
13433                    ),
13434                    encoder,
13435                    offset + 8,
13436                    _depth,
13437                ),
13438                InternalCapability::Service(ref val) => fidl::encoding::encode_in_envelope::<
13439                    fidl::encoding::BoundedString<100>,
13440                    D,
13441                >(
13442                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13443                        val,
13444                    ),
13445                    encoder,
13446                    offset + 8,
13447                    _depth,
13448                ),
13449                InternalCapability::Storage(ref val) => fidl::encoding::encode_in_envelope::<
13450                    fidl::encoding::BoundedString<100>,
13451                    D,
13452                >(
13453                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
13454                        val,
13455                    ),
13456                    encoder,
13457                    offset + 8,
13458                    _depth,
13459                ),
13460            }
13461        }
13462    }
13463
13464    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InternalCapability {
13465        #[inline(always)]
13466        fn new_empty() -> Self {
13467            Self::Config(fidl::new_empty!(fidl::encoding::BoundedString<100>, D))
13468        }
13469
13470        #[inline]
13471        unsafe fn decode(
13472            &mut self,
13473            decoder: &mut fidl::encoding::Decoder<'_, D>,
13474            offset: usize,
13475            mut depth: fidl::encoding::Depth,
13476        ) -> fidl::Result<()> {
13477            decoder.debug_check_bounds::<Self>(offset);
13478            #[allow(unused_variables)]
13479            let next_out_of_line = decoder.next_out_of_line();
13480            let handles_before = decoder.remaining_handles();
13481            let (ordinal, inlined, num_bytes, num_handles) =
13482                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
13483
13484            let member_inline_size = match ordinal {
13485                1 => {
13486                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13487                        decoder.context,
13488                    )
13489                }
13490                2 => {
13491                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13492                        decoder.context,
13493                    )
13494                }
13495                3 => {
13496                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13497                        decoder.context,
13498                    )
13499                }
13500                4 => <InternalEventStreamCapability as fidl::encoding::TypeMarker>::inline_size(
13501                    decoder.context,
13502                ),
13503                5 => {
13504                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13505                        decoder.context,
13506                    )
13507                }
13508                6 => {
13509                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13510                        decoder.context,
13511                    )
13512                }
13513                7 => {
13514                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13515                        decoder.context,
13516                    )
13517                }
13518                8 => {
13519                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13520                        decoder.context,
13521                    )
13522                }
13523                9 => {
13524                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13525                        decoder.context,
13526                    )
13527                }
13528                _ => return Err(fidl::Error::UnknownUnionTag),
13529            };
13530
13531            if inlined != (member_inline_size <= 4) {
13532                return Err(fidl::Error::InvalidInlineBitInEnvelope);
13533            }
13534            let _inner_offset;
13535            if inlined {
13536                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
13537                _inner_offset = offset + 8;
13538            } else {
13539                depth.increment()?;
13540                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13541            }
13542            match ordinal {
13543                1 => {
13544                    #[allow(irrefutable_let_patterns)]
13545                    if let InternalCapability::Config(_) = self {
13546                        // Do nothing, read the value into the object
13547                    } else {
13548                        // Initialize `self` to the right variant
13549                        *self = InternalCapability::Config(fidl::new_empty!(
13550                            fidl::encoding::BoundedString<100>,
13551                            D
13552                        ));
13553                    }
13554                    #[allow(irrefutable_let_patterns)]
13555                    if let InternalCapability::Config(ref mut val) = self {
13556                        fidl::decode!(
13557                            fidl::encoding::BoundedString<100>,
13558                            D,
13559                            val,
13560                            decoder,
13561                            _inner_offset,
13562                            depth
13563                        )?;
13564                    } else {
13565                        unreachable!()
13566                    }
13567                }
13568                2 => {
13569                    #[allow(irrefutable_let_patterns)]
13570                    if let InternalCapability::Dictionary(_) = self {
13571                        // Do nothing, read the value into the object
13572                    } else {
13573                        // Initialize `self` to the right variant
13574                        *self = InternalCapability::Dictionary(fidl::new_empty!(
13575                            fidl::encoding::BoundedString<100>,
13576                            D
13577                        ));
13578                    }
13579                    #[allow(irrefutable_let_patterns)]
13580                    if let InternalCapability::Dictionary(ref mut val) = self {
13581                        fidl::decode!(
13582                            fidl::encoding::BoundedString<100>,
13583                            D,
13584                            val,
13585                            decoder,
13586                            _inner_offset,
13587                            depth
13588                        )?;
13589                    } else {
13590                        unreachable!()
13591                    }
13592                }
13593                3 => {
13594                    #[allow(irrefutable_let_patterns)]
13595                    if let InternalCapability::Directory(_) = self {
13596                        // Do nothing, read the value into the object
13597                    } else {
13598                        // Initialize `self` to the right variant
13599                        *self = InternalCapability::Directory(fidl::new_empty!(
13600                            fidl::encoding::BoundedString<100>,
13601                            D
13602                        ));
13603                    }
13604                    #[allow(irrefutable_let_patterns)]
13605                    if let InternalCapability::Directory(ref mut val) = self {
13606                        fidl::decode!(
13607                            fidl::encoding::BoundedString<100>,
13608                            D,
13609                            val,
13610                            decoder,
13611                            _inner_offset,
13612                            depth
13613                        )?;
13614                    } else {
13615                        unreachable!()
13616                    }
13617                }
13618                4 => {
13619                    #[allow(irrefutable_let_patterns)]
13620                    if let InternalCapability::EventStream(_) = self {
13621                        // Do nothing, read the value into the object
13622                    } else {
13623                        // Initialize `self` to the right variant
13624                        *self = InternalCapability::EventStream(fidl::new_empty!(
13625                            InternalEventStreamCapability,
13626                            D
13627                        ));
13628                    }
13629                    #[allow(irrefutable_let_patterns)]
13630                    if let InternalCapability::EventStream(ref mut val) = self {
13631                        fidl::decode!(
13632                            InternalEventStreamCapability,
13633                            D,
13634                            val,
13635                            decoder,
13636                            _inner_offset,
13637                            depth
13638                        )?;
13639                    } else {
13640                        unreachable!()
13641                    }
13642                }
13643                5 => {
13644                    #[allow(irrefutable_let_patterns)]
13645                    if let InternalCapability::Protocol(_) = self {
13646                        // Do nothing, read the value into the object
13647                    } else {
13648                        // Initialize `self` to the right variant
13649                        *self = InternalCapability::Protocol(fidl::new_empty!(
13650                            fidl::encoding::BoundedString<100>,
13651                            D
13652                        ));
13653                    }
13654                    #[allow(irrefutable_let_patterns)]
13655                    if let InternalCapability::Protocol(ref mut val) = self {
13656                        fidl::decode!(
13657                            fidl::encoding::BoundedString<100>,
13658                            D,
13659                            val,
13660                            decoder,
13661                            _inner_offset,
13662                            depth
13663                        )?;
13664                    } else {
13665                        unreachable!()
13666                    }
13667                }
13668                6 => {
13669                    #[allow(irrefutable_let_patterns)]
13670                    if let InternalCapability::Resolver(_) = self {
13671                        // Do nothing, read the value into the object
13672                    } else {
13673                        // Initialize `self` to the right variant
13674                        *self = InternalCapability::Resolver(fidl::new_empty!(
13675                            fidl::encoding::BoundedString<100>,
13676                            D
13677                        ));
13678                    }
13679                    #[allow(irrefutable_let_patterns)]
13680                    if let InternalCapability::Resolver(ref mut val) = self {
13681                        fidl::decode!(
13682                            fidl::encoding::BoundedString<100>,
13683                            D,
13684                            val,
13685                            decoder,
13686                            _inner_offset,
13687                            depth
13688                        )?;
13689                    } else {
13690                        unreachable!()
13691                    }
13692                }
13693                7 => {
13694                    #[allow(irrefutable_let_patterns)]
13695                    if let InternalCapability::Runner(_) = self {
13696                        // Do nothing, read the value into the object
13697                    } else {
13698                        // Initialize `self` to the right variant
13699                        *self = InternalCapability::Runner(fidl::new_empty!(
13700                            fidl::encoding::BoundedString<100>,
13701                            D
13702                        ));
13703                    }
13704                    #[allow(irrefutable_let_patterns)]
13705                    if let InternalCapability::Runner(ref mut val) = self {
13706                        fidl::decode!(
13707                            fidl::encoding::BoundedString<100>,
13708                            D,
13709                            val,
13710                            decoder,
13711                            _inner_offset,
13712                            depth
13713                        )?;
13714                    } else {
13715                        unreachable!()
13716                    }
13717                }
13718                8 => {
13719                    #[allow(irrefutable_let_patterns)]
13720                    if let InternalCapability::Service(_) = self {
13721                        // Do nothing, read the value into the object
13722                    } else {
13723                        // Initialize `self` to the right variant
13724                        *self = InternalCapability::Service(fidl::new_empty!(
13725                            fidl::encoding::BoundedString<100>,
13726                            D
13727                        ));
13728                    }
13729                    #[allow(irrefutable_let_patterns)]
13730                    if let InternalCapability::Service(ref mut val) = self {
13731                        fidl::decode!(
13732                            fidl::encoding::BoundedString<100>,
13733                            D,
13734                            val,
13735                            decoder,
13736                            _inner_offset,
13737                            depth
13738                        )?;
13739                    } else {
13740                        unreachable!()
13741                    }
13742                }
13743                9 => {
13744                    #[allow(irrefutable_let_patterns)]
13745                    if let InternalCapability::Storage(_) = self {
13746                        // Do nothing, read the value into the object
13747                    } else {
13748                        // Initialize `self` to the right variant
13749                        *self = InternalCapability::Storage(fidl::new_empty!(
13750                            fidl::encoding::BoundedString<100>,
13751                            D
13752                        ));
13753                    }
13754                    #[allow(irrefutable_let_patterns)]
13755                    if let InternalCapability::Storage(ref mut val) = self {
13756                        fidl::decode!(
13757                            fidl::encoding::BoundedString<100>,
13758                            D,
13759                            val,
13760                            decoder,
13761                            _inner_offset,
13762                            depth
13763                        )?;
13764                    } else {
13765                        unreachable!()
13766                    }
13767                }
13768                ordinal => panic!("unexpected ordinal {:?}", ordinal),
13769            }
13770            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
13771                return Err(fidl::Error::InvalidNumBytesInEnvelope);
13772            }
13773            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13774                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13775            }
13776            Ok(())
13777        }
13778    }
13779}
fidl_fuchsia_component_internal__common/fidl_fuchsia_component_internal__common.rs

fidl_fuchsia_component_internal__common/
fidl_fuchsia_component_internal__common.rs
