fidl_fuchsia_component_test__common/
fidl_fuchsia_component_test__common.rs

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