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