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