fidl_fuchsia_component_decl__common/
fidl_fuchsia_component_decl__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// The string identifier for a config field.
12pub type ConfigKey = String;
13
14pub type ChildName = String;
15
16/// Path in a dictionary. The format is similar to a directory path, except no `.` or `..`.
17/// is allowed and each path segment must conform to the format of the `name` type.
18///
19/// The "dirname" (first to the penultimate segment, or empty if there is one
20/// segment) represents a sequence of nested dictionaries.
21/// The "basename" (last segment) identifies a capability in the last nested
22/// dictionary.
23pub type DictionaryPath = String;
24
25pub type Name = String;
26
27pub type UrlScheme = String;
28
29/// Config keys can only consist of these many bytes
30pub const CONFIG_KEY_MAX_SIZE: u32 = 64;
31
32pub const MAX_CHILD_NAME_LENGTH: u32 = 1024;
33
34pub const MAX_MONIKER_LENGTH: u32 = 4096;
35
36pub const MAX_NAME_LENGTH: u32 = 100;
37
38/// The maximum number of EventSubscriptions in an EventStream.
39pub const MAX_NUM_EVENT_STREAM_SUBSCRIPTIONS: u64 = 100;
40
41pub const MAX_PATH_LENGTH: u32 = 1024;
42
43pub const MAX_URL_SCHEME_LENGTH: u32 = 100;
44
45bitflags! {
46    /// Allowed sources for runtime overrides of a config field's value.
47    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
48    pub struct ConfigMutability: u32 {
49        /// Allow parent components to provide overrides for the configuration field.
50        const PARENT = 1;
51    }
52}
53
54impl ConfigMutability {
55    #[inline(always)]
56    pub fn from_bits_allow_unknown(bits: u32) -> Self {
57        Self::from_bits_retain(bits)
58    }
59
60    #[inline(always)]
61    pub fn has_unknown_bits(&self) -> bool {
62        self.get_unknown_bits() != 0
63    }
64
65    #[inline(always)]
66    pub fn get_unknown_bits(&self) -> u32 {
67        self.bits() & !Self::all().bits()
68    }
69}
70
71/// The kinds of offers that can target the children in a collection.
72#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
73#[repr(u32)]
74pub enum AllowedOffers {
75    /// Only static offers may target components in the collection. "Static
76    /// offers" are the offers in the `ComponentDecl` that target the collection
77    /// itself.
78    ///
79    /// This is the default behavior.
80    StaticOnly = 1,
81    /// Both static offers and dynamic offers may target components in the
82    /// collection. "Static offers" are the offers in the `ComponentDecl` that
83    /// target the collection itself. "Dynamic offers" are additional offers
84    /// that are passed to `CreateChild` at runtime.
85    StaticAndDynamic = 2,
86}
87
88impl AllowedOffers {
89    #[inline]
90    pub fn from_primitive(prim: u32) -> Option<Self> {
91        match prim {
92            1 => Some(Self::StaticOnly),
93            2 => Some(Self::StaticAndDynamic),
94            _ => None,
95        }
96    }
97
98    #[inline]
99    pub const fn into_primitive(self) -> u32 {
100        self as u32
101    }
102}
103
104/// Describes the expected availability of the capability.
105///
106/// Some capabilities may not be present on all system configurations. In those
107/// cases, the availability will be declared as `OPTIONAL` along the chains of
108/// exposes/offers/uses, and the capability would be routed from `void` on
109/// system configurations where it does not make sense to route or provide a
110/// particular capability (e.g. graphical capabilities on a headless system).
111#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
112#[repr(u32)]
113pub enum Availability {
114    /// The capability must be available. Failure to route the capability is an
115    /// error.
116    Required = 1,
117    /// Inside a use declaration: the component can function if it fails to
118    /// obtain the capability.
119    ///
120    /// Inside an offer/expose declaration: the capability may not be available
121    /// in some system configurations. As a corollary, the target component must
122    /// not have a required dependency on the capability.
123    Optional = 2,
124    /// If the target of the corresponding offer or expose declaration requires
125    /// the capability, then the behavior is equivalent to required. If the
126    /// target has an optional dependency on the capability, then the behavior
127    /// is equivalent to optional. This is useful for container components that
128    /// would like to change their routing availability based on ones inside.
129    ///
130    /// This value is not allowed inside a use declaration.
131    SameAsTarget = 3,
132    /// The source may omit the route completely without even having to route
133    /// from `void`.
134    ///
135    /// [`TRANSITIONAL`] is used for soft transitions that introduce new
136    /// capabilities.
137    Transitional = 4,
138}
139
140impl Availability {
141    #[inline]
142    pub fn from_primitive(prim: u32) -> Option<Self> {
143        match prim {
144            1 => Some(Self::Required),
145            2 => Some(Self::Optional),
146            3 => Some(Self::SameAsTarget),
147            4 => Some(Self::Transitional),
148            _ => None,
149        }
150    }
151
152    #[inline]
153    pub const fn into_primitive(self) -> u32 {
154        self as u32
155    }
156}
157
158#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
159pub enum ConfigTypeLayout {
160    Bool,
161    Uint8,
162    Uint16,
163    Uint32,
164    Uint64,
165    Int8,
166    Int16,
167    Int32,
168    Int64,
169    String,
170    Vector,
171    #[doc(hidden)]
172    __SourceBreaking {
173        unknown_ordinal: u32,
174    },
175}
176
177/// Pattern that matches an unknown `ConfigTypeLayout` member.
178#[macro_export]
179macro_rules! ConfigTypeLayoutUnknown {
180    () => {
181        _
182    };
183}
184
185impl ConfigTypeLayout {
186    #[inline]
187    pub fn from_primitive(prim: u32) -> Option<Self> {
188        match prim {
189            1 => Some(Self::Bool),
190            2 => Some(Self::Uint8),
191            3 => Some(Self::Uint16),
192            4 => Some(Self::Uint32),
193            5 => Some(Self::Uint64),
194            6 => Some(Self::Int8),
195            7 => Some(Self::Int16),
196            8 => Some(Self::Int32),
197            9 => Some(Self::Int64),
198            10 => Some(Self::String),
199            11 => Some(Self::Vector),
200            _ => None,
201        }
202    }
203
204    #[inline]
205    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
206        match prim {
207            1 => Self::Bool,
208            2 => Self::Uint8,
209            3 => Self::Uint16,
210            4 => Self::Uint32,
211            5 => Self::Uint64,
212            6 => Self::Int8,
213            7 => Self::Int16,
214            8 => Self::Int32,
215            9 => Self::Int64,
216            10 => Self::String,
217            11 => Self::Vector,
218            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
219        }
220    }
221
222    #[inline]
223    pub fn unknown() -> Self {
224        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
225    }
226
227    #[inline]
228    pub const fn into_primitive(self) -> u32 {
229        match self {
230            Self::Bool => 1,
231            Self::Uint8 => 2,
232            Self::Uint16 => 3,
233            Self::Uint32 => 4,
234            Self::Uint64 => 5,
235            Self::Int8 => 6,
236            Self::Int16 => 7,
237            Self::Int32 => 8,
238            Self::Int64 => 9,
239            Self::String => 10,
240            Self::Vector => 11,
241            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
242        }
243    }
244
245    #[inline]
246    pub fn is_unknown(&self) -> bool {
247        match self {
248            Self::__SourceBreaking { unknown_ordinal: _ } => true,
249            _ => false,
250        }
251    }
252}
253
254/// `DeliveryType` may be used when declaring a capability, and specifies under
255/// what conditions the framework will open the capability from the provider
256/// component's outgoing directory when there is a request for this capability.
257#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
258pub enum DeliveryType {
259    /// The framework will open the capability as soon as some consumer
260    /// component requests it.
261    Immediate,
262    /// The framework will monitor the `ZX_CHANNEL_READABLE` signal on the
263    /// server endpoint of connection requests made by the consumer component,
264    /// and only open the capability from the provider component's outgoing
265    /// directory when the server endpoint becomes readable.
266    OnReadable,
267    #[doc(hidden)]
268    __SourceBreaking { unknown_ordinal: u32 },
269}
270
271/// Pattern that matches an unknown `DeliveryType` member.
272#[macro_export]
273macro_rules! DeliveryTypeUnknown {
274    () => {
275        _
276    };
277}
278
279impl DeliveryType {
280    #[inline]
281    pub fn from_primitive(prim: u32) -> Option<Self> {
282        match prim {
283            0 => Some(Self::Immediate),
284            1 => Some(Self::OnReadable),
285            _ => None,
286        }
287    }
288
289    #[inline]
290    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
291        match prim {
292            0 => Self::Immediate,
293            1 => Self::OnReadable,
294            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
295        }
296    }
297
298    #[inline]
299    pub fn unknown() -> Self {
300        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
301    }
302
303    #[inline]
304    pub const fn into_primitive(self) -> u32 {
305        match self {
306            Self::Immediate => 0,
307            Self::OnReadable => 1,
308            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
309        }
310    }
311
312    #[inline]
313    pub fn is_unknown(&self) -> bool {
314        match self {
315            Self::__SourceBreaking { unknown_ordinal: _ } => true,
316            _ => false,
317        }
318    }
319}
320
321/// Describes the type of dependency implied by the capability.
322#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
323#[repr(u32)]
324pub enum DependencyType {
325    /// A strong dependency which may be required by components that use it.
326    Strong = 1,
327    /// A weak dependency which is allowed to form a cycle. Components that use
328    /// a weak dependency must support the dependency being unavailable at
329    /// arbitrary times.
330    Weak = 2,
331}
332
333impl DependencyType {
334    #[inline]
335    pub fn from_primitive(prim: u32) -> Option<Self> {
336        match prim {
337            1 => Some(Self::Strong),
338            2 => Some(Self::Weak),
339            _ => None,
340        }
341    }
342
343    #[inline]
344    pub const fn into_primitive(self) -> u32 {
345        self as u32
346    }
347}
348
349/// The durability of component instances created in a collection.
350#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
351#[repr(u32)]
352pub enum Durability {
353    /// An instance exists until either its parent instance is stopped
354    /// or it is explicitly destroyed.
355    Transient = 2,
356    /// An instance is started upon creation and is immediately destroyed when
357    /// it stops.
358    SingleRun = 3,
359}
360
361impl Durability {
362    #[inline]
363    pub fn from_primitive(prim: u32) -> Option<Self> {
364        match prim {
365            2 => Some(Self::Transient),
366            3 => Some(Self::SingleRun),
367            _ => None,
368        }
369    }
370
371    #[inline]
372    pub const fn into_primitive(self) -> u32 {
373        self as u32
374    }
375}
376
377/// Specifies how a declared environment's initial set of properties are assigned.
378#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
379#[repr(u32)]
380pub enum EnvironmentExtends {
381    /// The environment has no initial set of properties.
382    None = 0,
383    /// The environment's initial set of properties are inherited from its realm.
384    /// Inherited properties include any fields defined in `EnvironmentDecl`.
385    Realm = 1,
386}
387
388impl EnvironmentExtends {
389    #[inline]
390    pub fn from_primitive(prim: u32) -> Option<Self> {
391        match prim {
392            0 => Some(Self::None),
393            1 => Some(Self::Realm),
394            _ => None,
395        }
396    }
397
398    #[inline]
399    pub const fn into_primitive(self) -> u32 {
400        self as u32
401    }
402}
403
404/// Describes the action to take if this component instance terminates
405/// unexpectedly.
406#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
407#[repr(u32)]
408pub enum OnTerminate {
409    /// No action, the default
410    None = 0,
411    /// Trigger a graceful system reboot if the component terminates, unless its controller reports
412    /// via [`fuchsia.component.runner/ComponentController.OnStop`] a `termination_status` of Ok and
413    /// an `exit_code` that is either unset or 0. This is a specialized feature gated by Component
414    /// Framework security policy.
415    Reboot = 1,
416}
417
418impl OnTerminate {
419    #[inline]
420    pub fn from_primitive(prim: u32) -> Option<Self> {
421        match prim {
422            0 => Some(Self::None),
423            1 => Some(Self::Reboot),
424            _ => None,
425        }
426    }
427
428    #[inline]
429    pub const fn into_primitive(self) -> u32 {
430        self as u32
431    }
432}
433
434/// Describes under what conditions the component may be started.
435#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
436#[repr(u32)]
437pub enum StartupMode {
438    /// Start component instance only when it receives an incoming capability request or it's
439    /// started directly with [`fuchsia.component/Controller.Start`].
440    Lazy = 0,
441    /// Start component instance automatically when the parent starts or (for dynamic
442    /// components) when the component is created.
443    Eager = 1,
444}
445
446impl StartupMode {
447    #[inline]
448    pub fn from_primitive(prim: u32) -> Option<Self> {
449        match prim {
450            0 => Some(Self::Lazy),
451            1 => Some(Self::Eager),
452            _ => None,
453        }
454    }
455
456    #[inline]
457    pub const fn into_primitive(self) -> u32 {
458        self as u32
459    }
460}
461
462/// Declares which identifier to use to key a component's isolated storage
463/// directory.
464#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
465#[repr(u32)]
466pub enum StorageId {
467    /// Isolated storage directories are keyed using a component's instance ID
468    /// specified in the component ID index. Components which are not listed in
469    /// the index cannot use or open this storage capability.
470    StaticInstanceId = 1,
471    /// Isolated storage directories are keyed using a component's instance ID
472    /// if one is specified in the component ID index. Otherwise, a component's
473    /// moniker from the storage capability is used to key its isolated
474    /// storage directory.
475    StaticInstanceIdOrMoniker = 2,
476}
477
478impl StorageId {
479    #[inline]
480    pub fn from_primitive(prim: u32) -> Option<Self> {
481        match prim {
482            1 => Some(Self::StaticInstanceId),
483            2 => Some(Self::StaticInstanceIdOrMoniker),
484            _ => None,
485        }
486    }
487
488    #[inline]
489    pub const fn into_primitive(self) -> u32 {
490        self as u32
491    }
492}
493
494/// A reference to a capability declared in this component.
495#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
496pub struct CapabilityRef {
497    pub name: String,
498}
499
500impl fidl::Persistable for CapabilityRef {}
501
502/// A reference to one of the component's child instances.
503#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
504pub struct ChildRef {
505    /// The name assigned to the child by its parent. If `collection` is set,
506    /// `name` is scoped to `collection` and the child is a dynamic instance.
507    pub name: String,
508    /// The collection `name` belongs to. If omitted, `name` references a static
509    /// instance. This field must be omitted if the `ChildRef` is being used in
510    /// a component declaration. Optional.
511    pub collection: Option<String>,
512}
513
514impl fidl::Persistable for ChildRef {}
515
516/// A reference to one of the component's collections.
517#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
518pub struct CollectionRef {
519    pub name: String,
520}
521
522impl fidl::Persistable for CollectionRef {}
523
524#[derive(Clone, Debug, PartialEq)]
525pub struct ConfigType {
526    pub layout: ConfigTypeLayout,
527    pub parameters: Option<Vec<LayoutParameter>>,
528    pub constraints: Vec<LayoutConstraint>,
529}
530
531impl fidl::Persistable for ConfigType {}
532
533/// A reference to the environment's debug capabilities.
534#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
535pub struct DebugRef;
536
537impl fidl::Persistable for DebugRef {}
538
539/// A reference to the environment.
540#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
541pub struct EnvironmentRef;
542
543impl fidl::Persistable for EnvironmentRef {}
544
545/// A reference to the component framework itself.
546#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
547pub struct FrameworkRef;
548
549impl fidl::Persistable for FrameworkRef {}
550
551/// Type used to create a mapping between 2 names. Used to rename service or component instances
552/// in FIDL declarations.
553#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
554pub struct NameMapping {
555    /// Name used in the source instance.
556    pub source_name: String,
557    /// Name used in the target instance.
558    pub target_name: String,
559}
560
561impl fidl::Persistable for NameMapping {}
562
563/// A reference to a component's parent instance.
564#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
565pub struct ParentRef;
566
567impl fidl::Persistable for ParentRef {}
568
569/// A configuration that has been completely resolved by component manager.
570#[derive(Clone, Debug, PartialEq)]
571pub struct ResolvedConfig {
572    pub fields: Vec<ResolvedConfigField>,
573    pub checksum: ConfigChecksum,
574}
575
576impl fidl::Persistable for ResolvedConfig {}
577
578#[derive(Clone, Debug, PartialEq)]
579pub struct ResolvedConfigField {
580    pub key: String,
581    pub value: ConfigValue,
582}
583
584impl fidl::Persistable for ResolvedConfigField {}
585
586/// A reference to the component itself.
587#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
588pub struct SelfRef;
589
590impl fidl::Persistable for SelfRef {}
591
592/// A reference to an intentionally missing offer source.
593#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
594pub struct VoidRef;
595
596impl fidl::Persistable for VoidRef {}
597
598/// Statically declares a child component instance.
599#[derive(Clone, Debug, Default, PartialEq)]
600pub struct Child {
601    /// (Required) The name assigned to the child by its parent.
602    ///
603    /// Must be non-empty, unique among all siblings, and contain only the
604    /// following characters: [a-z0-9-_.].
605    pub name: Option<String>,
606    /// (Required) The child component's URL.
607    ///
608    /// Must be non-empty and a well-formed URL.
609    pub url: Option<String>,
610    /// (Required) The startup mode for the component instance.
611    ///
612    /// Must be set.
613    pub startup: Option<StartupMode>,
614    /// (Optional) The environment assigned to this child.
615    ///
616    /// May be unset, in which case the child will inherit the parent component's
617    /// environment. If set, the name must reference an environment defined in
618    /// the `ComponentDecl` and it must contain only the following characters:
619    /// [a-z0-9-_.].
620    pub environment: Option<String>,
621    /// (Optional, defaults to `NONE`) The action to take if this component
622    /// instance terminates unexpectedly.
623    pub on_terminate: Option<OnTerminate>,
624    /// Configuration overrides to apply to the child's base configuration.
625    ///
626    /// For a configuration field to be overridden it must be marked as mutable by parent.
627    ///
628    /// Parents must pass `ConfigOverride` values which match the child's declared schema types
629    /// exactly.
630    pub config_overrides: Option<Vec<ConfigOverride>>,
631    #[doc(hidden)]
632    pub __source_breaking: fidl::marker::SourceBreaking,
633}
634
635impl fidl::Persistable for Child {}
636
637/// Statically declares a component instance collection.
638#[derive(Clone, Debug, Default, PartialEq)]
639pub struct Collection {
640    /// (Required) The name of the collection. Instances created in the
641    /// collection are scoped to this name.
642    pub name: Option<String>,
643    /// (Required) The durability of instances in the collection.
644    pub durability: Option<Durability>,
645    /// (Optional) The environment assigned to child instances in this
646    /// collection.
647    ///
648    /// May be unset, in which case children in this collection will inherit the
649    /// parent component's environment. If set, the name must reference an
650    /// environment defined in the `ComponentDecl` and it must contain only the
651    /// following characters: [a-z0-9-_.].
652    pub environment: Option<String>,
653    /// (Optional, defaults to `STATIC_ONLY`) The kinds of offers that can
654    /// target the child instances in this collection.
655    ///
656    /// Only components using the `dynamic_offers` restricted feature may set
657    /// this field.
658    pub allowed_offers: Option<AllowedOffers>,
659    /// (Optional, defaults to `false`) Whether child instances in this
660    /// collection can have names longer than the default length limit of 100.
661    ///
662    /// Only components using the `allow_long_names` restricted feature may set
663    /// this field.
664    pub allow_long_names: Option<bool>,
665    /// (Optional) Whether the data in isolated storage used by dynamic child
666    /// instances and their descendants will persist after the instances are
667    /// destroyed. New dynamic instances inherit the previous instances' data
668    /// stores.
669    ///
670    /// This setting can be overridden by a lower-level collection that is a
671    /// descendant of a collection that enables/disables this setting.
672    ///
673    /// This setting applies to all storage capabilities consumed by the
674    /// collection components and their descendants.
675    ///
676    /// The default is the value inherited from an ancestral collection if set,
677    /// otherwise `false`.
678    pub persistent_storage: Option<bool>,
679    #[doc(hidden)]
680    pub __source_breaking: fidl::marker::SourceBreaking,
681}
682
683impl fidl::Persistable for Collection {}
684
685/// A component declaration.
686///
687/// This information is typically encoded in the component manifest (.cm file)
688/// if it has one or may be generated at runtime by a component resolver for
689/// those that don't.
690#[derive(Clone, Debug, Default, PartialEq)]
691pub struct Component {
692    /// (Optional) Information about the program to run when the component is executed.
693    /// Omitted for non-executable components.
694    pub program: Option<Program>,
695    /// (Optional) List of capabilities used by the component. These consist of
696    /// capabilities offered to the component that are installed in its incoming
697    /// namespace.
698    ///
699    /// The used capabilities must be unique and non-overlapping.
700    pub uses: Option<Vec<Use>>,
701    /// (Optional) List of capabilities exposed by the component. These consist of
702    /// capabilities that are made visible to the parent. The parent
703    /// may `offer` these capabilities to its children, but not `use` them.
704    ///
705    /// The exposed capabilities must be unique and non-overlapping.
706    pub exposes: Option<Vec<Expose>>,
707    /// (Optional) List of capabilities offered to the component's children. These consist
708    /// of capabilities that the given children may `use`, which may come from a
709    /// child, the parent, or the component's own outgoing namespace.
710    ///
711    /// The offered capabilities must be unique and non-overlapping.
712    pub offers: Option<Vec<Offer>>,
713    /// (Optional) List of capabilities defined by the component.
714    pub capabilities: Option<Vec<Capability>>,
715    /// (Optional) The component's statically instantiated children. The children must have
716    /// unique names.
717    pub children: Option<Vec<Child>>,
718    /// (Optional) The component's collections. The collections must have unique names.
719    pub collections: Option<Vec<Collection>>,
720    /// (Optional) List of environments created by this component.
721    /// Environments are assigned to children and control aspects of a child component's
722    /// runtime.
723    pub environments: Option<Vec<Environment>>,
724    /// (Optional) Additional metadata about the component.
725    pub facets: Option<fidl_fuchsia_data__common::Dictionary>,
726    /// (Optional) The schema of the component's configuration interface.
727    pub config: Option<ConfigSchema>,
728    #[doc(hidden)]
729    pub __source_breaking: fidl::marker::SourceBreaking,
730}
731
732impl fidl::Persistable for Component {}
733
734/// Declares a single config field (key + type)
735#[derive(Clone, Debug, Default, PartialEq)]
736pub struct ConfigField {
737    /// (Required) The identifier for this config field.
738    /// This key will be used to match overrides.
739    pub key: Option<String>,
740    /// (Required) The type of config values. Config values are verified
741    /// against this layout at build time and run time.
742    pub type_: Option<ConfigType>,
743    /// Allowed sources for runtime overrides of this field's value.
744    pub mutability: Option<ConfigMutability>,
745    #[doc(hidden)]
746    pub __source_breaking: fidl::marker::SourceBreaking,
747}
748
749impl fidl::Persistable for ConfigField {}
750
751/// A directive to override the value of a particular configuration field in the child.
752#[derive(Clone, Debug, Default, PartialEq)]
753pub struct ConfigOverride {
754    pub key: Option<String>,
755    pub value: Option<ConfigValue>,
756    #[doc(hidden)]
757    pub __source_breaking: fidl::marker::SourceBreaking,
758}
759
760impl fidl::Persistable for ConfigOverride {}
761
762/// The schema of a component's configuration interface.
763#[derive(Clone, Debug, Default, PartialEq)]
764pub struct ConfigSchema {
765    /// (Required) Ordered fields of the component's configuration interface.
766    pub fields: Option<Vec<ConfigField>>,
767    /// (Required) Checksum over the config declaration.
768    pub checksum: Option<ConfigChecksum>,
769    /// (Required) Strategy used to resolve config values.
770    pub value_source: Option<ConfigValueSource>,
771    #[doc(hidden)]
772    pub __source_breaking: fidl::marker::SourceBreaking,
773}
774
775impl fidl::Persistable for ConfigSchema {}
776
777#[derive(Clone, Debug, Default, PartialEq)]
778pub struct ConfigSourceCapabilities {
779    #[doc(hidden)]
780    pub __source_breaking: fidl::marker::SourceBreaking,
781}
782
783impl fidl::Persistable for ConfigSourceCapabilities {}
784
785/// An individual configuration value. It is matched against a specific configuration field based
786/// on its offset within `ValuesData.values`.
787#[derive(Clone, Debug, Default, PartialEq)]
788pub struct ConfigValueSpec {
789    pub value: Option<ConfigValue>,
790    #[doc(hidden)]
791    pub __source_breaking: fidl::marker::SourceBreaking,
792}
793
794impl fidl::Persistable for ConfigValueSpec {}
795
796/// Contents of the configuration value file. Defines the base values for a component's config.
797#[derive(Clone, Debug, Default, PartialEq)]
798pub struct ConfigValuesData {
799    /// The concrete values for the component's configuration.
800    pub values: Option<Vec<ConfigValueSpec>>,
801    /// A SHA-256 checksum of the configuration schema. Must match the checksum in the component
802    /// manifest and config parser library used to resolve the final configuration.
803    pub checksum: Option<ConfigChecksum>,
804    #[doc(hidden)]
805    pub __source_breaking: fidl::marker::SourceBreaking,
806}
807
808impl fidl::Persistable for ConfigValuesData {}
809
810/// Declares a configuration capability.
811///
812/// To learn more about configuration capabilities, see:
813/// https://fuchsia.dev/fuchsia-src/glossary#configuration-capability
814/// or:
815/// https://fuchsia.dev/fuchsia-src/docs/concepts/components/v2/capabilities/configuration
816#[derive(Clone, Debug, Default, PartialEq)]
817pub struct Configuration {
818    /// (Required) The name of this configuration
819    pub name: Option<String>,
820    /// (Required) The value of this Configuration.
821    pub value: Option<ConfigValue>,
822    #[doc(hidden)]
823    pub __source_breaking: fidl::marker::SourceBreaking,
824}
825
826impl fidl::Persistable for Configuration {}
827
828/// Registers a protocol in the environment as a debug capability. This makes
829/// it available to any component in the environment that uses it with
830/// `source == debug`.
831///
832/// To learn more about protocols, see:
833/// https://fuchsia.dev/fuchsia-src/glossary#protocol
834#[derive(Clone, Debug, Default, PartialEq)]
835pub struct DebugProtocolRegistration {
836    /// (Required) The provider of the capability relative to the component
837    /// itself. Must be `parent`, `self`, or `child`.
838    pub source: Option<Ref>,
839    /// (Required) Name identifying the protocol being offered.
840    pub source_name: Option<String>,
841    /// (Required) The name by which the capability is being offered.
842    pub target_name: Option<String>,
843    #[doc(hidden)]
844    pub __source_breaking: fidl::marker::SourceBreaking,
845}
846
847impl fidl::Persistable for DebugProtocolRegistration {}
848
849/// Declares a dictionary capability.
850#[derive(Clone, Debug, Default, PartialEq)]
851pub struct Dictionary {
852    /// (Required) The name of this dictionary.
853    ///
854    /// Must be unique among built-in capabilities.
855    pub name: Option<String>,
856    /// (Optional) Source of the contents used to initialize the dictionary.
857    /// Must be `parent`, `self`, or `child`.
858    pub source: Option<Ref>,
859    /// (Optional) Path in a dictionary provided by `ref` which contains the contents
860    /// that will be used to initialize the dictionary.
861    ///
862    /// This must be set iff `source` is set.
863    pub source_dictionary: Option<String>,
864    /// (Optional) Path in the component's outgoing directory to a
865    /// [fuchsia.component.sandbox/DictionaryRouter] that returns a
866    /// [fuchsia.component.sandbox/DirectoryRef] for this dictionary.
867    ///
868    /// If this is set, it means the dictionary is provided by the program directly, not component
869    /// manager. `source` and `source_dictionary` must be `null` if this is set.
870    pub source_path: Option<String>,
871    #[doc(hidden)]
872    pub __source_breaking: fidl::marker::SourceBreaking,
873}
874
875impl fidl::Persistable for Dictionary {}
876
877/// Declares a directory capability backed by this component.
878///
879/// To learn more about directories, see:
880/// https://fuchsia.dev/fuchsia-src/glossary#directory
881#[derive(Clone, Debug, Default, PartialEq)]
882pub struct Directory {
883    /// (Required) The name of this directory.
884    pub name: Option<String>,
885    /// (Optional) The path to the directory in the component's outgoing
886    /// directory.
887    ///
888    /// Not set for built-in capabilities.
889    pub source_path: Option<String>,
890    /// (Required) The maximum rights that can be set by a component using this
891    /// directory.
892    pub rights: Option<fidl_fuchsia_io__common::Operations>,
893    #[doc(hidden)]
894    pub __source_breaking: fidl::marker::SourceBreaking,
895}
896
897impl fidl::Persistable for Directory {}
898
899/// Declares an environment which configures a realm.
900#[derive(Clone, Debug, Default, PartialEq)]
901pub struct Environment {
902    /// (Required) The name of this environment.
903    pub name: Option<String>,
904    /// (Required) Specifies how the initial state of this environment is
905    /// constructed.
906    pub extends: Option<EnvironmentExtends>,
907    /// (Optional) List of runners available in this environment.
908    ///
909    /// This list determines the total set of runners that are available for any
910    /// component in the environment to use.
911    pub runners: Option<Vec<RunnerRegistration>>,
912    /// (Optional) List of component resolvers and the URL schemes they are
913    /// registered to resolve. These registrations determine how components are
914    /// resolved in the realm. If the component URL scheme does not match any of
915    /// these resolvers, URL resolution is delegated to the parent environment,
916    /// if this environment `extends` from `REALM`.
917    pub resolvers: Option<Vec<ResolverRegistration>>,
918    /// (Optional) Expose capabilities to debug section when component manager
919    /// allows it.
920    ///
921    /// These capabilities are accessible to any component in the environment
922    /// with a `use` declaration with `source == debug`.  Only capabilities
923    /// intended to support development should be declared here, and they are
924    /// only allowed if explicitly included in the component manager allowlist.
925    pub debug_capabilities: Option<Vec<DebugRegistration>>,
926    /// (Optional) The duration in milliseconds that the component will have to
927    /// stop before it is killed. Required if this environment `extends` from
928    /// `NONE`.
929    pub stop_timeout_ms: Option<u32>,
930    #[doc(hidden)]
931    pub __source_breaking: fidl::marker::SourceBreaking,
932}
933
934impl fidl::Persistable for Environment {}
935
936/// Declares an event_stream capability
937///
938/// This type cannot be used in `fuchsia.component.decl.Component`. It is only
939/// used for the framework's built-in capabilities declared in
940/// `internal.Config`.
941#[derive(Clone, Debug, Default, PartialEq)]
942pub struct EventStream {
943    /// (Required) The name of this event stream.
944    ///
945    /// Must be unique among built-in capabilities.
946    pub name: Option<String>,
947    #[doc(hidden)]
948    pub __source_breaking: fidl::marker::SourceBreaking,
949}
950
951impl fidl::Persistable for EventStream {}
952
953/// Indicates the event name to subscribe to with a given event mode.
954#[derive(Clone, Debug, Default, PartialEq)]
955pub struct EventSubscription {
956    /// (Required) The event names to subscribe to.
957    pub event_name: Option<String>,
958    #[doc(hidden)]
959    pub __source_breaking: fidl::marker::SourceBreaking,
960}
961
962impl fidl::Persistable for EventSubscription {}
963
964/// Declares a configuration capability exposed to a component's containing realm, such as
965/// a capability exposed by the component or one of its children at runtime.
966#[derive(Clone, Debug, Default, PartialEq)]
967pub struct ExposeConfiguration {
968    /// (Required) The provider of the capability relative to the component
969    /// itself. Must be `self` or `child`, or `void`. If set to `void`, then the
970    /// target must expose, offer, or use the capability with `OPTIONAL` or
971    /// `TRANSITIONAL` availability.
972    pub source: Option<Ref>,
973    /// (Required) Name identifying the configuration, by which it was presented to
974    /// this component.
975    pub source_name: Option<String>,
976    /// (Required) The destination to which the capability is exposed.
977    pub target: Option<Ref>,
978    /// (Required) The name by which the capability is being exposed.
979    pub target_name: Option<String>,
980    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
981    /// See [`Availability`].
982    pub availability: Option<Availability>,
983    /// (Optional) Path in a dictionary provided by `source` which contains `source_name`.
984    /// If this field is absent, `source_name` identifies a capability directly routed
985    /// by `source`. If set, `source_name` identifies a capability nested inside this
986    /// dictionary.
987    pub source_dictionary: Option<String>,
988    #[doc(hidden)]
989    pub __source_breaking: fidl::marker::SourceBreaking,
990}
991
992impl fidl::Persistable for ExposeConfiguration {}
993
994/// Declares a dictionary exposed to a component's containing realm, such as
995/// a dictionary exposed by the component or one of its children at runtime.
996///
997/// To learn more about dictionarys, see:
998/// https://fuchsia.dev/fuchsia-src/glossary#dictionary
999#[derive(Clone, Debug, Default, PartialEq)]
1000pub struct ExposeDictionary {
1001    /// (Required) The provider of the capability relative to the component
1002    /// itself. Must be `self` or `child`, or `void`. If set to `void`, then the
1003    /// target must expose, offer, or use the capability with `OPTIONAL` or
1004    /// `TRANSITIONAL` availability.
1005    pub source: Option<Ref>,
1006    /// (Required) Name identifying the dictionary, by which it was presented to
1007    /// this component.
1008    pub source_name: Option<String>,
1009    /// (Required) The destination to which the dictionary is exposed: either the
1010    /// component's realm or the framework.
1011    pub target: Option<Ref>,
1012    /// (Required) The name by which the capability is being exposed.
1013    pub target_name: Option<String>,
1014    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1015    /// See [`Availability`].
1016    pub availability: Option<Availability>,
1017    /// (Optional) Path in a dictionary offered by `ref` which contains `source_name`.
1018    /// If this field is absent, `source_name` identifies a capability directly routed
1019    /// by `source`. If set, `source_name` identifies a capability nested inside a
1020    /// dictionary. The name of the top-level dictionary is given by the first path
1021    /// segment of `source_dictionary`, and `source` is expected to route a
1022    /// dictionary capability with this name. The rest of the path (possibly empty)
1023    /// represents the path to a dictionary nested in the top-level dictionary which
1024    /// is expected to contain `source_name`.
1025    pub source_dictionary: Option<String>,
1026    #[doc(hidden)]
1027    pub __source_breaking: fidl::marker::SourceBreaking,
1028}
1029
1030impl fidl::Persistable for ExposeDictionary {}
1031
1032/// Declares a directory exposed to a component's containing realm, such as a
1033/// directory exposed by the component or one of its children at runtime.
1034#[derive(Clone, Debug, Default, PartialEq)]
1035pub struct ExposeDirectory {
1036    /// (Required) The provider of the capability relative to the component
1037    /// itself. Must be `self` or `child`, or `void`. If set to `void`, then the
1038    /// target must expose, offer, or use the capability with `OPTIONAL` or
1039    /// `TRANSITIONAL` availability.
1040    pub source: Option<Ref>,
1041    /// (Required) Name identifying the directory, by which it was presented to
1042    /// this component.
1043    pub source_name: Option<String>,
1044    /// (Required) The destination to which the directory is exposed: either the
1045    /// component's realm or the framework.
1046    pub target: Option<Ref>,
1047    /// (Required) The name by which the capability is being exposed.
1048    pub target_name: Option<String>,
1049    /// (Optional) The maximum rights that can be set by a component using this
1050    /// directory. If unset, the rights are inherited from `source`.
1051    pub rights: Option<fidl_fuchsia_io__common::Operations>,
1052    /// (Optional) The subdirectory of this directory to expose instead of the
1053    /// root.
1054    pub subdir: Option<String>,
1055    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1056    /// See [`Availability`].
1057    pub availability: Option<Availability>,
1058    /// (Optional) Path in a dictionary offered by `ref` which contains `source_name`.
1059    /// If this field is absent, `source_name` identifies a capability directly routed
1060    /// by `source`. If set, `source_name` identifies a capability nested inside a
1061    /// dictionary. The name of the top-level dictionary is given by the first path
1062    /// segment of `source_dictionary`, and `source` is expected to route a
1063    /// dictionary capability with this name. The rest of the path (possibly empty)
1064    /// represents the path to a dictionary nested in the top-level dictionary which
1065    /// is expected to contain `source_name`.
1066    pub source_dictionary: Option<String>,
1067    #[doc(hidden)]
1068    pub __source_breaking: fidl::marker::SourceBreaking,
1069}
1070
1071impl fidl::Persistable for ExposeDirectory {}
1072
1073/// Declares a protocol exposed to a component's containing realm, such as
1074/// a protocol exposed by the component or one of its children at runtime.
1075///
1076/// To learn more about protocols, see:
1077/// https://fuchsia.dev/fuchsia-src/glossary#protocol
1078#[derive(Clone, Debug, Default, PartialEq)]
1079pub struct ExposeProtocol {
1080    /// (Required) The provider of the capability relative to the component
1081    /// itself. Must be `self` or `child`, or `void`. If set to `void`, then the
1082    /// target must expose, offer, or use the capability with `OPTIONAL` or
1083    /// `TRANSITIONAL` availability.
1084    pub source: Option<Ref>,
1085    /// (Required) Name identifying the protocol, by which it was presented to
1086    /// this component.
1087    pub source_name: Option<String>,
1088    /// (Required) The destination to which the protocol is exposed: either the
1089    /// component's realm or the framework.
1090    pub target: Option<Ref>,
1091    /// (Required) The name by which the capability is being exposed.
1092    pub target_name: Option<String>,
1093    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1094    /// See [`Availability`].
1095    pub availability: Option<Availability>,
1096    /// (Optional) Path in a dictionary offered by `ref` which contains `source_name`.
1097    /// If this field is absent, `source_name` identifies a capability directly routed
1098    /// by `source`. If set, `source_name` identifies a capability nested inside a
1099    /// dictionary. The name of the top-level dictionary is given by the first path
1100    /// segment of `source_dictionary`, and `source` is expected to route a
1101    /// dictionary capability with this name. The rest of the path (possibly empty)
1102    /// represents the path to a dictionary nested in the top-level dictionary which
1103    /// is expected to contain `source_name`.
1104    pub source_dictionary: Option<String>,
1105    #[doc(hidden)]
1106    pub __source_breaking: fidl::marker::SourceBreaking,
1107}
1108
1109impl fidl::Persistable for ExposeProtocol {}
1110
1111/// Declares a resolver exposed to a component's containing realm, such as a
1112/// resolver exposed by the component or one of its children at runtime.
1113#[derive(Clone, Debug, Default, PartialEq)]
1114pub struct ExposeResolver {
1115    /// (Required) The provider of the capability relative to the component
1116    /// itself. Must be `self` or `child`.
1117    pub source: Option<Ref>,
1118    /// (Required) The name of the resolver, by which it was presented to this
1119    /// component.
1120    pub source_name: Option<String>,
1121    /// (Required) The destination to which the resolver is exposed
1122    pub target: Option<Ref>,
1123    /// (Required) The name by which the capability is being exposed.
1124    pub target_name: Option<String>,
1125    /// (Optional) Path in a dictionary offered by `ref` which contains `source_name`.
1126    /// If this field is absent, `source_name` identifies a capability directly routed
1127    /// by `source`. If set, `source_name` identifies a capability nested inside a
1128    /// dictionary. The name of the top-level dictionary is given by the first path
1129    /// segment of `source_dictionary`, and `source` is expected to route a
1130    /// dictionary capability with this name. The rest of the path (possibly empty)
1131    /// represents the path to a dictionary nested in the top-level dictionary which
1132    /// is expected to contain `source_name`.
1133    pub source_dictionary: Option<String>,
1134    #[doc(hidden)]
1135    pub __source_breaking: fidl::marker::SourceBreaking,
1136}
1137
1138impl fidl::Persistable for ExposeResolver {}
1139
1140/// Declares a runner exposed to a component's containing realm, such as a
1141/// runner exposed by the component or one of its children at runtime.
1142#[derive(Clone, Debug, Default, PartialEq)]
1143pub struct ExposeRunner {
1144    /// (Required) The provider of the capability relative to the component
1145    /// itself. Must be `self` or `child`.
1146    pub source: Option<Ref>,
1147    /// (Required) The name of the runner, by which it was presented to this
1148    /// component.
1149    pub source_name: Option<String>,
1150    /// (Required) The destination to which the runner is exposed: either the
1151    /// component's realm or the framework.
1152    pub target: Option<Ref>,
1153    /// (Required) The name by which the capability is being exposed.
1154    pub target_name: Option<String>,
1155    /// (Optional) Path in a dictionary offered by `ref` which contains `source_name`.
1156    /// If this field is absent, `source_name` identifies a capability directly routed
1157    /// by `source`. If set, `source_name` identifies a capability nested inside a
1158    /// dictionary. The name of the top-level dictionary is given by the first path
1159    /// segment of `source_dictionary`, and `source` is expected to route a
1160    /// dictionary capability with this name. The rest of the path (possibly empty)
1161    /// represents the path to a dictionary nested in the top-level dictionary which
1162    /// is expected to contain `source_name`.
1163    pub source_dictionary: Option<String>,
1164    #[doc(hidden)]
1165    pub __source_breaking: fidl::marker::SourceBreaking,
1166}
1167
1168impl fidl::Persistable for ExposeRunner {}
1169
1170/// Declares a service exposed to a component's containing realm, such as a
1171/// service exposed by the component or one of its children at runtime.
1172///
1173/// To learn more about services, see:
1174/// https://fuchsia.dev/fuchsia-src/glossary#service
1175#[derive(Clone, Debug, Default, PartialEq)]
1176pub struct ExposeService {
1177    /// (Required) The provider of the capability relative to the component
1178    /// itself. Must be `self` or `child`, or `void`. If set to `void`, then the
1179    /// target must expose, offer, or use the capability with `OPTIONAL` or
1180    /// `TRANSITIONAL` availability.
1181    pub source: Option<Ref>,
1182    /// (Required) Name identifying the service, by which it was presented to
1183    /// this component.
1184    pub source_name: Option<String>,
1185    /// (Required) The destination to which the service is exposed: either the
1186    /// component's realm or the framework.
1187    pub target: Option<Ref>,
1188    /// (Required) The name by which the capability is being exposed.
1189    pub target_name: Option<String>,
1190    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1191    /// See [`Availability`].
1192    pub availability: Option<Availability>,
1193    /// (Optional) Path in a dictionary provided by `source` which contains `source_name`.
1194    /// If this field is absent, `source_name` identifies a capability directly routed
1195    /// by `source`. If set, `source_name` identifies a capability nested inside this
1196    /// dictionary.
1197    pub source_dictionary: Option<String>,
1198    #[doc(hidden)]
1199    pub __source_breaking: fidl::marker::SourceBreaking,
1200}
1201
1202impl fidl::Persistable for ExposeService {}
1203
1204/// Declares a configuration capability offered by a component to one of its children,
1205/// which may have been offered by the component's containing realm, the
1206/// component itself, or one of its other children.
1207#[derive(Clone, Debug, Default, PartialEq)]
1208pub struct OfferConfiguration {
1209    /// (Required) The provider of the capability relative to the component
1210    /// itself. Must be `parent`, `self`, `child`, or `void`.
1211    /// If set to `void`, then the target must offer or use the capability with
1212    /// `OPTIONAL` or `TRANSITIONAL` availability.
1213    pub source: Option<Ref>,
1214    /// (Required) Name identifying the configuration being offered.
1215    pub source_name: Option<String>,
1216    /// (Required) Reference to the target. Must be `child`, or `collection`.
1217    pub target: Option<Ref>,
1218    /// (Required) The name by which the capability is being offered.
1219    pub target_name: Option<String>,
1220    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1221    /// If set to `required`, the target may use or offer the capability with
1222    /// either `required` or `optional` availability. If set to `optional`, the
1223    /// target must use or offer the capability with `optional` availability.
1224    /// The `same_as_target` value causes this offer's availability to match the
1225    /// availability set in the target.
1226    pub availability: Option<Availability>,
1227    /// (Optional) Path in a dictionary provided by `source` which contains `source_name`.
1228    /// If this field is absent, `source_name` identifies a capability directly routed
1229    /// by `source`. If set, `source_name` identifies a capability nested inside this
1230    /// dictionary.
1231    pub source_dictionary: Option<String>,
1232    #[doc(hidden)]
1233    pub __source_breaking: fidl::marker::SourceBreaking,
1234}
1235
1236impl fidl::Persistable for OfferConfiguration {}
1237
1238/// Declares a dictionary offered by a component to one of its children,
1239/// which may have been offered by the component's containing realm, the
1240/// component itself, or one of its other children.
1241///
1242/// To learn more about dictionaries, see:
1243/// https://fuchsia.dev/fuchsia-src/glossary#dictionary
1244#[derive(Clone, Debug, Default, PartialEq)]
1245pub struct OfferDictionary {
1246    /// (Required) The provider of the capability relative to the component
1247    /// itself. Must be `parent`, `self`, `child`, or `void`.
1248    /// If set to `void`, then the target must offer or use the capability with
1249    /// `OPTIONAL` or `TRANSITIONAL` availability.
1250    pub source: Option<Ref>,
1251    /// (Required) Name identifying the dictionary being offered.
1252    pub source_name: Option<String>,
1253    /// (Required) Reference to the target. Must be `child`, `collection`, or
1254    /// a dictionary `capability`.
1255    pub target: Option<Ref>,
1256    /// (Required) The name by which the capability is being offered.
1257    pub target_name: Option<String>,
1258    /// (Required) The dependency type this offer represents. A component which
1259    /// receives a weak offer must support the offered capability being
1260    /// unavailable at any point.
1261    pub dependency_type: Option<DependencyType>,
1262    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1263    /// If set to `required`, the target may use or offer the capability with
1264    /// either `required` or `optional` availability. If set to `optional`, the
1265    /// target must use or offer the capability with `optional` availability.
1266    /// The `same_as_target` value causes this offer's availability to match the
1267    /// availability set in the target.
1268    pub availability: Option<Availability>,
1269    /// (Optional) Path in a dictionary provided by `source` which contains `source_name`.
1270    /// If this field is absent, `source_name` identifies a capability directly routed
1271    /// by `source`. If set, `source_name` identifies a capability nested inside this
1272    /// dictionary.
1273    pub source_dictionary: Option<String>,
1274    #[doc(hidden)]
1275    pub __source_breaking: fidl::marker::SourceBreaking,
1276}
1277
1278impl fidl::Persistable for OfferDictionary {}
1279
1280/// Declares a directory offered by a component to one of its children, which
1281/// may have been offered by the component's containing realm, the component
1282/// itself, or one of its other children.
1283#[derive(Clone, Debug, Default, PartialEq)]
1284pub struct OfferDirectory {
1285    /// (Required) The provider of the capability relative to the component
1286    /// itself. Must be `parent`, `self`, `child`, or `void`.
1287    /// If set to `void`, then the target must offer or use the capability with
1288    /// `OPTIONAL` or `TRANSITIONAL` availability.
1289    pub source: Option<Ref>,
1290    /// (Required) Name identifying the directory being offered.
1291    pub source_name: Option<String>,
1292    /// (Required) Reference to the target. Must be `child`, `collection`, or
1293    /// a dictionary `capability`.
1294    pub target: Option<Ref>,
1295    /// (Required) The name by which the capability is being offered.
1296    pub target_name: Option<String>,
1297    /// (Optional) The maximum rights that can be set by a component using this
1298    /// directory. IF unset, the rights are inherited from `source`.
1299    pub rights: Option<fidl_fuchsia_io__common::Operations>,
1300    /// (Optional) The subdirectory of this directory to offer instead of the
1301    /// root. Optional.
1302    pub subdir: Option<String>,
1303    /// (Required) The dependency type this offer represents. A component which
1304    /// receives a weak offer must support the offered capability being
1305    /// unavailable at any point.
1306    pub dependency_type: Option<DependencyType>,
1307    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1308    /// If set to `required`, the target may use or offer the capability with
1309    /// either `required` or `optional` availability. If set to `optional`, the
1310    /// target must use or offer the capability with `optional` availability.
1311    /// The `same_as_target` value causes this offer's availability to match the
1312    /// availability set in the target.
1313    pub availability: Option<Availability>,
1314    /// (Optional) Path in a dictionary provided by `source` which contains `source_name`.
1315    /// If this field is absent, `source_name` identifies a capability directly routed
1316    /// by `source`. If set, `source_name` identifies a capability nested inside this
1317    /// dictionary.
1318    pub source_dictionary: Option<String>,
1319    #[doc(hidden)]
1320    pub __source_breaking: fidl::marker::SourceBreaking,
1321}
1322
1323impl fidl::Persistable for OfferDirectory {}
1324
1325/// Declares an event stream offered by a component.
1326#[derive(Clone, Debug, Default, PartialEq)]
1327pub struct OfferEventStream {
1328    /// (Required) The provider of the capability relative to the component
1329    /// itself. Must be `parent`, `framework`, `child`, or `void`. If set to
1330    /// `void`, then the target must offer or use the capability with `OPTIONAL`
1331    /// or `TRANSITIONAL` availability.
1332    pub source: Option<Ref>,
1333    /// (Required) Name of the event being offered.
1334    pub source_name: Option<String>,
1335    /// (Optional) When an event is offered from framework, the scope is
1336    /// required and allows one to define the child (or array of children) which
1337    /// the event is about. When the event is offered from parent, the scope can
1338    /// be used to downscope the event to a certain child scope, otherwise the
1339    /// event will carry the scope coming from the parent.
1340    pub scope: Option<Vec<Ref>>,
1341    /// (Required) The destination to which the event stream is offered.
1342    pub target: Option<Ref>,
1343    /// (Required) Name under which the event stream is being offered.
1344    pub target_name: Option<String>,
1345    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1346    /// If set to `required`, the target may use or offer the capability with
1347    /// either `required` or `optional` availability. If set to `optional`, the
1348    /// target must use or offer the capability with `optional` availability.
1349    /// The `same_as_target` value causes this offer's availability to match the
1350    /// availability set in the target.
1351    pub availability: Option<Availability>,
1352    #[doc(hidden)]
1353    pub __source_breaking: fidl::marker::SourceBreaking,
1354}
1355
1356impl fidl::Persistable for OfferEventStream {}
1357
1358/// Declares a protocol offered by a component to one of its children,
1359/// which may have been offered by the component's containing realm, the
1360/// component itself, or one of its other children.
1361///
1362/// To learn more about protocols, see:
1363/// https://fuchsia.dev/fuchsia-src/glossary#protocol
1364#[derive(Clone, Debug, Default, PartialEq)]
1365pub struct OfferProtocol {
1366    /// (Required) The provider of the capability relative to the component
1367    /// itself. Must be `parent`, `self`, `child`, or `void`.
1368    /// If set to `void`, then the target must offer or use the capability with
1369    /// `OPTIONAL` or `TRANSITIONAL` availability.
1370    pub source: Option<Ref>,
1371    /// (Required) Name identifying the protocol being offered.
1372    pub source_name: Option<String>,
1373    /// (Required) Reference to the target. Must be `child`, `collection`, or
1374    /// a dictionary `capability`.
1375    pub target: Option<Ref>,
1376    /// (Required) The name by which the capability is being offered.
1377    pub target_name: Option<String>,
1378    /// (Required) The dependency type this offer represents. A component which
1379    /// receives a weak offer must support the offered capability being
1380    /// unavailable at any point.
1381    pub dependency_type: Option<DependencyType>,
1382    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1383    /// If set to `required`, the target may use or offer the capability with
1384    /// either `required` or `optional` availability. If set to `optional`, the
1385    /// target must use or offer the capability with `optional` availability.
1386    /// The `same_as_target` value causes this offer's availability to match the
1387    /// availability set in the target.
1388    pub availability: Option<Availability>,
1389    /// (Optional) Path in a dictionary provided by `source` which contains `source_name`.
1390    /// If this field is absent, `source_name` identifies a capability directly routed
1391    /// by `source`. If set, `source_name` identifies a capability nested inside this
1392    /// dictionary.
1393    pub source_dictionary: Option<String>,
1394    #[doc(hidden)]
1395    pub __source_breaking: fidl::marker::SourceBreaking,
1396}
1397
1398impl fidl::Persistable for OfferProtocol {}
1399
1400/// Declares a resolver capability offered by a component to one of its children, which
1401/// may have been offered by the component's containing realm, the component itself,
1402/// or one of its other children.
1403#[derive(Clone, Debug, Default, PartialEq)]
1404pub struct OfferResolver {
1405    /// (Required) The provider of the capability relative to the component
1406    /// itself. Must be `parent`, `self`, `child`, or `void`.
1407    /// If set to `void`, then the target must offer or use the capability with
1408    /// `OPTIONAL` or `TRANSITIONAL` availability.
1409    pub source: Option<Ref>,
1410    /// (Required) Name of the resolver being offered.
1411    pub source_name: Option<String>,
1412    /// (Required) Reference to the target. Must be `child`, `collection`, or
1413    /// a dictionary `capability`.
1414    pub target: Option<Ref>,
1415    /// (Required) Name under which the capability is being offered.
1416    pub target_name: Option<String>,
1417    /// (Optional) Path in a dictionary provided by `source` which contains `source_name`.
1418    /// If this field is absent, `source_name` identifies a capability directly routed
1419    /// by `source`. If set, `source_name` identifies a capability nested inside this
1420    /// dictionary.
1421    pub source_dictionary: Option<String>,
1422    #[doc(hidden)]
1423    pub __source_breaking: fidl::marker::SourceBreaking,
1424}
1425
1426impl fidl::Persistable for OfferResolver {}
1427
1428/// Declares a runner offered by a component to one of its children, which may
1429/// have been offered by the component's containing realm, the component itself,
1430/// or one of its other children.
1431#[derive(Clone, Debug, Default, PartialEq)]
1432pub struct OfferRunner {
1433    /// (Required) The provider of the capability relative to the component
1434    /// itself. Must be `parent`, `self`, `child`, or `void`.
1435    /// If set to `void`, then the target must offer or use the capability with
1436    /// `OPTIONAL` or `TRANSITIONAL` availability.
1437    pub source: Option<Ref>,
1438    /// (Required) Name of the runner being offered.
1439    pub source_name: Option<String>,
1440    /// (Required) Reference to the target. Must be `child`, `collection`, or
1441    /// a dictionary `capability`.
1442    pub target: Option<Ref>,
1443    /// (Required) Name under which the capability is being offered.
1444    pub target_name: Option<String>,
1445    /// (Optional) Path in a dictionary provided by `source` which contains `source_name`.
1446    /// If this field is absent, `source_name` identifies a capability directly routed
1447    /// by `source`. If set, `source_name` identifies a capability nested inside this
1448    /// dictionary.
1449    pub source_dictionary: Option<String>,
1450    #[doc(hidden)]
1451    pub __source_breaking: fidl::marker::SourceBreaking,
1452}
1453
1454impl fidl::Persistable for OfferRunner {}
1455
1456/// Declares a service offered by a component to one of its children, which may
1457/// have been offered by the component's containing realm, the component itself,
1458/// or one of its other children.
1459///
1460/// To learn more about services, see:
1461/// https://fuchsia.dev/fuchsia-src/glossary#service
1462#[derive(Clone, Debug, Default, PartialEq)]
1463pub struct OfferService {
1464    /// (Required) The provider of the capability relative to the component
1465    /// itself. Must be `parent`, `self`, `child`, or `void`.
1466    /// If set to `void`, then the target must offer or use the capability with
1467    /// `OPTIONAL` or `TRANSITIONAL` availability.
1468    pub source: Option<Ref>,
1469    /// (Required) Name identifying the service being offered.
1470    pub source_name: Option<String>,
1471    /// (Required) Reference to the target. Must be `child`, `collection`, or
1472    /// a dictionary `capability`.
1473    pub target: Option<Ref>,
1474    /// (Required) The name under which the capability is being offered.
1475    pub target_name: Option<String>,
1476    /// (Optional) The list of allowlisted instances to be offered. Instances
1477    /// of the service not in this list will not be accessible by the target
1478    /// component. If this is not set that means all instances from the source
1479    /// service are offered.
1480    pub source_instance_filter: Option<Vec<String>>,
1481    /// (Optional) The list of allowlisted instances to be offered, with
1482    /// renames.
1483    ///
1484    /// If this is set and nonempty, the set of instances in the target service
1485    /// will be restricted to the instances in this list, renaming `source_name`
1486    /// to `target_name`.
1487    ///
1488    /// If it is set and nonempty, `source_instance_filter` will further
1489    /// restrict the set of instances to those whose `target_name` appears in
1490    /// that list. There is generally no reason to set both, but we support it
1491    /// for compatibility.
1492    pub renamed_instances: Option<Vec<NameMapping>>,
1493    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1494    /// If set to `required`, the target may use or offer the capability with
1495    /// either `required` or `optional` availability. If set to `optional`, the
1496    /// target must use or offer the capability with `optional` availability.
1497    /// The `same_as_target` value causes this offer's availability to match the
1498    /// availability set in the target.
1499    pub availability: Option<Availability>,
1500    /// (Optional) Path in a dictionary provided by `source` which contains `source_name`.
1501    /// If this field is absent, `source_name` identifies a capability directly routed
1502    /// by `source`. If set, `source_name` identifies a capability nested inside this
1503    /// dictionary.
1504    pub source_dictionary: Option<String>,
1505    /// (Optional, defaults to `STRONG`) The dependency type this offer represents.
1506    /// A component which receives a weak offer must support the offered capability being
1507    /// unavailable at any point.
1508    pub dependency_type: Option<DependencyType>,
1509    #[doc(hidden)]
1510    pub __source_breaking: fidl::marker::SourceBreaking,
1511}
1512
1513impl fidl::Persistable for OfferService {}
1514
1515/// Declares a storage capability offered by a component to one of its children,
1516/// such as meta storage offered by the component's containing realm or cache
1517/// storage offered by the component itself.
1518#[derive(Clone, Debug, Default, PartialEq)]
1519pub struct OfferStorage {
1520    /// (Required) The name of the storage capability being offered
1521    pub source_name: Option<String>,
1522    /// (Required) The provider of the capability relative to the component
1523    /// itself. Must be `parent`, `self`, `child`, or `void`.
1524    /// If set to `void`, then the target must offer or use the capability with
1525    /// `OPTIONAL` or `TRANSITIONAL` availability.
1526    pub source: Option<Ref>,
1527    /// (Required) Reference to the target. Must be `child`, `collection`, or
1528    /// a dictionary `capability`.
1529    pub target: Option<Ref>,
1530    /// (Required) The name the storage capability is being offered as
1531    pub target_name: Option<String>,
1532    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1533    /// If set to `required`, the target may use or offer the capability with
1534    /// either `required` or `optional` availability. If set to `optional`, the
1535    /// target must use or offer the capability with `optional` availability.
1536    /// The `same_as_target` value causes this offer's availability to match the
1537    /// availability set in the target.
1538    pub availability: Option<Availability>,
1539    #[doc(hidden)]
1540    pub __source_breaking: fidl::marker::SourceBreaking,
1541}
1542
1543impl fidl::Persistable for OfferStorage {}
1544
1545/// A program declaration.
1546///
1547/// This declaration is set by executable components to designate the runner to
1548/// use and pass runner-specific program information to it.
1549///
1550/// To learn more about runners, see:
1551/// https://fuchsia.dev/fuchsia-src/glossary#runner
1552#[derive(Clone, Debug, Default, PartialEq)]
1553pub struct Program {
1554    /// The name of the runner to use to run the component. Must match a `RunnerRegistration` in the
1555    /// component's environment. If this value is not supplied, the component must 'use' a runner.
1556    /// If this value is supplied, the component may 'use' a runner, but it must be identical
1557    /// (matching name, from environment).
1558    pub runner: Option<String>,
1559    /// (Required) Information about the program to run when the component is
1560    /// executed. The component manager provides the contents of this dictionary
1561    /// to the runner when executing this program.
1562    ///
1563    /// For instance, this might contain a path to the program's executable
1564    /// image, or program arguments.
1565    ///
1566    /// * The keys represent namespaced properties, delimited by ".".
1567    /// * Properties may be nested in values, but only in the case of an object
1568    /// vector.
1569    pub info: Option<fidl_fuchsia_data__common::Dictionary>,
1570    #[doc(hidden)]
1571    pub __source_breaking: fidl::marker::SourceBreaking,
1572}
1573
1574impl fidl::Persistable for Program {}
1575
1576/// Declares a protocol capability backed by this component.
1577///
1578/// To learn more about protocols, see:
1579/// https://fuchsia.dev/fuchsia-src/glossary#protocol
1580#[derive(Clone, Debug, Default, PartialEq)]
1581pub struct Protocol {
1582    /// (Required) The name of this protocol.
1583    pub name: Option<String>,
1584    /// (Optional) The path to the protocol in the component's outgoing
1585    /// directory.
1586    ///
1587    /// Not set for built-in capabilities.
1588    pub source_path: Option<String>,
1589    /// (Optional, defaults to `EAGER`) specifies when the framework will open
1590    /// the protocol from this component's outgoing directory when someone
1591    /// requests the capability. See details on `DeliveryType`.
1592    pub delivery: Option<DeliveryType>,
1593    #[doc(hidden)]
1594    pub __source_breaking: fidl::marker::SourceBreaking,
1595}
1596
1597impl fidl::Persistable for Protocol {}
1598
1599/// Declares a resolver which is responsible for resolving component URLs to
1600/// actual components. See `fuchsia.component.resolution.Resolver` for the
1601/// protocol resolvers are expected to implement.
1602#[derive(Clone, Debug, Default, PartialEq)]
1603pub struct Resolver {
1604    /// (Required) The name of this resolver.
1605    ///
1606    /// Must be unique among resolvers declared in the same `ComponentDecl`.
1607    pub name: Option<String>,
1608    /// (Optional) The path to the resolver protocol in the component's outgoing
1609    /// directory
1610    ///
1611    /// Not set for built-in capabilities.
1612    pub source_path: Option<String>,
1613    #[doc(hidden)]
1614    pub __source_breaking: fidl::marker::SourceBreaking,
1615}
1616
1617impl fidl::Persistable for Resolver {}
1618
1619/// A mapping of URL scheme to resolver name.
1620#[derive(Clone, Debug, Default, PartialEq)]
1621pub struct ResolverRegistration {
1622    /// (Required) The name of the resolver.
1623    pub resolver: Option<String>,
1624    /// (Required) The provider of the capability relative to the component
1625    /// itself. Must be `parent`, `self`, or `child`.
1626    pub source: Option<Ref>,
1627    /// (Required) The URL scheme the resolver is registered to handle. Only one
1628    /// resolver may be registered to a particular URL scheme. The URL scheme
1629    /// must start with a lowercase ASCII letter (a-z), and may contain
1630    /// lowercase ASCII letters, digits, `+`, `-`, and `.`.
1631    pub scheme: Option<String>,
1632    #[doc(hidden)]
1633    pub __source_breaking: fidl::marker::SourceBreaking,
1634}
1635
1636impl fidl::Persistable for ResolverRegistration {}
1637
1638/// Declares a runner capability backed by a service.
1639#[derive(Clone, Debug, Default, PartialEq)]
1640pub struct Runner {
1641    /// (Required) The name of this runner.
1642    ///
1643    /// Must unique among runners declared in the same `ComponentDecl`.
1644    pub name: Option<String>,
1645    /// (Optional) The path to the runner protocol in the component's outgoing
1646    /// directory.
1647    ///
1648    /// Not set for built-in capabilities.
1649    pub source_path: Option<String>,
1650    #[doc(hidden)]
1651    pub __source_breaking: fidl::marker::SourceBreaking,
1652}
1653
1654impl fidl::Persistable for Runner {}
1655
1656/// A repository of the runners available in an environment.
1657#[derive(Clone, Debug, Default, PartialEq)]
1658pub struct RunnerRegistration {
1659    /// (Required) The name of the runner capability as it's exposed to,
1660    /// offered, or defined by this component.
1661    pub source_name: Option<String>,
1662    /// (Required) The provider of the capability relative to the component
1663    /// itself. Must be `parent`, `self`, or `child`.
1664    pub source: Option<Ref>,
1665    /// (Required) The name by which the runner is made available in this
1666    /// environment.
1667    pub target_name: Option<String>,
1668    #[doc(hidden)]
1669    pub __source_breaking: fidl::marker::SourceBreaking,
1670}
1671
1672impl fidl::Persistable for RunnerRegistration {}
1673
1674/// Declares a service capability backed by this component.
1675///
1676/// To learn more about services, see:
1677/// https://fuchsia.dev/fuchsia-src/glossary#service
1678#[derive(Clone, Debug, Default, PartialEq)]
1679pub struct Service {
1680    /// (Required) The name of this service.
1681    pub name: Option<String>,
1682    /// (Optional) The path to the service in the component's outgoing
1683    /// directory.
1684    ///
1685    /// Not set for built-in capabilities.
1686    pub source_path: Option<String>,
1687    #[doc(hidden)]
1688    pub __source_breaking: fidl::marker::SourceBreaking,
1689}
1690
1691impl fidl::Persistable for Service {}
1692
1693/// Declares a storage capability backed by a directory from which data, cache,
1694/// or meta storage can be offered.
1695#[derive(Clone, Debug, Default, PartialEq)]
1696pub struct Storage {
1697    /// (Required) The name of this storage
1698    pub name: Option<String>,
1699    /// (Required) The provider of the backing directory capability relative to
1700    /// the component itself. Must be `parent`, `self`, or `child`.
1701    pub source: Option<Ref>,
1702    /// (Required) The name of the directory capability from `source` that backs
1703    /// the storage.
1704    pub backing_dir: Option<String>,
1705    /// (Optional) The subdirectory of the source directory that will back the
1706    /// storage
1707    pub subdir: Option<String>,
1708    /// (Required) This enum determines how to key a component's isolated
1709    /// storage directory. Each option corresponds to a different key'ing
1710    /// strategy.
1711    pub storage_id: Option<StorageId>,
1712    #[doc(hidden)]
1713    pub __source_breaking: fidl::marker::SourceBreaking,
1714}
1715
1716impl fidl::Persistable for Storage {}
1717
1718#[derive(Clone, Debug, Default, PartialEq)]
1719pub struct UseConfiguration {
1720    /// (Required) The provider of the configuration relative to the component
1721    /// itself. Must be `parent`, `self`, `child`.
1722    pub source: Option<Ref>,
1723    /// (Required) Name identifying the configuration, by which it was presented to this
1724    /// component.
1725    pub source_name: Option<String>,
1726    /// (Required) The name that the component sees for this configuration.
1727    /// This must match a key in the 'config' schema for this component. The
1728    /// matching config field's type must match this configuration type.
1729    pub target_name: Option<String>,
1730    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1731    /// If set to `required`, the component is likely to malfunction if this
1732    /// capability is not provided. If set to `optional`, the component can
1733    /// handle the capability's absence.
1734    pub availability: Option<Availability>,
1735    /// (Required) The type of this config value. If `target_name` matches a
1736    /// key in the `config` schema, then this type must match that type.
1737    pub type_: Option<ConfigType>,
1738    /// (Optional): If this is set, this is the value that will be provided via routing
1739    /// if the capability is successfully routed from void.
1740    pub default: Option<ConfigValue>,
1741    /// (Optional) Path in a dictionary provided by `source` which contains `source_name`.
1742    /// If this field is absent, `source_name` identifies a capability directly routed
1743    /// by `source`. If set, `source_name` identifies a capability nested inside this
1744    /// dictionary.
1745    pub source_dictionary: Option<String>,
1746    #[doc(hidden)]
1747    pub __source_breaking: fidl::marker::SourceBreaking,
1748}
1749
1750impl fidl::Persistable for UseConfiguration {}
1751
1752/// Declares a directory used by a component, which was offered to it.
1753#[derive(Clone, Debug, Default, PartialEq)]
1754pub struct UseDirectory {
1755    /// (Required) The provider of the directory relative to the component
1756    /// itself. Must be `parent`, `framework`,  or `child`.
1757    pub source: Option<Ref>,
1758    /// (Required) Name identifying the directory, by which it was presented to
1759    /// this component.
1760    pub source_name: Option<String>,
1761    /// (Required) The path where the capability should be installed in the
1762    /// component's namespace.
1763    ///
1764    /// Must be an absolute path starting with /.
1765    pub target_path: Option<String>,
1766    /// (Required) The rights required by the component to use this directory.
1767    pub rights: Option<fidl_fuchsia_io__common::Operations>,
1768    /// (Optional) The subdirectory of this directory to use instead of the
1769    /// root.
1770    pub subdir: Option<String>,
1771    /// (Required) The dependency type this use represents.
1772    ///
1773    /// A component which offers a capability to a child from itself and uses a
1774    /// capability from the same child, must mark the dependency as `weak`.  A
1775    /// `weak` dependency implies that the capability may become unavailable at
1776    /// any point. Taking a strong dependency on a child's capability will
1777    /// cause this the child to shut down before its parent. When using a weak
1778    /// dependency, the parent shuts down before the child.
1779    pub dependency_type: Option<DependencyType>,
1780    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1781    /// If set to `required`, the component is likely to malfunction if this
1782    /// capability is not provided. If set to `optional`, the component can
1783    /// handle the capability's absence.
1784    pub availability: Option<Availability>,
1785    /// (Optional) Path in a dictionary provided by `source` which contains `source_name`.
1786    /// If this field is absent, `source_name` identifies a capability directly routed
1787    /// by `source`. If set, `source_name` identifies a capability nested inside this
1788    /// dictionary.
1789    pub source_dictionary: Option<String>,
1790    #[doc(hidden)]
1791    pub __source_breaking: fidl::marker::SourceBreaking,
1792}
1793
1794impl fidl::Persistable for UseDirectory {}
1795
1796/// Declares an EventStream used by a component.
1797#[derive(Clone, Debug, Default, PartialEq)]
1798pub struct UseEventStream {
1799    /// (Required) The names of the event streams.
1800    pub source_name: Option<String>,
1801    /// (Required) The provider of the event. Must be `parent`, `framework`, or `child`.
1802    pub source: Option<Ref>,
1803    /// (Optional) When an event is used from framework, the scope is required
1804    /// to specify the child (or array of children) which the event will be
1805    /// about. When the event is used from parent, the scope can be used to
1806    /// downscope the event to a certain child scope, otherwise the event will
1807    /// carry the scope coming from the parent.
1808    pub scope: Option<Vec<Ref>>,
1809    /// (Required) The path where the capability should be installed in the
1810    /// component's namespace. Must be an absolute path starting with /.
1811    pub target_path: Option<String>,
1812    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1813    /// If set to `required`, the component is likely to malfunction if this
1814    /// capability is not provided. If set to `optional`, the component can
1815    /// handle the capability's absence.
1816    pub availability: Option<Availability>,
1817    /// (Optional) Filter for the event stream. The structure of the filter
1818    /// depends on the event stream type. Only supported for the
1819    /// `CapabilityRequested` event type.
1820    pub filter: Option<fidl_fuchsia_data__common::Dictionary>,
1821    #[doc(hidden)]
1822    pub __source_breaking: fidl::marker::SourceBreaking,
1823}
1824
1825impl fidl::Persistable for UseEventStream {}
1826
1827/// Declares a protocol used by a component, which was offered to it.
1828///
1829/// A protocol is a service with a single instance, provided by a single FIDL
1830/// protocol.
1831#[derive(Clone, Debug, Default, PartialEq)]
1832pub struct UseProtocol {
1833    /// (Required) The provider of the protocol relative to the component
1834    /// itself. Must be `parent`, `framework`, `debug`, `capability` or `child`.
1835    pub source: Option<Ref>,
1836    /// (Required) Name identifying the protocol, by which it was presented to this
1837    /// component.
1838    pub source_name: Option<String>,
1839    /// (Required) The path where the capability should be installed in the component's
1840    /// namespace.
1841    ///
1842    /// Must be an absolute path starting with /.
1843    pub target_path: Option<String>,
1844    /// (Required) The dependency type this use represents.
1845    ///
1846    /// A component which offers a capability to a child from itself and uses a
1847    /// capability from the same child, must mark the dependency as `weak`.  A
1848    /// `weak` dependency implies that the capability may become unavailable at
1849    /// any point. Taking a strong dependency on a child's capability will
1850    /// cause this the child to shut down before its parent. When using a weak
1851    /// dependency, the parent shuts down before the child.
1852    pub dependency_type: Option<DependencyType>,
1853    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1854    /// If set to `required`, the component is likely to malfunction if this
1855    /// capability is not provided. If set to `optional`, the component can
1856    /// handle the capability's absence.
1857    pub availability: Option<Availability>,
1858    /// (Optional) Path in a dictionary provided by `source` which contains `source_name`.
1859    /// If this field is absent, `source_name` identifies a capability directly routed
1860    /// by `source`. If set, `source_name` identifies a capability nested inside this
1861    /// dictionary.
1862    pub source_dictionary: Option<String>,
1863    #[doc(hidden)]
1864    pub __source_breaking: fidl::marker::SourceBreaking,
1865}
1866
1867impl fidl::Persistable for UseProtocol {}
1868
1869/// Declares runner used by a component.
1870#[derive(Clone, Debug, Default, PartialEq)]
1871pub struct UseRunner {
1872    /// (Required) The provider of the runner relative to the component.
1873    /// Must be `parent`, `child`, `framework`, or `environment`.
1874    pub source: Option<Ref>,
1875    /// (Required) Name identifying the runner, by which it was presented to this
1876    /// component.
1877    pub source_name: Option<String>,
1878    /// (Optional) Path in a dictionary provided by `source` which contains `source_name`.
1879    /// If this field is absent, `source_name` identifies a capability directly routed
1880    /// by `source`. If set, `source_name` identifies a capability nested inside this
1881    /// dictionary.
1882    pub source_dictionary: Option<String>,
1883    #[doc(hidden)]
1884    pub __source_breaking: fidl::marker::SourceBreaking,
1885}
1886
1887impl fidl::Persistable for UseRunner {}
1888
1889/// Declares a service used by a component, which was offered to it.
1890///
1891/// To learn more about services, see:
1892/// https://fuchsia.dev/fuchsia-src/glossary#service
1893#[derive(Clone, Debug, Default, PartialEq)]
1894pub struct UseService {
1895    /// (Required) The provider of the protocol relative to the component
1896    /// itself. Must be `parent`, `framework`, `self`, or `child`.
1897    pub source: Option<Ref>,
1898    /// (Required) Name identifying the service, by which it was presented to
1899    /// this component.
1900    pub source_name: Option<String>,
1901    /// (Required) The path where the capability should be installed in the
1902    /// component's namespace.
1903    ///
1904    /// Must be an absolute path starting with /.
1905    pub target_path: Option<String>,
1906    /// (Required) The dependency type this use represents.
1907    ///
1908    /// A component which offers a capability to a child from itself and uses a
1909    /// capability from the same child, must mark the dependency as `weak`.  A
1910    /// `weak` dependency implies that the capability may become unavailable at
1911    /// any point. Taking a strong dependency on a child's capability will
1912    /// cause this the child to shut down before its parent. When using a weak
1913    /// dependency, the parent shuts down before the child.
1914    pub dependency_type: Option<DependencyType>,
1915    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1916    /// If set to `required`, the component is likely to malfunction if this
1917    /// capability is not provided. If set to `optional`, the component can
1918    /// handle the capability's absence.
1919    pub availability: Option<Availability>,
1920    /// (Optional) Path in a dictionary provided by `source` which contains `source_name`.
1921    /// If this field is absent, `source_name` identifies a capability directly routed
1922    /// by `source`. If set, `source_name` identifies a capability nested inside this
1923    /// dictionary.
1924    pub source_dictionary: Option<String>,
1925    #[doc(hidden)]
1926    pub __source_breaking: fidl::marker::SourceBreaking,
1927}
1928
1929impl fidl::Persistable for UseService {}
1930
1931/// Declares storage used by a component, which was offered to it.
1932#[derive(Clone, Debug, Default, PartialEq)]
1933pub struct UseStorage {
1934    /// (Required) Name identifying the storage, by which it was presented to
1935    /// this component.
1936    pub source_name: Option<String>,
1937    /// (Required) The path where the capability should be installed in the
1938    /// component's namespace.
1939    ///
1940    /// Must be an absolute path starting with /.
1941    pub target_path: Option<String>,
1942    /// (Optional, defaults to `REQUIRED`) The availability of this capability.
1943    /// If set to `required`, the component is likely to malfunction if this
1944    /// capability is not provided. If set to `optional`, the component can
1945    /// handle the capability's absence.
1946    pub availability: Option<Availability>,
1947    #[doc(hidden)]
1948    pub __source_breaking: fidl::marker::SourceBreaking,
1949}
1950
1951impl fidl::Persistable for UseStorage {}
1952
1953/// Declares a capability defined by this component.
1954#[derive(Clone, Debug)]
1955pub enum Capability {
1956    Service(Service),
1957    Protocol(Protocol),
1958    Directory(Directory),
1959    Storage(Storage),
1960    Runner(Runner),
1961    Resolver(Resolver),
1962    EventStream(EventStream),
1963    Dictionary(Dictionary),
1964    Config(Configuration),
1965    #[doc(hidden)]
1966    __SourceBreaking {
1967        unknown_ordinal: u64,
1968    },
1969}
1970
1971/// Pattern that matches an unknown `Capability` member.
1972#[macro_export]
1973macro_rules! CapabilityUnknown {
1974    () => {
1975        _
1976    };
1977}
1978
1979// Custom PartialEq so that unknown variants are not equal to themselves.
1980impl PartialEq for Capability {
1981    fn eq(&self, other: &Self) -> bool {
1982        match (self, other) {
1983            (Self::Service(x), Self::Service(y)) => *x == *y,
1984            (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
1985            (Self::Directory(x), Self::Directory(y)) => *x == *y,
1986            (Self::Storage(x), Self::Storage(y)) => *x == *y,
1987            (Self::Runner(x), Self::Runner(y)) => *x == *y,
1988            (Self::Resolver(x), Self::Resolver(y)) => *x == *y,
1989            (Self::EventStream(x), Self::EventStream(y)) => *x == *y,
1990            (Self::Dictionary(x), Self::Dictionary(y)) => *x == *y,
1991            (Self::Config(x), Self::Config(y)) => *x == *y,
1992            _ => false,
1993        }
1994    }
1995}
1996
1997impl Capability {
1998    #[inline]
1999    pub fn ordinal(&self) -> u64 {
2000        match *self {
2001            Self::Service(_) => 1,
2002            Self::Protocol(_) => 2,
2003            Self::Directory(_) => 3,
2004            Self::Storage(_) => 4,
2005            Self::Runner(_) => 5,
2006            Self::Resolver(_) => 6,
2007            Self::EventStream(_) => 8,
2008            Self::Dictionary(_) => 9,
2009            Self::Config(_) => 10,
2010            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2011        }
2012    }
2013
2014    #[inline]
2015    pub fn unknown_variant_for_testing() -> Self {
2016        Self::__SourceBreaking { unknown_ordinal: 0 }
2017    }
2018
2019    #[inline]
2020    pub fn is_unknown(&self) -> bool {
2021        match self {
2022            Self::__SourceBreaking { .. } => true,
2023            _ => false,
2024        }
2025    }
2026}
2027
2028impl fidl::Persistable for Capability {}
2029
2030/// The checksum produced for a configuration interface.
2031/// Two configuration interfaces are the same if their checksums are the same.
2032#[derive(Clone, Debug)]
2033pub enum ConfigChecksum {
2034    /// A SHA-256 hash produced over a component's config interface.
2035    Sha256([u8; 32]),
2036    #[doc(hidden)]
2037    __SourceBreaking { unknown_ordinal: u64 },
2038}
2039
2040/// Pattern that matches an unknown `ConfigChecksum` member.
2041#[macro_export]
2042macro_rules! ConfigChecksumUnknown {
2043    () => {
2044        _
2045    };
2046}
2047
2048// Custom PartialEq so that unknown variants are not equal to themselves.
2049impl PartialEq for ConfigChecksum {
2050    fn eq(&self, other: &Self) -> bool {
2051        match (self, other) {
2052            (Self::Sha256(x), Self::Sha256(y)) => *x == *y,
2053            _ => false,
2054        }
2055    }
2056}
2057
2058impl ConfigChecksum {
2059    #[inline]
2060    pub fn ordinal(&self) -> u64 {
2061        match *self {
2062            Self::Sha256(_) => 1,
2063            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2064        }
2065    }
2066
2067    #[inline]
2068    pub fn unknown_variant_for_testing() -> Self {
2069        Self::__SourceBreaking { unknown_ordinal: 0 }
2070    }
2071
2072    #[inline]
2073    pub fn is_unknown(&self) -> bool {
2074        match self {
2075            Self::__SourceBreaking { .. } => true,
2076            _ => false,
2077        }
2078    }
2079}
2080
2081impl fidl::Persistable for ConfigChecksum {}
2082
2083/// A single configuration value.
2084#[derive(Clone, Debug)]
2085pub enum ConfigSingleValue {
2086    Bool(bool),
2087    Uint8(u8),
2088    Uint16(u16),
2089    Uint32(u32),
2090    Uint64(u64),
2091    Int8(i8),
2092    Int16(i16),
2093    Int32(i32),
2094    Int64(i64),
2095    String(String),
2096    #[doc(hidden)]
2097    __SourceBreaking {
2098        unknown_ordinal: u64,
2099    },
2100}
2101
2102/// Pattern that matches an unknown `ConfigSingleValue` member.
2103#[macro_export]
2104macro_rules! ConfigSingleValueUnknown {
2105    () => {
2106        _
2107    };
2108}
2109
2110// Custom PartialEq so that unknown variants are not equal to themselves.
2111impl PartialEq for ConfigSingleValue {
2112    fn eq(&self, other: &Self) -> bool {
2113        match (self, other) {
2114            (Self::Bool(x), Self::Bool(y)) => *x == *y,
2115            (Self::Uint8(x), Self::Uint8(y)) => *x == *y,
2116            (Self::Uint16(x), Self::Uint16(y)) => *x == *y,
2117            (Self::Uint32(x), Self::Uint32(y)) => *x == *y,
2118            (Self::Uint64(x), Self::Uint64(y)) => *x == *y,
2119            (Self::Int8(x), Self::Int8(y)) => *x == *y,
2120            (Self::Int16(x), Self::Int16(y)) => *x == *y,
2121            (Self::Int32(x), Self::Int32(y)) => *x == *y,
2122            (Self::Int64(x), Self::Int64(y)) => *x == *y,
2123            (Self::String(x), Self::String(y)) => *x == *y,
2124            _ => false,
2125        }
2126    }
2127}
2128
2129impl ConfigSingleValue {
2130    #[inline]
2131    pub fn ordinal(&self) -> u64 {
2132        match *self {
2133            Self::Bool(_) => 1,
2134            Self::Uint8(_) => 2,
2135            Self::Uint16(_) => 3,
2136            Self::Uint32(_) => 4,
2137            Self::Uint64(_) => 5,
2138            Self::Int8(_) => 6,
2139            Self::Int16(_) => 7,
2140            Self::Int32(_) => 8,
2141            Self::Int64(_) => 9,
2142            Self::String(_) => 10,
2143            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2144        }
2145    }
2146
2147    #[inline]
2148    pub fn unknown_variant_for_testing() -> Self {
2149        Self::__SourceBreaking { unknown_ordinal: 0 }
2150    }
2151
2152    #[inline]
2153    pub fn is_unknown(&self) -> bool {
2154        match self {
2155            Self::__SourceBreaking { .. } => true,
2156            _ => false,
2157        }
2158    }
2159}
2160
2161impl fidl::Persistable for ConfigSingleValue {}
2162
2163/// A configuration value which can be provided to a component.
2164///
2165/// Used both for storing configuration at-rest and in runtime configuration APIs.
2166#[derive(Clone, Debug)]
2167pub enum ConfigValue {
2168    Single(ConfigSingleValue),
2169    Vector(ConfigVectorValue),
2170    #[doc(hidden)]
2171    __SourceBreaking {
2172        unknown_ordinal: u64,
2173    },
2174}
2175
2176/// Pattern that matches an unknown `ConfigValue` member.
2177#[macro_export]
2178macro_rules! ConfigValueUnknown {
2179    () => {
2180        _
2181    };
2182}
2183
2184// Custom PartialEq so that unknown variants are not equal to themselves.
2185impl PartialEq for ConfigValue {
2186    fn eq(&self, other: &Self) -> bool {
2187        match (self, other) {
2188            (Self::Single(x), Self::Single(y)) => *x == *y,
2189            (Self::Vector(x), Self::Vector(y)) => *x == *y,
2190            _ => false,
2191        }
2192    }
2193}
2194
2195impl ConfigValue {
2196    #[inline]
2197    pub fn ordinal(&self) -> u64 {
2198        match *self {
2199            Self::Single(_) => 1,
2200            Self::Vector(_) => 2,
2201            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2202        }
2203    }
2204
2205    #[inline]
2206    pub fn unknown_variant_for_testing() -> Self {
2207        Self::__SourceBreaking { unknown_ordinal: 0 }
2208    }
2209
2210    #[inline]
2211    pub fn is_unknown(&self) -> bool {
2212        match self {
2213            Self::__SourceBreaking { .. } => true,
2214            _ => false,
2215        }
2216    }
2217}
2218
2219impl fidl::Persistable for ConfigValue {}
2220
2221/// Strategies available for resolving configuration values.
2222#[derive(Clone, Debug)]
2223pub enum ConfigValueSource {
2224    /// (Required) The path within the component's package at which to find config value files.
2225    PackagePath(String),
2226    /// If this is set, then all of the config values are found through CML files.
2227    Capabilities(ConfigSourceCapabilities),
2228    #[doc(hidden)]
2229    __SourceBreaking { unknown_ordinal: u64 },
2230}
2231
2232/// Pattern that matches an unknown `ConfigValueSource` member.
2233#[macro_export]
2234macro_rules! ConfigValueSourceUnknown {
2235    () => {
2236        _
2237    };
2238}
2239
2240// Custom PartialEq so that unknown variants are not equal to themselves.
2241impl PartialEq for ConfigValueSource {
2242    fn eq(&self, other: &Self) -> bool {
2243        match (self, other) {
2244            (Self::PackagePath(x), Self::PackagePath(y)) => *x == *y,
2245            (Self::Capabilities(x), Self::Capabilities(y)) => *x == *y,
2246            _ => false,
2247        }
2248    }
2249}
2250
2251impl ConfigValueSource {
2252    #[inline]
2253    pub fn ordinal(&self) -> u64 {
2254        match *self {
2255            Self::PackagePath(_) => 1,
2256            Self::Capabilities(_) => 2,
2257            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2258        }
2259    }
2260
2261    #[inline]
2262    pub fn unknown_variant_for_testing() -> Self {
2263        Self::__SourceBreaking { unknown_ordinal: 0 }
2264    }
2265
2266    #[inline]
2267    pub fn is_unknown(&self) -> bool {
2268        match self {
2269            Self::__SourceBreaking { .. } => true,
2270            _ => false,
2271        }
2272    }
2273}
2274
2275impl fidl::Persistable for ConfigValueSource {}
2276
2277/// A vector configuration value.
2278#[derive(Clone, Debug)]
2279pub enum ConfigVectorValue {
2280    BoolVector(Vec<bool>),
2281    Uint8Vector(Vec<u8>),
2282    Uint16Vector(Vec<u16>),
2283    Uint32Vector(Vec<u32>),
2284    Uint64Vector(Vec<u64>),
2285    Int8Vector(Vec<i8>),
2286    Int16Vector(Vec<i16>),
2287    Int32Vector(Vec<i32>),
2288    Int64Vector(Vec<i64>),
2289    StringVector(Vec<String>),
2290    #[doc(hidden)]
2291    __SourceBreaking {
2292        unknown_ordinal: u64,
2293    },
2294}
2295
2296/// Pattern that matches an unknown `ConfigVectorValue` member.
2297#[macro_export]
2298macro_rules! ConfigVectorValueUnknown {
2299    () => {
2300        _
2301    };
2302}
2303
2304// Custom PartialEq so that unknown variants are not equal to themselves.
2305impl PartialEq for ConfigVectorValue {
2306    fn eq(&self, other: &Self) -> bool {
2307        match (self, other) {
2308            (Self::BoolVector(x), Self::BoolVector(y)) => *x == *y,
2309            (Self::Uint8Vector(x), Self::Uint8Vector(y)) => *x == *y,
2310            (Self::Uint16Vector(x), Self::Uint16Vector(y)) => *x == *y,
2311            (Self::Uint32Vector(x), Self::Uint32Vector(y)) => *x == *y,
2312            (Self::Uint64Vector(x), Self::Uint64Vector(y)) => *x == *y,
2313            (Self::Int8Vector(x), Self::Int8Vector(y)) => *x == *y,
2314            (Self::Int16Vector(x), Self::Int16Vector(y)) => *x == *y,
2315            (Self::Int32Vector(x), Self::Int32Vector(y)) => *x == *y,
2316            (Self::Int64Vector(x), Self::Int64Vector(y)) => *x == *y,
2317            (Self::StringVector(x), Self::StringVector(y)) => *x == *y,
2318            _ => false,
2319        }
2320    }
2321}
2322
2323impl ConfigVectorValue {
2324    #[inline]
2325    pub fn ordinal(&self) -> u64 {
2326        match *self {
2327            Self::BoolVector(_) => 1,
2328            Self::Uint8Vector(_) => 2,
2329            Self::Uint16Vector(_) => 3,
2330            Self::Uint32Vector(_) => 4,
2331            Self::Uint64Vector(_) => 5,
2332            Self::Int8Vector(_) => 6,
2333            Self::Int16Vector(_) => 7,
2334            Self::Int32Vector(_) => 8,
2335            Self::Int64Vector(_) => 9,
2336            Self::StringVector(_) => 10,
2337            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2338        }
2339    }
2340
2341    #[inline]
2342    pub fn unknown_variant_for_testing() -> Self {
2343        Self::__SourceBreaking { unknown_ordinal: 0 }
2344    }
2345
2346    #[inline]
2347    pub fn is_unknown(&self) -> bool {
2348        match self {
2349            Self::__SourceBreaking { .. } => true,
2350            _ => false,
2351        }
2352    }
2353}
2354
2355impl fidl::Persistable for ConfigVectorValue {}
2356
2357/// Declares a capability registered in the debug section of an environment.
2358#[derive(Clone, Debug)]
2359pub enum DebugRegistration {
2360    Protocol(DebugProtocolRegistration),
2361    #[doc(hidden)]
2362    __SourceBreaking {
2363        unknown_ordinal: u64,
2364    },
2365}
2366
2367/// Pattern that matches an unknown `DebugRegistration` member.
2368#[macro_export]
2369macro_rules! DebugRegistrationUnknown {
2370    () => {
2371        _
2372    };
2373}
2374
2375// Custom PartialEq so that unknown variants are not equal to themselves.
2376impl PartialEq for DebugRegistration {
2377    fn eq(&self, other: &Self) -> bool {
2378        match (self, other) {
2379            (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
2380            _ => false,
2381        }
2382    }
2383}
2384
2385impl DebugRegistration {
2386    #[inline]
2387    pub fn ordinal(&self) -> u64 {
2388        match *self {
2389            Self::Protocol(_) => 1,
2390            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2391        }
2392    }
2393
2394    #[inline]
2395    pub fn unknown_variant_for_testing() -> Self {
2396        Self::__SourceBreaking { unknown_ordinal: 0 }
2397    }
2398
2399    #[inline]
2400    pub fn is_unknown(&self) -> bool {
2401        match self {
2402            Self::__SourceBreaking { .. } => true,
2403            _ => false,
2404        }
2405    }
2406}
2407
2408impl fidl::Persistable for DebugRegistration {}
2409
2410/// Declares a capability exposed to either a component's containing realm or to
2411/// the framework. For example, a legacy service exposed by the component at
2412/// runtime.
2413#[derive(Clone, Debug)]
2414pub enum Expose {
2415    Service(ExposeService),
2416    Protocol(ExposeProtocol),
2417    Directory(ExposeDirectory),
2418    Runner(ExposeRunner),
2419    Resolver(ExposeResolver),
2420    Dictionary(ExposeDictionary),
2421    Config(ExposeConfiguration),
2422    #[doc(hidden)]
2423    __SourceBreaking {
2424        unknown_ordinal: u64,
2425    },
2426}
2427
2428/// Pattern that matches an unknown `Expose` member.
2429#[macro_export]
2430macro_rules! ExposeUnknown {
2431    () => {
2432        _
2433    };
2434}
2435
2436// Custom PartialEq so that unknown variants are not equal to themselves.
2437impl PartialEq for Expose {
2438    fn eq(&self, other: &Self) -> bool {
2439        match (self, other) {
2440            (Self::Service(x), Self::Service(y)) => *x == *y,
2441            (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
2442            (Self::Directory(x), Self::Directory(y)) => *x == *y,
2443            (Self::Runner(x), Self::Runner(y)) => *x == *y,
2444            (Self::Resolver(x), Self::Resolver(y)) => *x == *y,
2445            (Self::Dictionary(x), Self::Dictionary(y)) => *x == *y,
2446            (Self::Config(x), Self::Config(y)) => *x == *y,
2447            _ => false,
2448        }
2449    }
2450}
2451
2452impl Expose {
2453    #[inline]
2454    pub fn ordinal(&self) -> u64 {
2455        match *self {
2456            Self::Service(_) => 1,
2457            Self::Protocol(_) => 2,
2458            Self::Directory(_) => 3,
2459            Self::Runner(_) => 4,
2460            Self::Resolver(_) => 5,
2461            Self::Dictionary(_) => 7,
2462            Self::Config(_) => 8,
2463            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2464        }
2465    }
2466
2467    #[inline]
2468    pub fn unknown_variant_for_testing() -> Self {
2469        Self::__SourceBreaking { unknown_ordinal: 0 }
2470    }
2471
2472    #[inline]
2473    pub fn is_unknown(&self) -> bool {
2474        match self {
2475            Self::__SourceBreaking { .. } => true,
2476            _ => false,
2477        }
2478    }
2479}
2480
2481impl fidl::Persistable for Expose {}
2482
2483#[derive(Clone, Debug)]
2484pub enum LayoutConstraint {
2485    MaxSize(u32),
2486    #[doc(hidden)]
2487    __SourceBreaking {
2488        unknown_ordinal: u64,
2489    },
2490}
2491
2492/// Pattern that matches an unknown `LayoutConstraint` member.
2493#[macro_export]
2494macro_rules! LayoutConstraintUnknown {
2495    () => {
2496        _
2497    };
2498}
2499
2500// Custom PartialEq so that unknown variants are not equal to themselves.
2501impl PartialEq for LayoutConstraint {
2502    fn eq(&self, other: &Self) -> bool {
2503        match (self, other) {
2504            (Self::MaxSize(x), Self::MaxSize(y)) => *x == *y,
2505            _ => false,
2506        }
2507    }
2508}
2509
2510impl LayoutConstraint {
2511    #[inline]
2512    pub fn ordinal(&self) -> u64 {
2513        match *self {
2514            Self::MaxSize(_) => 1,
2515            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2516        }
2517    }
2518
2519    #[inline]
2520    pub fn unknown_variant_for_testing() -> Self {
2521        Self::__SourceBreaking { unknown_ordinal: 0 }
2522    }
2523
2524    #[inline]
2525    pub fn is_unknown(&self) -> bool {
2526        match self {
2527            Self::__SourceBreaking { .. } => true,
2528            _ => false,
2529        }
2530    }
2531}
2532
2533impl fidl::Persistable for LayoutConstraint {}
2534
2535#[derive(Clone, Debug)]
2536pub enum LayoutParameter {
2537    NestedType(ConfigType),
2538    #[doc(hidden)]
2539    __SourceBreaking {
2540        unknown_ordinal: u64,
2541    },
2542}
2543
2544/// Pattern that matches an unknown `LayoutParameter` member.
2545#[macro_export]
2546macro_rules! LayoutParameterUnknown {
2547    () => {
2548        _
2549    };
2550}
2551
2552// Custom PartialEq so that unknown variants are not equal to themselves.
2553impl PartialEq for LayoutParameter {
2554    fn eq(&self, other: &Self) -> bool {
2555        match (self, other) {
2556            (Self::NestedType(x), Self::NestedType(y)) => *x == *y,
2557            _ => false,
2558        }
2559    }
2560}
2561
2562impl LayoutParameter {
2563    #[inline]
2564    pub fn ordinal(&self) -> u64 {
2565        match *self {
2566            Self::NestedType(_) => 1,
2567            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2568        }
2569    }
2570
2571    #[inline]
2572    pub fn unknown_variant_for_testing() -> Self {
2573        Self::__SourceBreaking { unknown_ordinal: 0 }
2574    }
2575
2576    #[inline]
2577    pub fn is_unknown(&self) -> bool {
2578        match self {
2579            Self::__SourceBreaking { .. } => true,
2580            _ => false,
2581        }
2582    }
2583}
2584
2585impl fidl::Persistable for LayoutParameter {}
2586
2587/// Declares a capability offered by a component to one of its children, which
2588/// may have been offered by the component's containing realm, the component
2589/// itself, or one of its other children.
2590#[derive(Clone, Debug)]
2591pub enum Offer {
2592    Service(OfferService),
2593    Protocol(OfferProtocol),
2594    Directory(OfferDirectory),
2595    Storage(OfferStorage),
2596    Runner(OfferRunner),
2597    Resolver(OfferResolver),
2598    EventStream(OfferEventStream),
2599    Dictionary(OfferDictionary),
2600    Config(OfferConfiguration),
2601    #[doc(hidden)]
2602    __SourceBreaking {
2603        unknown_ordinal: u64,
2604    },
2605}
2606
2607/// Pattern that matches an unknown `Offer` member.
2608#[macro_export]
2609macro_rules! OfferUnknown {
2610    () => {
2611        _
2612    };
2613}
2614
2615// Custom PartialEq so that unknown variants are not equal to themselves.
2616impl PartialEq for Offer {
2617    fn eq(&self, other: &Self) -> bool {
2618        match (self, other) {
2619            (Self::Service(x), Self::Service(y)) => *x == *y,
2620            (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
2621            (Self::Directory(x), Self::Directory(y)) => *x == *y,
2622            (Self::Storage(x), Self::Storage(y)) => *x == *y,
2623            (Self::Runner(x), Self::Runner(y)) => *x == *y,
2624            (Self::Resolver(x), Self::Resolver(y)) => *x == *y,
2625            (Self::EventStream(x), Self::EventStream(y)) => *x == *y,
2626            (Self::Dictionary(x), Self::Dictionary(y)) => *x == *y,
2627            (Self::Config(x), Self::Config(y)) => *x == *y,
2628            _ => false,
2629        }
2630    }
2631}
2632
2633impl Offer {
2634    #[inline]
2635    pub fn ordinal(&self) -> u64 {
2636        match *self {
2637            Self::Service(_) => 1,
2638            Self::Protocol(_) => 2,
2639            Self::Directory(_) => 3,
2640            Self::Storage(_) => 4,
2641            Self::Runner(_) => 5,
2642            Self::Resolver(_) => 6,
2643            Self::EventStream(_) => 8,
2644            Self::Dictionary(_) => 9,
2645            Self::Config(_) => 10,
2646            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2647        }
2648    }
2649
2650    #[inline]
2651    pub fn unknown_variant_for_testing() -> Self {
2652        Self::__SourceBreaking { unknown_ordinal: 0 }
2653    }
2654
2655    #[inline]
2656    pub fn is_unknown(&self) -> bool {
2657        match self {
2658            Self::__SourceBreaking { .. } => true,
2659            _ => false,
2660        }
2661    }
2662}
2663
2664impl fidl::Persistable for Offer {}
2665
2666/// A reference to a capability source or destination relative to this
2667/// component.
2668#[derive(Clone, Debug)]
2669pub enum Ref {
2670    Parent(ParentRef),
2671    Self_(SelfRef),
2672    Child(ChildRef),
2673    Collection(CollectionRef),
2674    Framework(FrameworkRef),
2675    Capability(CapabilityRef),
2676    Debug(DebugRef),
2677    VoidType(VoidRef),
2678    Environment(EnvironmentRef),
2679    #[doc(hidden)]
2680    __SourceBreaking {
2681        unknown_ordinal: u64,
2682    },
2683}
2684
2685/// Pattern that matches an unknown `Ref` member.
2686#[macro_export]
2687macro_rules! RefUnknown {
2688    () => {
2689        _
2690    };
2691}
2692
2693// Custom PartialEq so that unknown variants are not equal to themselves.
2694impl PartialEq for Ref {
2695    fn eq(&self, other: &Self) -> bool {
2696        match (self, other) {
2697            (Self::Parent(x), Self::Parent(y)) => *x == *y,
2698            (Self::Self_(x), Self::Self_(y)) => *x == *y,
2699            (Self::Child(x), Self::Child(y)) => *x == *y,
2700            (Self::Collection(x), Self::Collection(y)) => *x == *y,
2701            (Self::Framework(x), Self::Framework(y)) => *x == *y,
2702            (Self::Capability(x), Self::Capability(y)) => *x == *y,
2703            (Self::Debug(x), Self::Debug(y)) => *x == *y,
2704            (Self::VoidType(x), Self::VoidType(y)) => *x == *y,
2705            (Self::Environment(x), Self::Environment(y)) => *x == *y,
2706            _ => false,
2707        }
2708    }
2709}
2710
2711impl Ref {
2712    #[inline]
2713    pub fn ordinal(&self) -> u64 {
2714        match *self {
2715            Self::Parent(_) => 1,
2716            Self::Self_(_) => 2,
2717            Self::Child(_) => 3,
2718            Self::Collection(_) => 4,
2719            Self::Framework(_) => 5,
2720            Self::Capability(_) => 6,
2721            Self::Debug(_) => 7,
2722            Self::VoidType(_) => 8,
2723            Self::Environment(_) => 9,
2724            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2725        }
2726    }
2727
2728    #[inline]
2729    pub fn unknown_variant_for_testing() -> Self {
2730        Self::__SourceBreaking { unknown_ordinal: 0 }
2731    }
2732
2733    #[inline]
2734    pub fn is_unknown(&self) -> bool {
2735        match self {
2736            Self::__SourceBreaking { .. } => true,
2737            _ => false,
2738        }
2739    }
2740}
2741
2742impl fidl::Persistable for Ref {}
2743
2744/// Declares a capability used by a component, which was offered to it.
2745#[derive(Clone, Debug)]
2746pub enum Use {
2747    Service(UseService),
2748    Protocol(UseProtocol),
2749    Directory(UseDirectory),
2750    Storage(UseStorage),
2751    EventStream(UseEventStream),
2752    Runner(UseRunner),
2753    Config(UseConfiguration),
2754    #[doc(hidden)]
2755    __SourceBreaking {
2756        unknown_ordinal: u64,
2757    },
2758}
2759
2760/// Pattern that matches an unknown `Use` member.
2761#[macro_export]
2762macro_rules! UseUnknown {
2763    () => {
2764        _
2765    };
2766}
2767
2768// Custom PartialEq so that unknown variants are not equal to themselves.
2769impl PartialEq for Use {
2770    fn eq(&self, other: &Self) -> bool {
2771        match (self, other) {
2772            (Self::Service(x), Self::Service(y)) => *x == *y,
2773            (Self::Protocol(x), Self::Protocol(y)) => *x == *y,
2774            (Self::Directory(x), Self::Directory(y)) => *x == *y,
2775            (Self::Storage(x), Self::Storage(y)) => *x == *y,
2776            (Self::EventStream(x), Self::EventStream(y)) => *x == *y,
2777            (Self::Runner(x), Self::Runner(y)) => *x == *y,
2778            (Self::Config(x), Self::Config(y)) => *x == *y,
2779            _ => false,
2780        }
2781    }
2782}
2783
2784impl Use {
2785    #[inline]
2786    pub fn ordinal(&self) -> u64 {
2787        match *self {
2788            Self::Service(_) => 1,
2789            Self::Protocol(_) => 2,
2790            Self::Directory(_) => 3,
2791            Self::Storage(_) => 4,
2792            Self::EventStream(_) => 7,
2793            Self::Runner(_) => 8,
2794            Self::Config(_) => 9,
2795            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
2796        }
2797    }
2798
2799    #[inline]
2800    pub fn unknown_variant_for_testing() -> Self {
2801        Self::__SourceBreaking { unknown_ordinal: 0 }
2802    }
2803
2804    #[inline]
2805    pub fn is_unknown(&self) -> bool {
2806        match self {
2807            Self::__SourceBreaking { .. } => true,
2808            _ => false,
2809        }
2810    }
2811}
2812
2813impl fidl::Persistable for Use {}
2814
2815mod internal {
2816    use super::*;
2817    unsafe impl fidl::encoding::TypeMarker for ConfigMutability {
2818        type Owned = Self;
2819
2820        #[inline(always)]
2821        fn inline_align(_context: fidl::encoding::Context) -> usize {
2822            4
2823        }
2824
2825        #[inline(always)]
2826        fn inline_size(_context: fidl::encoding::Context) -> usize {
2827            4
2828        }
2829    }
2830
2831    impl fidl::encoding::ValueTypeMarker for ConfigMutability {
2832        type Borrowed<'a> = Self;
2833        #[inline(always)]
2834        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2835            *value
2836        }
2837    }
2838
2839    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2840        for ConfigMutability
2841    {
2842        #[inline]
2843        unsafe fn encode(
2844            self,
2845            encoder: &mut fidl::encoding::Encoder<'_, D>,
2846            offset: usize,
2847            _depth: fidl::encoding::Depth,
2848        ) -> fidl::Result<()> {
2849            encoder.debug_check_bounds::<Self>(offset);
2850            encoder.write_num(self.bits(), offset);
2851            Ok(())
2852        }
2853    }
2854
2855    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigMutability {
2856        #[inline(always)]
2857        fn new_empty() -> Self {
2858            Self::empty()
2859        }
2860
2861        #[inline]
2862        unsafe fn decode(
2863            &mut self,
2864            decoder: &mut fidl::encoding::Decoder<'_, D>,
2865            offset: usize,
2866            _depth: fidl::encoding::Depth,
2867        ) -> fidl::Result<()> {
2868            decoder.debug_check_bounds::<Self>(offset);
2869            let prim = decoder.read_num::<u32>(offset);
2870            *self = Self::from_bits_allow_unknown(prim);
2871            Ok(())
2872        }
2873    }
2874    unsafe impl fidl::encoding::TypeMarker for AllowedOffers {
2875        type Owned = Self;
2876
2877        #[inline(always)]
2878        fn inline_align(_context: fidl::encoding::Context) -> usize {
2879            std::mem::align_of::<u32>()
2880        }
2881
2882        #[inline(always)]
2883        fn inline_size(_context: fidl::encoding::Context) -> usize {
2884            std::mem::size_of::<u32>()
2885        }
2886
2887        #[inline(always)]
2888        fn encode_is_copy() -> bool {
2889            true
2890        }
2891
2892        #[inline(always)]
2893        fn decode_is_copy() -> bool {
2894            false
2895        }
2896    }
2897
2898    impl fidl::encoding::ValueTypeMarker for AllowedOffers {
2899        type Borrowed<'a> = Self;
2900        #[inline(always)]
2901        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2902            *value
2903        }
2904    }
2905
2906    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AllowedOffers {
2907        #[inline]
2908        unsafe fn encode(
2909            self,
2910            encoder: &mut fidl::encoding::Encoder<'_, D>,
2911            offset: usize,
2912            _depth: fidl::encoding::Depth,
2913        ) -> fidl::Result<()> {
2914            encoder.debug_check_bounds::<Self>(offset);
2915            encoder.write_num(self.into_primitive(), offset);
2916            Ok(())
2917        }
2918    }
2919
2920    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowedOffers {
2921        #[inline(always)]
2922        fn new_empty() -> Self {
2923            Self::StaticOnly
2924        }
2925
2926        #[inline]
2927        unsafe fn decode(
2928            &mut self,
2929            decoder: &mut fidl::encoding::Decoder<'_, D>,
2930            offset: usize,
2931            _depth: fidl::encoding::Depth,
2932        ) -> fidl::Result<()> {
2933            decoder.debug_check_bounds::<Self>(offset);
2934            let prim = decoder.read_num::<u32>(offset);
2935
2936            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2937            Ok(())
2938        }
2939    }
2940    unsafe impl fidl::encoding::TypeMarker for Availability {
2941        type Owned = Self;
2942
2943        #[inline(always)]
2944        fn inline_align(_context: fidl::encoding::Context) -> usize {
2945            std::mem::align_of::<u32>()
2946        }
2947
2948        #[inline(always)]
2949        fn inline_size(_context: fidl::encoding::Context) -> usize {
2950            std::mem::size_of::<u32>()
2951        }
2952
2953        #[inline(always)]
2954        fn encode_is_copy() -> bool {
2955            true
2956        }
2957
2958        #[inline(always)]
2959        fn decode_is_copy() -> bool {
2960            false
2961        }
2962    }
2963
2964    impl fidl::encoding::ValueTypeMarker for Availability {
2965        type Borrowed<'a> = Self;
2966        #[inline(always)]
2967        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2968            *value
2969        }
2970    }
2971
2972    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Availability {
2973        #[inline]
2974        unsafe fn encode(
2975            self,
2976            encoder: &mut fidl::encoding::Encoder<'_, D>,
2977            offset: usize,
2978            _depth: fidl::encoding::Depth,
2979        ) -> fidl::Result<()> {
2980            encoder.debug_check_bounds::<Self>(offset);
2981            encoder.write_num(self.into_primitive(), offset);
2982            Ok(())
2983        }
2984    }
2985
2986    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Availability {
2987        #[inline(always)]
2988        fn new_empty() -> Self {
2989            Self::Required
2990        }
2991
2992        #[inline]
2993        unsafe fn decode(
2994            &mut self,
2995            decoder: &mut fidl::encoding::Decoder<'_, D>,
2996            offset: usize,
2997            _depth: fidl::encoding::Depth,
2998        ) -> fidl::Result<()> {
2999            decoder.debug_check_bounds::<Self>(offset);
3000            let prim = decoder.read_num::<u32>(offset);
3001
3002            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3003            Ok(())
3004        }
3005    }
3006    unsafe impl fidl::encoding::TypeMarker for ConfigTypeLayout {
3007        type Owned = Self;
3008
3009        #[inline(always)]
3010        fn inline_align(_context: fidl::encoding::Context) -> usize {
3011            std::mem::align_of::<u32>()
3012        }
3013
3014        #[inline(always)]
3015        fn inline_size(_context: fidl::encoding::Context) -> usize {
3016            std::mem::size_of::<u32>()
3017        }
3018
3019        #[inline(always)]
3020        fn encode_is_copy() -> bool {
3021            false
3022        }
3023
3024        #[inline(always)]
3025        fn decode_is_copy() -> bool {
3026            false
3027        }
3028    }
3029
3030    impl fidl::encoding::ValueTypeMarker for ConfigTypeLayout {
3031        type Borrowed<'a> = Self;
3032        #[inline(always)]
3033        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3034            *value
3035        }
3036    }
3037
3038    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3039        for ConfigTypeLayout
3040    {
3041        #[inline]
3042        unsafe fn encode(
3043            self,
3044            encoder: &mut fidl::encoding::Encoder<'_, D>,
3045            offset: usize,
3046            _depth: fidl::encoding::Depth,
3047        ) -> fidl::Result<()> {
3048            encoder.debug_check_bounds::<Self>(offset);
3049            encoder.write_num(self.into_primitive(), offset);
3050            Ok(())
3051        }
3052    }
3053
3054    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigTypeLayout {
3055        #[inline(always)]
3056        fn new_empty() -> Self {
3057            Self::unknown()
3058        }
3059
3060        #[inline]
3061        unsafe fn decode(
3062            &mut self,
3063            decoder: &mut fidl::encoding::Decoder<'_, D>,
3064            offset: usize,
3065            _depth: fidl::encoding::Depth,
3066        ) -> fidl::Result<()> {
3067            decoder.debug_check_bounds::<Self>(offset);
3068            let prim = decoder.read_num::<u32>(offset);
3069
3070            *self = Self::from_primitive_allow_unknown(prim);
3071            Ok(())
3072        }
3073    }
3074    unsafe impl fidl::encoding::TypeMarker for DeliveryType {
3075        type Owned = Self;
3076
3077        #[inline(always)]
3078        fn inline_align(_context: fidl::encoding::Context) -> usize {
3079            std::mem::align_of::<u32>()
3080        }
3081
3082        #[inline(always)]
3083        fn inline_size(_context: fidl::encoding::Context) -> usize {
3084            std::mem::size_of::<u32>()
3085        }
3086
3087        #[inline(always)]
3088        fn encode_is_copy() -> bool {
3089            false
3090        }
3091
3092        #[inline(always)]
3093        fn decode_is_copy() -> bool {
3094            false
3095        }
3096    }
3097
3098    impl fidl::encoding::ValueTypeMarker for DeliveryType {
3099        type Borrowed<'a> = Self;
3100        #[inline(always)]
3101        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3102            *value
3103        }
3104    }
3105
3106    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DeliveryType {
3107        #[inline]
3108        unsafe fn encode(
3109            self,
3110            encoder: &mut fidl::encoding::Encoder<'_, D>,
3111            offset: usize,
3112            _depth: fidl::encoding::Depth,
3113        ) -> fidl::Result<()> {
3114            encoder.debug_check_bounds::<Self>(offset);
3115            encoder.write_num(self.into_primitive(), offset);
3116            Ok(())
3117        }
3118    }
3119
3120    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeliveryType {
3121        #[inline(always)]
3122        fn new_empty() -> Self {
3123            Self::unknown()
3124        }
3125
3126        #[inline]
3127        unsafe fn decode(
3128            &mut self,
3129            decoder: &mut fidl::encoding::Decoder<'_, D>,
3130            offset: usize,
3131            _depth: fidl::encoding::Depth,
3132        ) -> fidl::Result<()> {
3133            decoder.debug_check_bounds::<Self>(offset);
3134            let prim = decoder.read_num::<u32>(offset);
3135
3136            *self = Self::from_primitive_allow_unknown(prim);
3137            Ok(())
3138        }
3139    }
3140    unsafe impl fidl::encoding::TypeMarker for DependencyType {
3141        type Owned = Self;
3142
3143        #[inline(always)]
3144        fn inline_align(_context: fidl::encoding::Context) -> usize {
3145            std::mem::align_of::<u32>()
3146        }
3147
3148        #[inline(always)]
3149        fn inline_size(_context: fidl::encoding::Context) -> usize {
3150            std::mem::size_of::<u32>()
3151        }
3152
3153        #[inline(always)]
3154        fn encode_is_copy() -> bool {
3155            true
3156        }
3157
3158        #[inline(always)]
3159        fn decode_is_copy() -> bool {
3160            false
3161        }
3162    }
3163
3164    impl fidl::encoding::ValueTypeMarker for DependencyType {
3165        type Borrowed<'a> = Self;
3166        #[inline(always)]
3167        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3168            *value
3169        }
3170    }
3171
3172    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DependencyType {
3173        #[inline]
3174        unsafe fn encode(
3175            self,
3176            encoder: &mut fidl::encoding::Encoder<'_, D>,
3177            offset: usize,
3178            _depth: fidl::encoding::Depth,
3179        ) -> fidl::Result<()> {
3180            encoder.debug_check_bounds::<Self>(offset);
3181            encoder.write_num(self.into_primitive(), offset);
3182            Ok(())
3183        }
3184    }
3185
3186    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DependencyType {
3187        #[inline(always)]
3188        fn new_empty() -> Self {
3189            Self::Strong
3190        }
3191
3192        #[inline]
3193        unsafe fn decode(
3194            &mut self,
3195            decoder: &mut fidl::encoding::Decoder<'_, D>,
3196            offset: usize,
3197            _depth: fidl::encoding::Depth,
3198        ) -> fidl::Result<()> {
3199            decoder.debug_check_bounds::<Self>(offset);
3200            let prim = decoder.read_num::<u32>(offset);
3201
3202            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3203            Ok(())
3204        }
3205    }
3206    unsafe impl fidl::encoding::TypeMarker for Durability {
3207        type Owned = Self;
3208
3209        #[inline(always)]
3210        fn inline_align(_context: fidl::encoding::Context) -> usize {
3211            std::mem::align_of::<u32>()
3212        }
3213
3214        #[inline(always)]
3215        fn inline_size(_context: fidl::encoding::Context) -> usize {
3216            std::mem::size_of::<u32>()
3217        }
3218
3219        #[inline(always)]
3220        fn encode_is_copy() -> bool {
3221            true
3222        }
3223
3224        #[inline(always)]
3225        fn decode_is_copy() -> bool {
3226            false
3227        }
3228    }
3229
3230    impl fidl::encoding::ValueTypeMarker for Durability {
3231        type Borrowed<'a> = Self;
3232        #[inline(always)]
3233        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3234            *value
3235        }
3236    }
3237
3238    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Durability {
3239        #[inline]
3240        unsafe fn encode(
3241            self,
3242            encoder: &mut fidl::encoding::Encoder<'_, D>,
3243            offset: usize,
3244            _depth: fidl::encoding::Depth,
3245        ) -> fidl::Result<()> {
3246            encoder.debug_check_bounds::<Self>(offset);
3247            encoder.write_num(self.into_primitive(), offset);
3248            Ok(())
3249        }
3250    }
3251
3252    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Durability {
3253        #[inline(always)]
3254        fn new_empty() -> Self {
3255            Self::Transient
3256        }
3257
3258        #[inline]
3259        unsafe fn decode(
3260            &mut self,
3261            decoder: &mut fidl::encoding::Decoder<'_, D>,
3262            offset: usize,
3263            _depth: fidl::encoding::Depth,
3264        ) -> fidl::Result<()> {
3265            decoder.debug_check_bounds::<Self>(offset);
3266            let prim = decoder.read_num::<u32>(offset);
3267
3268            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3269            Ok(())
3270        }
3271    }
3272    unsafe impl fidl::encoding::TypeMarker for EnvironmentExtends {
3273        type Owned = Self;
3274
3275        #[inline(always)]
3276        fn inline_align(_context: fidl::encoding::Context) -> usize {
3277            std::mem::align_of::<u32>()
3278        }
3279
3280        #[inline(always)]
3281        fn inline_size(_context: fidl::encoding::Context) -> usize {
3282            std::mem::size_of::<u32>()
3283        }
3284
3285        #[inline(always)]
3286        fn encode_is_copy() -> bool {
3287            true
3288        }
3289
3290        #[inline(always)]
3291        fn decode_is_copy() -> bool {
3292            false
3293        }
3294    }
3295
3296    impl fidl::encoding::ValueTypeMarker for EnvironmentExtends {
3297        type Borrowed<'a> = Self;
3298        #[inline(always)]
3299        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3300            *value
3301        }
3302    }
3303
3304    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3305        for EnvironmentExtends
3306    {
3307        #[inline]
3308        unsafe fn encode(
3309            self,
3310            encoder: &mut fidl::encoding::Encoder<'_, D>,
3311            offset: usize,
3312            _depth: fidl::encoding::Depth,
3313        ) -> fidl::Result<()> {
3314            encoder.debug_check_bounds::<Self>(offset);
3315            encoder.write_num(self.into_primitive(), offset);
3316            Ok(())
3317        }
3318    }
3319
3320    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnvironmentExtends {
3321        #[inline(always)]
3322        fn new_empty() -> Self {
3323            Self::None
3324        }
3325
3326        #[inline]
3327        unsafe fn decode(
3328            &mut self,
3329            decoder: &mut fidl::encoding::Decoder<'_, D>,
3330            offset: usize,
3331            _depth: fidl::encoding::Depth,
3332        ) -> fidl::Result<()> {
3333            decoder.debug_check_bounds::<Self>(offset);
3334            let prim = decoder.read_num::<u32>(offset);
3335
3336            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3337            Ok(())
3338        }
3339    }
3340    unsafe impl fidl::encoding::TypeMarker for OnTerminate {
3341        type Owned = Self;
3342
3343        #[inline(always)]
3344        fn inline_align(_context: fidl::encoding::Context) -> usize {
3345            std::mem::align_of::<u32>()
3346        }
3347
3348        #[inline(always)]
3349        fn inline_size(_context: fidl::encoding::Context) -> usize {
3350            std::mem::size_of::<u32>()
3351        }
3352
3353        #[inline(always)]
3354        fn encode_is_copy() -> bool {
3355            true
3356        }
3357
3358        #[inline(always)]
3359        fn decode_is_copy() -> bool {
3360            false
3361        }
3362    }
3363
3364    impl fidl::encoding::ValueTypeMarker for OnTerminate {
3365        type Borrowed<'a> = Self;
3366        #[inline(always)]
3367        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3368            *value
3369        }
3370    }
3371
3372    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OnTerminate {
3373        #[inline]
3374        unsafe fn encode(
3375            self,
3376            encoder: &mut fidl::encoding::Encoder<'_, D>,
3377            offset: usize,
3378            _depth: fidl::encoding::Depth,
3379        ) -> fidl::Result<()> {
3380            encoder.debug_check_bounds::<Self>(offset);
3381            encoder.write_num(self.into_primitive(), offset);
3382            Ok(())
3383        }
3384    }
3385
3386    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OnTerminate {
3387        #[inline(always)]
3388        fn new_empty() -> Self {
3389            Self::None
3390        }
3391
3392        #[inline]
3393        unsafe fn decode(
3394            &mut self,
3395            decoder: &mut fidl::encoding::Decoder<'_, D>,
3396            offset: usize,
3397            _depth: fidl::encoding::Depth,
3398        ) -> fidl::Result<()> {
3399            decoder.debug_check_bounds::<Self>(offset);
3400            let prim = decoder.read_num::<u32>(offset);
3401
3402            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3403            Ok(())
3404        }
3405    }
3406    unsafe impl fidl::encoding::TypeMarker for StartupMode {
3407        type Owned = Self;
3408
3409        #[inline(always)]
3410        fn inline_align(_context: fidl::encoding::Context) -> usize {
3411            std::mem::align_of::<u32>()
3412        }
3413
3414        #[inline(always)]
3415        fn inline_size(_context: fidl::encoding::Context) -> usize {
3416            std::mem::size_of::<u32>()
3417        }
3418
3419        #[inline(always)]
3420        fn encode_is_copy() -> bool {
3421            true
3422        }
3423
3424        #[inline(always)]
3425        fn decode_is_copy() -> bool {
3426            false
3427        }
3428    }
3429
3430    impl fidl::encoding::ValueTypeMarker for StartupMode {
3431        type Borrowed<'a> = Self;
3432        #[inline(always)]
3433        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3434            *value
3435        }
3436    }
3437
3438    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StartupMode {
3439        #[inline]
3440        unsafe fn encode(
3441            self,
3442            encoder: &mut fidl::encoding::Encoder<'_, D>,
3443            offset: usize,
3444            _depth: fidl::encoding::Depth,
3445        ) -> fidl::Result<()> {
3446            encoder.debug_check_bounds::<Self>(offset);
3447            encoder.write_num(self.into_primitive(), offset);
3448            Ok(())
3449        }
3450    }
3451
3452    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartupMode {
3453        #[inline(always)]
3454        fn new_empty() -> Self {
3455            Self::Lazy
3456        }
3457
3458        #[inline]
3459        unsafe fn decode(
3460            &mut self,
3461            decoder: &mut fidl::encoding::Decoder<'_, D>,
3462            offset: usize,
3463            _depth: fidl::encoding::Depth,
3464        ) -> fidl::Result<()> {
3465            decoder.debug_check_bounds::<Self>(offset);
3466            let prim = decoder.read_num::<u32>(offset);
3467
3468            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3469            Ok(())
3470        }
3471    }
3472    unsafe impl fidl::encoding::TypeMarker for StorageId {
3473        type Owned = Self;
3474
3475        #[inline(always)]
3476        fn inline_align(_context: fidl::encoding::Context) -> usize {
3477            std::mem::align_of::<u32>()
3478        }
3479
3480        #[inline(always)]
3481        fn inline_size(_context: fidl::encoding::Context) -> usize {
3482            std::mem::size_of::<u32>()
3483        }
3484
3485        #[inline(always)]
3486        fn encode_is_copy() -> bool {
3487            true
3488        }
3489
3490        #[inline(always)]
3491        fn decode_is_copy() -> bool {
3492            false
3493        }
3494    }
3495
3496    impl fidl::encoding::ValueTypeMarker for StorageId {
3497        type Borrowed<'a> = Self;
3498        #[inline(always)]
3499        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3500            *value
3501        }
3502    }
3503
3504    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StorageId {
3505        #[inline]
3506        unsafe fn encode(
3507            self,
3508            encoder: &mut fidl::encoding::Encoder<'_, D>,
3509            offset: usize,
3510            _depth: fidl::encoding::Depth,
3511        ) -> fidl::Result<()> {
3512            encoder.debug_check_bounds::<Self>(offset);
3513            encoder.write_num(self.into_primitive(), offset);
3514            Ok(())
3515        }
3516    }
3517
3518    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StorageId {
3519        #[inline(always)]
3520        fn new_empty() -> Self {
3521            Self::StaticInstanceId
3522        }
3523
3524        #[inline]
3525        unsafe fn decode(
3526            &mut self,
3527            decoder: &mut fidl::encoding::Decoder<'_, D>,
3528            offset: usize,
3529            _depth: fidl::encoding::Depth,
3530        ) -> fidl::Result<()> {
3531            decoder.debug_check_bounds::<Self>(offset);
3532            let prim = decoder.read_num::<u32>(offset);
3533
3534            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
3535            Ok(())
3536        }
3537    }
3538
3539    impl fidl::encoding::ValueTypeMarker for CapabilityRef {
3540        type Borrowed<'a> = &'a Self;
3541        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3542            value
3543        }
3544    }
3545
3546    unsafe impl fidl::encoding::TypeMarker for CapabilityRef {
3547        type Owned = Self;
3548
3549        #[inline(always)]
3550        fn inline_align(_context: fidl::encoding::Context) -> usize {
3551            8
3552        }
3553
3554        #[inline(always)]
3555        fn inline_size(_context: fidl::encoding::Context) -> usize {
3556            16
3557        }
3558    }
3559
3560    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CapabilityRef, D>
3561        for &CapabilityRef
3562    {
3563        #[inline]
3564        unsafe fn encode(
3565            self,
3566            encoder: &mut fidl::encoding::Encoder<'_, D>,
3567            offset: usize,
3568            _depth: fidl::encoding::Depth,
3569        ) -> fidl::Result<()> {
3570            encoder.debug_check_bounds::<CapabilityRef>(offset);
3571            // Delegate to tuple encoding.
3572            fidl::encoding::Encode::<CapabilityRef, D>::encode(
3573                (<fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
3574                    &self.name,
3575                ),),
3576                encoder,
3577                offset,
3578                _depth,
3579            )
3580        }
3581    }
3582    unsafe impl<
3583            D: fidl::encoding::ResourceDialect,
3584            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<100>, D>,
3585        > fidl::encoding::Encode<CapabilityRef, D> for (T0,)
3586    {
3587        #[inline]
3588        unsafe fn encode(
3589            self,
3590            encoder: &mut fidl::encoding::Encoder<'_, D>,
3591            offset: usize,
3592            depth: fidl::encoding::Depth,
3593        ) -> fidl::Result<()> {
3594            encoder.debug_check_bounds::<CapabilityRef>(offset);
3595            // Zero out padding regions. There's no need to apply masks
3596            // because the unmasked parts will be overwritten by fields.
3597            // Write the fields.
3598            self.0.encode(encoder, offset + 0, depth)?;
3599            Ok(())
3600        }
3601    }
3602
3603    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CapabilityRef {
3604        #[inline(always)]
3605        fn new_empty() -> Self {
3606            Self { name: fidl::new_empty!(fidl::encoding::BoundedString<100>, D) }
3607        }
3608
3609        #[inline]
3610        unsafe fn decode(
3611            &mut self,
3612            decoder: &mut fidl::encoding::Decoder<'_, D>,
3613            offset: usize,
3614            _depth: fidl::encoding::Depth,
3615        ) -> fidl::Result<()> {
3616            decoder.debug_check_bounds::<Self>(offset);
3617            // Verify that padding bytes are zero.
3618            fidl::decode!(
3619                fidl::encoding::BoundedString<100>,
3620                D,
3621                &mut self.name,
3622                decoder,
3623                offset + 0,
3624                _depth
3625            )?;
3626            Ok(())
3627        }
3628    }
3629
3630    impl fidl::encoding::ValueTypeMarker for ChildRef {
3631        type Borrowed<'a> = &'a Self;
3632        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3633            value
3634        }
3635    }
3636
3637    unsafe impl fidl::encoding::TypeMarker for ChildRef {
3638        type Owned = Self;
3639
3640        #[inline(always)]
3641        fn inline_align(_context: fidl::encoding::Context) -> usize {
3642            8
3643        }
3644
3645        #[inline(always)]
3646        fn inline_size(_context: fidl::encoding::Context) -> usize {
3647            32
3648        }
3649    }
3650
3651    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChildRef, D> for &ChildRef {
3652        #[inline]
3653        unsafe fn encode(
3654            self,
3655            encoder: &mut fidl::encoding::Encoder<'_, D>,
3656            offset: usize,
3657            _depth: fidl::encoding::Depth,
3658        ) -> fidl::Result<()> {
3659            encoder.debug_check_bounds::<ChildRef>(offset);
3660            // Delegate to tuple encoding.
3661            fidl::encoding::Encode::<ChildRef, D>::encode(
3662                (
3663                    <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
3664                    <fidl::encoding::Optional<fidl::encoding::BoundedString<100>> as fidl::encoding::ValueTypeMarker>::borrow(&self.collection),
3665                ),
3666                encoder, offset, _depth
3667            )
3668        }
3669    }
3670    unsafe impl<
3671            D: fidl::encoding::ResourceDialect,
3672            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
3673            T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<100>>, D>,
3674        > fidl::encoding::Encode<ChildRef, D> for (T0, T1)
3675    {
3676        #[inline]
3677        unsafe fn encode(
3678            self,
3679            encoder: &mut fidl::encoding::Encoder<'_, D>,
3680            offset: usize,
3681            depth: fidl::encoding::Depth,
3682        ) -> fidl::Result<()> {
3683            encoder.debug_check_bounds::<ChildRef>(offset);
3684            // Zero out padding regions. There's no need to apply masks
3685            // because the unmasked parts will be overwritten by fields.
3686            // Write the fields.
3687            self.0.encode(encoder, offset + 0, depth)?;
3688            self.1.encode(encoder, offset + 16, depth)?;
3689            Ok(())
3690        }
3691    }
3692
3693    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChildRef {
3694        #[inline(always)]
3695        fn new_empty() -> Self {
3696            Self {
3697                name: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D),
3698                collection: fidl::new_empty!(
3699                    fidl::encoding::Optional<fidl::encoding::BoundedString<100>>,
3700                    D
3701                ),
3702            }
3703        }
3704
3705        #[inline]
3706        unsafe fn decode(
3707            &mut self,
3708            decoder: &mut fidl::encoding::Decoder<'_, D>,
3709            offset: usize,
3710            _depth: fidl::encoding::Depth,
3711        ) -> fidl::Result<()> {
3712            decoder.debug_check_bounds::<Self>(offset);
3713            // Verify that padding bytes are zero.
3714            fidl::decode!(
3715                fidl::encoding::BoundedString<1024>,
3716                D,
3717                &mut self.name,
3718                decoder,
3719                offset + 0,
3720                _depth
3721            )?;
3722            fidl::decode!(
3723                fidl::encoding::Optional<fidl::encoding::BoundedString<100>>,
3724                D,
3725                &mut self.collection,
3726                decoder,
3727                offset + 16,
3728                _depth
3729            )?;
3730            Ok(())
3731        }
3732    }
3733
3734    impl fidl::encoding::ValueTypeMarker for CollectionRef {
3735        type Borrowed<'a> = &'a Self;
3736        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3737            value
3738        }
3739    }
3740
3741    unsafe impl fidl::encoding::TypeMarker for CollectionRef {
3742        type Owned = Self;
3743
3744        #[inline(always)]
3745        fn inline_align(_context: fidl::encoding::Context) -> usize {
3746            8
3747        }
3748
3749        #[inline(always)]
3750        fn inline_size(_context: fidl::encoding::Context) -> usize {
3751            16
3752        }
3753    }
3754
3755    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CollectionRef, D>
3756        for &CollectionRef
3757    {
3758        #[inline]
3759        unsafe fn encode(
3760            self,
3761            encoder: &mut fidl::encoding::Encoder<'_, D>,
3762            offset: usize,
3763            _depth: fidl::encoding::Depth,
3764        ) -> fidl::Result<()> {
3765            encoder.debug_check_bounds::<CollectionRef>(offset);
3766            // Delegate to tuple encoding.
3767            fidl::encoding::Encode::<CollectionRef, D>::encode(
3768                (<fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
3769                    &self.name,
3770                ),),
3771                encoder,
3772                offset,
3773                _depth,
3774            )
3775        }
3776    }
3777    unsafe impl<
3778            D: fidl::encoding::ResourceDialect,
3779            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<100>, D>,
3780        > fidl::encoding::Encode<CollectionRef, D> for (T0,)
3781    {
3782        #[inline]
3783        unsafe fn encode(
3784            self,
3785            encoder: &mut fidl::encoding::Encoder<'_, D>,
3786            offset: usize,
3787            depth: fidl::encoding::Depth,
3788        ) -> fidl::Result<()> {
3789            encoder.debug_check_bounds::<CollectionRef>(offset);
3790            // Zero out padding regions. There's no need to apply masks
3791            // because the unmasked parts will be overwritten by fields.
3792            // Write the fields.
3793            self.0.encode(encoder, offset + 0, depth)?;
3794            Ok(())
3795        }
3796    }
3797
3798    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CollectionRef {
3799        #[inline(always)]
3800        fn new_empty() -> Self {
3801            Self { name: fidl::new_empty!(fidl::encoding::BoundedString<100>, D) }
3802        }
3803
3804        #[inline]
3805        unsafe fn decode(
3806            &mut self,
3807            decoder: &mut fidl::encoding::Decoder<'_, D>,
3808            offset: usize,
3809            _depth: fidl::encoding::Depth,
3810        ) -> fidl::Result<()> {
3811            decoder.debug_check_bounds::<Self>(offset);
3812            // Verify that padding bytes are zero.
3813            fidl::decode!(
3814                fidl::encoding::BoundedString<100>,
3815                D,
3816                &mut self.name,
3817                decoder,
3818                offset + 0,
3819                _depth
3820            )?;
3821            Ok(())
3822        }
3823    }
3824
3825    impl fidl::encoding::ValueTypeMarker for ConfigType {
3826        type Borrowed<'a> = &'a Self;
3827        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3828            value
3829        }
3830    }
3831
3832    unsafe impl fidl::encoding::TypeMarker for ConfigType {
3833        type Owned = Self;
3834
3835        #[inline(always)]
3836        fn inline_align(_context: fidl::encoding::Context) -> usize {
3837            8
3838        }
3839
3840        #[inline(always)]
3841        fn inline_size(_context: fidl::encoding::Context) -> usize {
3842            40
3843        }
3844    }
3845
3846    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigType, D>
3847        for &ConfigType
3848    {
3849        #[inline]
3850        unsafe fn encode(
3851            self,
3852            encoder: &mut fidl::encoding::Encoder<'_, D>,
3853            offset: usize,
3854            _depth: fidl::encoding::Depth,
3855        ) -> fidl::Result<()> {
3856            encoder.debug_check_bounds::<ConfigType>(offset);
3857            // Delegate to tuple encoding.
3858            fidl::encoding::Encode::<ConfigType, D>::encode(
3859                (
3860                    <ConfigTypeLayout as fidl::encoding::ValueTypeMarker>::borrow(&self.layout),
3861                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<LayoutParameter>> as fidl::encoding::ValueTypeMarker>::borrow(&self.parameters),
3862                    <fidl::encoding::UnboundedVector<LayoutConstraint> as fidl::encoding::ValueTypeMarker>::borrow(&self.constraints),
3863                ),
3864                encoder, offset, _depth
3865            )
3866        }
3867    }
3868    unsafe impl<
3869            D: fidl::encoding::ResourceDialect,
3870            T0: fidl::encoding::Encode<ConfigTypeLayout, D>,
3871            T1: fidl::encoding::Encode<
3872                fidl::encoding::Optional<fidl::encoding::UnboundedVector<LayoutParameter>>,
3873                D,
3874            >,
3875            T2: fidl::encoding::Encode<fidl::encoding::UnboundedVector<LayoutConstraint>, D>,
3876        > fidl::encoding::Encode<ConfigType, D> for (T0, T1, T2)
3877    {
3878        #[inline]
3879        unsafe fn encode(
3880            self,
3881            encoder: &mut fidl::encoding::Encoder<'_, D>,
3882            offset: usize,
3883            depth: fidl::encoding::Depth,
3884        ) -> fidl::Result<()> {
3885            encoder.debug_check_bounds::<ConfigType>(offset);
3886            // Zero out padding regions. There's no need to apply masks
3887            // because the unmasked parts will be overwritten by fields.
3888            unsafe {
3889                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3890                (ptr as *mut u64).write_unaligned(0);
3891            }
3892            // Write the fields.
3893            self.0.encode(encoder, offset + 0, depth)?;
3894            self.1.encode(encoder, offset + 8, depth)?;
3895            self.2.encode(encoder, offset + 24, depth)?;
3896            Ok(())
3897        }
3898    }
3899
3900    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigType {
3901        #[inline(always)]
3902        fn new_empty() -> Self {
3903            Self {
3904                layout: fidl::new_empty!(ConfigTypeLayout, D),
3905                parameters: fidl::new_empty!(
3906                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<LayoutParameter>>,
3907                    D
3908                ),
3909                constraints: fidl::new_empty!(fidl::encoding::UnboundedVector<LayoutConstraint>, D),
3910            }
3911        }
3912
3913        #[inline]
3914        unsafe fn decode(
3915            &mut self,
3916            decoder: &mut fidl::encoding::Decoder<'_, D>,
3917            offset: usize,
3918            _depth: fidl::encoding::Depth,
3919        ) -> fidl::Result<()> {
3920            decoder.debug_check_bounds::<Self>(offset);
3921            // Verify that padding bytes are zero.
3922            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3923            let padval = unsafe { (ptr as *const u64).read_unaligned() };
3924            let mask = 0xffffffff00000000u64;
3925            let maskedval = padval & mask;
3926            if maskedval != 0 {
3927                return Err(fidl::Error::NonZeroPadding {
3928                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3929                });
3930            }
3931            fidl::decode!(ConfigTypeLayout, D, &mut self.layout, decoder, offset + 0, _depth)?;
3932            fidl::decode!(
3933                fidl::encoding::Optional<fidl::encoding::UnboundedVector<LayoutParameter>>,
3934                D,
3935                &mut self.parameters,
3936                decoder,
3937                offset + 8,
3938                _depth
3939            )?;
3940            fidl::decode!(
3941                fidl::encoding::UnboundedVector<LayoutConstraint>,
3942                D,
3943                &mut self.constraints,
3944                decoder,
3945                offset + 24,
3946                _depth
3947            )?;
3948            Ok(())
3949        }
3950    }
3951
3952    impl fidl::encoding::ValueTypeMarker for DebugRef {
3953        type Borrowed<'a> = &'a Self;
3954        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3955            value
3956        }
3957    }
3958
3959    unsafe impl fidl::encoding::TypeMarker for DebugRef {
3960        type Owned = Self;
3961
3962        #[inline(always)]
3963        fn inline_align(_context: fidl::encoding::Context) -> usize {
3964            1
3965        }
3966
3967        #[inline(always)]
3968        fn inline_size(_context: fidl::encoding::Context) -> usize {
3969            1
3970        }
3971    }
3972
3973    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DebugRef, D> for &DebugRef {
3974        #[inline]
3975        unsafe fn encode(
3976            self,
3977            encoder: &mut fidl::encoding::Encoder<'_, D>,
3978            offset: usize,
3979            _depth: fidl::encoding::Depth,
3980        ) -> fidl::Result<()> {
3981            encoder.debug_check_bounds::<DebugRef>(offset);
3982            encoder.write_num(0u8, offset);
3983            Ok(())
3984        }
3985    }
3986
3987    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DebugRef {
3988        #[inline(always)]
3989        fn new_empty() -> Self {
3990            Self
3991        }
3992
3993        #[inline]
3994        unsafe fn decode(
3995            &mut self,
3996            decoder: &mut fidl::encoding::Decoder<'_, D>,
3997            offset: usize,
3998            _depth: fidl::encoding::Depth,
3999        ) -> fidl::Result<()> {
4000            decoder.debug_check_bounds::<Self>(offset);
4001            match decoder.read_num::<u8>(offset) {
4002                0 => Ok(()),
4003                _ => Err(fidl::Error::Invalid),
4004            }
4005        }
4006    }
4007
4008    impl fidl::encoding::ValueTypeMarker for EnvironmentRef {
4009        type Borrowed<'a> = &'a Self;
4010        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4011            value
4012        }
4013    }
4014
4015    unsafe impl fidl::encoding::TypeMarker for EnvironmentRef {
4016        type Owned = Self;
4017
4018        #[inline(always)]
4019        fn inline_align(_context: fidl::encoding::Context) -> usize {
4020            1
4021        }
4022
4023        #[inline(always)]
4024        fn inline_size(_context: fidl::encoding::Context) -> usize {
4025            1
4026        }
4027    }
4028
4029    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnvironmentRef, D>
4030        for &EnvironmentRef
4031    {
4032        #[inline]
4033        unsafe fn encode(
4034            self,
4035            encoder: &mut fidl::encoding::Encoder<'_, D>,
4036            offset: usize,
4037            _depth: fidl::encoding::Depth,
4038        ) -> fidl::Result<()> {
4039            encoder.debug_check_bounds::<EnvironmentRef>(offset);
4040            encoder.write_num(0u8, offset);
4041            Ok(())
4042        }
4043    }
4044
4045    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnvironmentRef {
4046        #[inline(always)]
4047        fn new_empty() -> Self {
4048            Self
4049        }
4050
4051        #[inline]
4052        unsafe fn decode(
4053            &mut self,
4054            decoder: &mut fidl::encoding::Decoder<'_, D>,
4055            offset: usize,
4056            _depth: fidl::encoding::Depth,
4057        ) -> fidl::Result<()> {
4058            decoder.debug_check_bounds::<Self>(offset);
4059            match decoder.read_num::<u8>(offset) {
4060                0 => Ok(()),
4061                _ => Err(fidl::Error::Invalid),
4062            }
4063        }
4064    }
4065
4066    impl fidl::encoding::ValueTypeMarker for FrameworkRef {
4067        type Borrowed<'a> = &'a Self;
4068        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4069            value
4070        }
4071    }
4072
4073    unsafe impl fidl::encoding::TypeMarker for FrameworkRef {
4074        type Owned = Self;
4075
4076        #[inline(always)]
4077        fn inline_align(_context: fidl::encoding::Context) -> usize {
4078            1
4079        }
4080
4081        #[inline(always)]
4082        fn inline_size(_context: fidl::encoding::Context) -> usize {
4083            1
4084        }
4085    }
4086
4087    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FrameworkRef, D>
4088        for &FrameworkRef
4089    {
4090        #[inline]
4091        unsafe fn encode(
4092            self,
4093            encoder: &mut fidl::encoding::Encoder<'_, D>,
4094            offset: usize,
4095            _depth: fidl::encoding::Depth,
4096        ) -> fidl::Result<()> {
4097            encoder.debug_check_bounds::<FrameworkRef>(offset);
4098            encoder.write_num(0u8, offset);
4099            Ok(())
4100        }
4101    }
4102
4103    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FrameworkRef {
4104        #[inline(always)]
4105        fn new_empty() -> Self {
4106            Self
4107        }
4108
4109        #[inline]
4110        unsafe fn decode(
4111            &mut self,
4112            decoder: &mut fidl::encoding::Decoder<'_, D>,
4113            offset: usize,
4114            _depth: fidl::encoding::Depth,
4115        ) -> fidl::Result<()> {
4116            decoder.debug_check_bounds::<Self>(offset);
4117            match decoder.read_num::<u8>(offset) {
4118                0 => Ok(()),
4119                _ => Err(fidl::Error::Invalid),
4120            }
4121        }
4122    }
4123
4124    impl fidl::encoding::ValueTypeMarker for NameMapping {
4125        type Borrowed<'a> = &'a Self;
4126        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4127            value
4128        }
4129    }
4130
4131    unsafe impl fidl::encoding::TypeMarker for NameMapping {
4132        type Owned = Self;
4133
4134        #[inline(always)]
4135        fn inline_align(_context: fidl::encoding::Context) -> usize {
4136            8
4137        }
4138
4139        #[inline(always)]
4140        fn inline_size(_context: fidl::encoding::Context) -> usize {
4141            32
4142        }
4143    }
4144
4145    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NameMapping, D>
4146        for &NameMapping
4147    {
4148        #[inline]
4149        unsafe fn encode(
4150            self,
4151            encoder: &mut fidl::encoding::Encoder<'_, D>,
4152            offset: usize,
4153            _depth: fidl::encoding::Depth,
4154        ) -> fidl::Result<()> {
4155            encoder.debug_check_bounds::<NameMapping>(offset);
4156            // Delegate to tuple encoding.
4157            fidl::encoding::Encode::<NameMapping, D>::encode(
4158                (
4159                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
4160                        &self.source_name,
4161                    ),
4162                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow(
4163                        &self.target_name,
4164                    ),
4165                ),
4166                encoder,
4167                offset,
4168                _depth,
4169            )
4170        }
4171    }
4172    unsafe impl<
4173            D: fidl::encoding::ResourceDialect,
4174            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<100>, D>,
4175            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<100>, D>,
4176        > fidl::encoding::Encode<NameMapping, D> for (T0, T1)
4177    {
4178        #[inline]
4179        unsafe fn encode(
4180            self,
4181            encoder: &mut fidl::encoding::Encoder<'_, D>,
4182            offset: usize,
4183            depth: fidl::encoding::Depth,
4184        ) -> fidl::Result<()> {
4185            encoder.debug_check_bounds::<NameMapping>(offset);
4186            // Zero out padding regions. There's no need to apply masks
4187            // because the unmasked parts will be overwritten by fields.
4188            // Write the fields.
4189            self.0.encode(encoder, offset + 0, depth)?;
4190            self.1.encode(encoder, offset + 16, depth)?;
4191            Ok(())
4192        }
4193    }
4194
4195    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NameMapping {
4196        #[inline(always)]
4197        fn new_empty() -> Self {
4198            Self {
4199                source_name: fidl::new_empty!(fidl::encoding::BoundedString<100>, D),
4200                target_name: fidl::new_empty!(fidl::encoding::BoundedString<100>, D),
4201            }
4202        }
4203
4204        #[inline]
4205        unsafe fn decode(
4206            &mut self,
4207            decoder: &mut fidl::encoding::Decoder<'_, D>,
4208            offset: usize,
4209            _depth: fidl::encoding::Depth,
4210        ) -> fidl::Result<()> {
4211            decoder.debug_check_bounds::<Self>(offset);
4212            // Verify that padding bytes are zero.
4213            fidl::decode!(
4214                fidl::encoding::BoundedString<100>,
4215                D,
4216                &mut self.source_name,
4217                decoder,
4218                offset + 0,
4219                _depth
4220            )?;
4221            fidl::decode!(
4222                fidl::encoding::BoundedString<100>,
4223                D,
4224                &mut self.target_name,
4225                decoder,
4226                offset + 16,
4227                _depth
4228            )?;
4229            Ok(())
4230        }
4231    }
4232
4233    impl fidl::encoding::ValueTypeMarker for ParentRef {
4234        type Borrowed<'a> = &'a Self;
4235        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4236            value
4237        }
4238    }
4239
4240    unsafe impl fidl::encoding::TypeMarker for ParentRef {
4241        type Owned = Self;
4242
4243        #[inline(always)]
4244        fn inline_align(_context: fidl::encoding::Context) -> usize {
4245            1
4246        }
4247
4248        #[inline(always)]
4249        fn inline_size(_context: fidl::encoding::Context) -> usize {
4250            1
4251        }
4252    }
4253
4254    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ParentRef, D>
4255        for &ParentRef
4256    {
4257        #[inline]
4258        unsafe fn encode(
4259            self,
4260            encoder: &mut fidl::encoding::Encoder<'_, D>,
4261            offset: usize,
4262            _depth: fidl::encoding::Depth,
4263        ) -> fidl::Result<()> {
4264            encoder.debug_check_bounds::<ParentRef>(offset);
4265            encoder.write_num(0u8, offset);
4266            Ok(())
4267        }
4268    }
4269
4270    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ParentRef {
4271        #[inline(always)]
4272        fn new_empty() -> Self {
4273            Self
4274        }
4275
4276        #[inline]
4277        unsafe fn decode(
4278            &mut self,
4279            decoder: &mut fidl::encoding::Decoder<'_, D>,
4280            offset: usize,
4281            _depth: fidl::encoding::Depth,
4282        ) -> fidl::Result<()> {
4283            decoder.debug_check_bounds::<Self>(offset);
4284            match decoder.read_num::<u8>(offset) {
4285                0 => Ok(()),
4286                _ => Err(fidl::Error::Invalid),
4287            }
4288        }
4289    }
4290
4291    impl fidl::encoding::ValueTypeMarker for ResolvedConfig {
4292        type Borrowed<'a> = &'a Self;
4293        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4294            value
4295        }
4296    }
4297
4298    unsafe impl fidl::encoding::TypeMarker for ResolvedConfig {
4299        type Owned = Self;
4300
4301        #[inline(always)]
4302        fn inline_align(_context: fidl::encoding::Context) -> usize {
4303            8
4304        }
4305
4306        #[inline(always)]
4307        fn inline_size(_context: fidl::encoding::Context) -> usize {
4308            32
4309        }
4310    }
4311
4312    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ResolvedConfig, D>
4313        for &ResolvedConfig
4314    {
4315        #[inline]
4316        unsafe fn encode(
4317            self,
4318            encoder: &mut fidl::encoding::Encoder<'_, D>,
4319            offset: usize,
4320            _depth: fidl::encoding::Depth,
4321        ) -> fidl::Result<()> {
4322            encoder.debug_check_bounds::<ResolvedConfig>(offset);
4323            // Delegate to tuple encoding.
4324            fidl::encoding::Encode::<ResolvedConfig, D>::encode(
4325                (
4326                    <fidl::encoding::UnboundedVector<ResolvedConfigField> as fidl::encoding::ValueTypeMarker>::borrow(&self.fields),
4327                    <ConfigChecksum as fidl::encoding::ValueTypeMarker>::borrow(&self.checksum),
4328                ),
4329                encoder, offset, _depth
4330            )
4331        }
4332    }
4333    unsafe impl<
4334            D: fidl::encoding::ResourceDialect,
4335            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<ResolvedConfigField>, D>,
4336            T1: fidl::encoding::Encode<ConfigChecksum, D>,
4337        > fidl::encoding::Encode<ResolvedConfig, D> for (T0, T1)
4338    {
4339        #[inline]
4340        unsafe fn encode(
4341            self,
4342            encoder: &mut fidl::encoding::Encoder<'_, D>,
4343            offset: usize,
4344            depth: fidl::encoding::Depth,
4345        ) -> fidl::Result<()> {
4346            encoder.debug_check_bounds::<ResolvedConfig>(offset);
4347            // Zero out padding regions. There's no need to apply masks
4348            // because the unmasked parts will be overwritten by fields.
4349            // Write the fields.
4350            self.0.encode(encoder, offset + 0, depth)?;
4351            self.1.encode(encoder, offset + 16, depth)?;
4352            Ok(())
4353        }
4354    }
4355
4356    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolvedConfig {
4357        #[inline(always)]
4358        fn new_empty() -> Self {
4359            Self {
4360                fields: fidl::new_empty!(fidl::encoding::UnboundedVector<ResolvedConfigField>, D),
4361                checksum: fidl::new_empty!(ConfigChecksum, D),
4362            }
4363        }
4364
4365        #[inline]
4366        unsafe fn decode(
4367            &mut self,
4368            decoder: &mut fidl::encoding::Decoder<'_, D>,
4369            offset: usize,
4370            _depth: fidl::encoding::Depth,
4371        ) -> fidl::Result<()> {
4372            decoder.debug_check_bounds::<Self>(offset);
4373            // Verify that padding bytes are zero.
4374            fidl::decode!(
4375                fidl::encoding::UnboundedVector<ResolvedConfigField>,
4376                D,
4377                &mut self.fields,
4378                decoder,
4379                offset + 0,
4380                _depth
4381            )?;
4382            fidl::decode!(ConfigChecksum, D, &mut self.checksum, decoder, offset + 16, _depth)?;
4383            Ok(())
4384        }
4385    }
4386
4387    impl fidl::encoding::ValueTypeMarker for ResolvedConfigField {
4388        type Borrowed<'a> = &'a Self;
4389        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4390            value
4391        }
4392    }
4393
4394    unsafe impl fidl::encoding::TypeMarker for ResolvedConfigField {
4395        type Owned = Self;
4396
4397        #[inline(always)]
4398        fn inline_align(_context: fidl::encoding::Context) -> usize {
4399            8
4400        }
4401
4402        #[inline(always)]
4403        fn inline_size(_context: fidl::encoding::Context) -> usize {
4404            32
4405        }
4406    }
4407
4408    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ResolvedConfigField, D>
4409        for &ResolvedConfigField
4410    {
4411        #[inline]
4412        unsafe fn encode(
4413            self,
4414            encoder: &mut fidl::encoding::Encoder<'_, D>,
4415            offset: usize,
4416            _depth: fidl::encoding::Depth,
4417        ) -> fidl::Result<()> {
4418            encoder.debug_check_bounds::<ResolvedConfigField>(offset);
4419            // Delegate to tuple encoding.
4420            fidl::encoding::Encode::<ResolvedConfigField, D>::encode(
4421                (
4422                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
4423                        &self.key,
4424                    ),
4425                    <ConfigValue as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
4426                ),
4427                encoder,
4428                offset,
4429                _depth,
4430            )
4431        }
4432    }
4433    unsafe impl<
4434            D: fidl::encoding::ResourceDialect,
4435            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
4436            T1: fidl::encoding::Encode<ConfigValue, D>,
4437        > fidl::encoding::Encode<ResolvedConfigField, D> for (T0, T1)
4438    {
4439        #[inline]
4440        unsafe fn encode(
4441            self,
4442            encoder: &mut fidl::encoding::Encoder<'_, D>,
4443            offset: usize,
4444            depth: fidl::encoding::Depth,
4445        ) -> fidl::Result<()> {
4446            encoder.debug_check_bounds::<ResolvedConfigField>(offset);
4447            // Zero out padding regions. There's no need to apply masks
4448            // because the unmasked parts will be overwritten by fields.
4449            // Write the fields.
4450            self.0.encode(encoder, offset + 0, depth)?;
4451            self.1.encode(encoder, offset + 16, depth)?;
4452            Ok(())
4453        }
4454    }
4455
4456    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolvedConfigField {
4457        #[inline(always)]
4458        fn new_empty() -> Self {
4459            Self {
4460                key: fidl::new_empty!(fidl::encoding::UnboundedString, D),
4461                value: fidl::new_empty!(ConfigValue, D),
4462            }
4463        }
4464
4465        #[inline]
4466        unsafe fn decode(
4467            &mut self,
4468            decoder: &mut fidl::encoding::Decoder<'_, D>,
4469            offset: usize,
4470            _depth: fidl::encoding::Depth,
4471        ) -> fidl::Result<()> {
4472            decoder.debug_check_bounds::<Self>(offset);
4473            // Verify that padding bytes are zero.
4474            fidl::decode!(
4475                fidl::encoding::UnboundedString,
4476                D,
4477                &mut self.key,
4478                decoder,
4479                offset + 0,
4480                _depth
4481            )?;
4482            fidl::decode!(ConfigValue, D, &mut self.value, decoder, offset + 16, _depth)?;
4483            Ok(())
4484        }
4485    }
4486
4487    impl fidl::encoding::ValueTypeMarker for SelfRef {
4488        type Borrowed<'a> = &'a Self;
4489        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4490            value
4491        }
4492    }
4493
4494    unsafe impl fidl::encoding::TypeMarker for SelfRef {
4495        type Owned = Self;
4496
4497        #[inline(always)]
4498        fn inline_align(_context: fidl::encoding::Context) -> usize {
4499            1
4500        }
4501
4502        #[inline(always)]
4503        fn inline_size(_context: fidl::encoding::Context) -> usize {
4504            1
4505        }
4506    }
4507
4508    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SelfRef, D> for &SelfRef {
4509        #[inline]
4510        unsafe fn encode(
4511            self,
4512            encoder: &mut fidl::encoding::Encoder<'_, D>,
4513            offset: usize,
4514            _depth: fidl::encoding::Depth,
4515        ) -> fidl::Result<()> {
4516            encoder.debug_check_bounds::<SelfRef>(offset);
4517            encoder.write_num(0u8, offset);
4518            Ok(())
4519        }
4520    }
4521
4522    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SelfRef {
4523        #[inline(always)]
4524        fn new_empty() -> Self {
4525            Self
4526        }
4527
4528        #[inline]
4529        unsafe fn decode(
4530            &mut self,
4531            decoder: &mut fidl::encoding::Decoder<'_, D>,
4532            offset: usize,
4533            _depth: fidl::encoding::Depth,
4534        ) -> fidl::Result<()> {
4535            decoder.debug_check_bounds::<Self>(offset);
4536            match decoder.read_num::<u8>(offset) {
4537                0 => Ok(()),
4538                _ => Err(fidl::Error::Invalid),
4539            }
4540        }
4541    }
4542
4543    impl fidl::encoding::ValueTypeMarker for VoidRef {
4544        type Borrowed<'a> = &'a Self;
4545        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4546            value
4547        }
4548    }
4549
4550    unsafe impl fidl::encoding::TypeMarker for VoidRef {
4551        type Owned = Self;
4552
4553        #[inline(always)]
4554        fn inline_align(_context: fidl::encoding::Context) -> usize {
4555            1
4556        }
4557
4558        #[inline(always)]
4559        fn inline_size(_context: fidl::encoding::Context) -> usize {
4560            1
4561        }
4562    }
4563
4564    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VoidRef, D> for &VoidRef {
4565        #[inline]
4566        unsafe fn encode(
4567            self,
4568            encoder: &mut fidl::encoding::Encoder<'_, D>,
4569            offset: usize,
4570            _depth: fidl::encoding::Depth,
4571        ) -> fidl::Result<()> {
4572            encoder.debug_check_bounds::<VoidRef>(offset);
4573            encoder.write_num(0u8, offset);
4574            Ok(())
4575        }
4576    }
4577
4578    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VoidRef {
4579        #[inline(always)]
4580        fn new_empty() -> Self {
4581            Self
4582        }
4583
4584        #[inline]
4585        unsafe fn decode(
4586            &mut self,
4587            decoder: &mut fidl::encoding::Decoder<'_, D>,
4588            offset: usize,
4589            _depth: fidl::encoding::Depth,
4590        ) -> fidl::Result<()> {
4591            decoder.debug_check_bounds::<Self>(offset);
4592            match decoder.read_num::<u8>(offset) {
4593                0 => Ok(()),
4594                _ => Err(fidl::Error::Invalid),
4595            }
4596        }
4597    }
4598
4599    impl Child {
4600        #[inline(always)]
4601        fn max_ordinal_present(&self) -> u64 {
4602            if let Some(_) = self.config_overrides {
4603                return 6;
4604            }
4605            if let Some(_) = self.on_terminate {
4606                return 5;
4607            }
4608            if let Some(_) = self.environment {
4609                return 4;
4610            }
4611            if let Some(_) = self.startup {
4612                return 3;
4613            }
4614            if let Some(_) = self.url {
4615                return 2;
4616            }
4617            if let Some(_) = self.name {
4618                return 1;
4619            }
4620            0
4621        }
4622    }
4623
4624    impl fidl::encoding::ValueTypeMarker for Child {
4625        type Borrowed<'a> = &'a Self;
4626        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4627            value
4628        }
4629    }
4630
4631    unsafe impl fidl::encoding::TypeMarker for Child {
4632        type Owned = Self;
4633
4634        #[inline(always)]
4635        fn inline_align(_context: fidl::encoding::Context) -> usize {
4636            8
4637        }
4638
4639        #[inline(always)]
4640        fn inline_size(_context: fidl::encoding::Context) -> usize {
4641            16
4642        }
4643    }
4644
4645    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Child, D> for &Child {
4646        unsafe fn encode(
4647            self,
4648            encoder: &mut fidl::encoding::Encoder<'_, D>,
4649            offset: usize,
4650            mut depth: fidl::encoding::Depth,
4651        ) -> fidl::Result<()> {
4652            encoder.debug_check_bounds::<Child>(offset);
4653            // Vector header
4654            let max_ordinal: u64 = self.max_ordinal_present();
4655            encoder.write_num(max_ordinal, offset);
4656            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4657            // Calling encoder.out_of_line_offset(0) is not allowed.
4658            if max_ordinal == 0 {
4659                return Ok(());
4660            }
4661            depth.increment()?;
4662            let envelope_size = 8;
4663            let bytes_len = max_ordinal as usize * envelope_size;
4664            #[allow(unused_variables)]
4665            let offset = encoder.out_of_line_offset(bytes_len);
4666            let mut _prev_end_offset: usize = 0;
4667            if 1 > max_ordinal {
4668                return Ok(());
4669            }
4670
4671            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4672            // are envelope_size bytes.
4673            let cur_offset: usize = (1 - 1) * envelope_size;
4674
4675            // Zero reserved fields.
4676            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4677
4678            // Safety:
4679            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4680            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4681            //   envelope_size bytes, there is always sufficient room.
4682            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
4683            self.name.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
4684            encoder, offset + cur_offset, depth
4685        )?;
4686
4687            _prev_end_offset = cur_offset + envelope_size;
4688            if 2 > max_ordinal {
4689                return Ok(());
4690            }
4691
4692            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4693            // are envelope_size bytes.
4694            let cur_offset: usize = (2 - 1) * envelope_size;
4695
4696            // Zero reserved fields.
4697            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4698
4699            // Safety:
4700            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4701            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4702            //   envelope_size bytes, there is always sufficient room.
4703            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
4704            self.url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
4705            encoder, offset + cur_offset, depth
4706        )?;
4707
4708            _prev_end_offset = cur_offset + envelope_size;
4709            if 3 > max_ordinal {
4710                return Ok(());
4711            }
4712
4713            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4714            // are envelope_size bytes.
4715            let cur_offset: usize = (3 - 1) * envelope_size;
4716
4717            // Zero reserved fields.
4718            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4719
4720            // Safety:
4721            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4722            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4723            //   envelope_size bytes, there is always sufficient room.
4724            fidl::encoding::encode_in_envelope_optional::<StartupMode, D>(
4725                self.startup.as_ref().map(<StartupMode as fidl::encoding::ValueTypeMarker>::borrow),
4726                encoder,
4727                offset + cur_offset,
4728                depth,
4729            )?;
4730
4731            _prev_end_offset = cur_offset + envelope_size;
4732            if 4 > max_ordinal {
4733                return Ok(());
4734            }
4735
4736            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4737            // are envelope_size bytes.
4738            let cur_offset: usize = (4 - 1) * envelope_size;
4739
4740            // Zero reserved fields.
4741            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4742
4743            // Safety:
4744            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4745            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4746            //   envelope_size bytes, there is always sufficient room.
4747            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
4748                self.environment.as_ref().map(
4749                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
4750                ),
4751                encoder,
4752                offset + cur_offset,
4753                depth,
4754            )?;
4755
4756            _prev_end_offset = cur_offset + envelope_size;
4757            if 5 > max_ordinal {
4758                return Ok(());
4759            }
4760
4761            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4762            // are envelope_size bytes.
4763            let cur_offset: usize = (5 - 1) * envelope_size;
4764
4765            // Zero reserved fields.
4766            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4767
4768            // Safety:
4769            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4770            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4771            //   envelope_size bytes, there is always sufficient room.
4772            fidl::encoding::encode_in_envelope_optional::<OnTerminate, D>(
4773                self.on_terminate
4774                    .as_ref()
4775                    .map(<OnTerminate as fidl::encoding::ValueTypeMarker>::borrow),
4776                encoder,
4777                offset + cur_offset,
4778                depth,
4779            )?;
4780
4781            _prev_end_offset = cur_offset + envelope_size;
4782            if 6 > max_ordinal {
4783                return Ok(());
4784            }
4785
4786            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4787            // are envelope_size bytes.
4788            let cur_offset: usize = (6 - 1) * envelope_size;
4789
4790            // Zero reserved fields.
4791            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4792
4793            // Safety:
4794            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4795            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4796            //   envelope_size bytes, there is always sufficient room.
4797            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ConfigOverride>, D>(
4798            self.config_overrides.as_ref().map(<fidl::encoding::UnboundedVector<ConfigOverride> as fidl::encoding::ValueTypeMarker>::borrow),
4799            encoder, offset + cur_offset, depth
4800        )?;
4801
4802            _prev_end_offset = cur_offset + envelope_size;
4803
4804            Ok(())
4805        }
4806    }
4807
4808    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Child {
4809        #[inline(always)]
4810        fn new_empty() -> Self {
4811            Self::default()
4812        }
4813
4814        unsafe fn decode(
4815            &mut self,
4816            decoder: &mut fidl::encoding::Decoder<'_, D>,
4817            offset: usize,
4818            mut depth: fidl::encoding::Depth,
4819        ) -> fidl::Result<()> {
4820            decoder.debug_check_bounds::<Self>(offset);
4821            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4822                None => return Err(fidl::Error::NotNullable),
4823                Some(len) => len,
4824            };
4825            // Calling decoder.out_of_line_offset(0) is not allowed.
4826            if len == 0 {
4827                return Ok(());
4828            };
4829            depth.increment()?;
4830            let envelope_size = 8;
4831            let bytes_len = len * envelope_size;
4832            let offset = decoder.out_of_line_offset(bytes_len)?;
4833            // Decode the envelope for each type.
4834            let mut _next_ordinal_to_read = 0;
4835            let mut next_offset = offset;
4836            let end_offset = offset + bytes_len;
4837            _next_ordinal_to_read += 1;
4838            if next_offset >= end_offset {
4839                return Ok(());
4840            }
4841
4842            // Decode unknown envelopes for gaps in ordinals.
4843            while _next_ordinal_to_read < 1 {
4844                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4845                _next_ordinal_to_read += 1;
4846                next_offset += envelope_size;
4847            }
4848
4849            let next_out_of_line = decoder.next_out_of_line();
4850            let handles_before = decoder.remaining_handles();
4851            if let Some((inlined, num_bytes, num_handles)) =
4852                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4853            {
4854                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4855                if inlined != (member_inline_size <= 4) {
4856                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4857                }
4858                let inner_offset;
4859                let mut inner_depth = depth.clone();
4860                if inlined {
4861                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4862                    inner_offset = next_offset;
4863                } else {
4864                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4865                    inner_depth.increment()?;
4866                }
4867                let val_ref = self.name.get_or_insert_with(|| {
4868                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
4869                });
4870                fidl::decode!(
4871                    fidl::encoding::BoundedString<1024>,
4872                    D,
4873                    val_ref,
4874                    decoder,
4875                    inner_offset,
4876                    inner_depth
4877                )?;
4878                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4879                {
4880                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4881                }
4882                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4883                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4884                }
4885            }
4886
4887            next_offset += envelope_size;
4888            _next_ordinal_to_read += 1;
4889            if next_offset >= end_offset {
4890                return Ok(());
4891            }
4892
4893            // Decode unknown envelopes for gaps in ordinals.
4894            while _next_ordinal_to_read < 2 {
4895                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4896                _next_ordinal_to_read += 1;
4897                next_offset += envelope_size;
4898            }
4899
4900            let next_out_of_line = decoder.next_out_of_line();
4901            let handles_before = decoder.remaining_handles();
4902            if let Some((inlined, num_bytes, num_handles)) =
4903                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4904            {
4905                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4906                if inlined != (member_inline_size <= 4) {
4907                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4908                }
4909                let inner_offset;
4910                let mut inner_depth = depth.clone();
4911                if inlined {
4912                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4913                    inner_offset = next_offset;
4914                } else {
4915                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4916                    inner_depth.increment()?;
4917                }
4918                let val_ref = self.url.get_or_insert_with(|| {
4919                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
4920                });
4921                fidl::decode!(
4922                    fidl::encoding::BoundedString<4096>,
4923                    D,
4924                    val_ref,
4925                    decoder,
4926                    inner_offset,
4927                    inner_depth
4928                )?;
4929                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4930                {
4931                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4932                }
4933                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4934                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4935                }
4936            }
4937
4938            next_offset += envelope_size;
4939            _next_ordinal_to_read += 1;
4940            if next_offset >= end_offset {
4941                return Ok(());
4942            }
4943
4944            // Decode unknown envelopes for gaps in ordinals.
4945            while _next_ordinal_to_read < 3 {
4946                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4947                _next_ordinal_to_read += 1;
4948                next_offset += envelope_size;
4949            }
4950
4951            let next_out_of_line = decoder.next_out_of_line();
4952            let handles_before = decoder.remaining_handles();
4953            if let Some((inlined, num_bytes, num_handles)) =
4954                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4955            {
4956                let member_inline_size =
4957                    <StartupMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4958                if inlined != (member_inline_size <= 4) {
4959                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4960                }
4961                let inner_offset;
4962                let mut inner_depth = depth.clone();
4963                if inlined {
4964                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4965                    inner_offset = next_offset;
4966                } else {
4967                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4968                    inner_depth.increment()?;
4969                }
4970                let val_ref = self.startup.get_or_insert_with(|| fidl::new_empty!(StartupMode, D));
4971                fidl::decode!(StartupMode, D, val_ref, decoder, inner_offset, inner_depth)?;
4972                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4973                {
4974                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4975                }
4976                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4977                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4978                }
4979            }
4980
4981            next_offset += envelope_size;
4982            _next_ordinal_to_read += 1;
4983            if next_offset >= end_offset {
4984                return Ok(());
4985            }
4986
4987            // Decode unknown envelopes for gaps in ordinals.
4988            while _next_ordinal_to_read < 4 {
4989                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4990                _next_ordinal_to_read += 1;
4991                next_offset += envelope_size;
4992            }
4993
4994            let next_out_of_line = decoder.next_out_of_line();
4995            let handles_before = decoder.remaining_handles();
4996            if let Some((inlined, num_bytes, num_handles)) =
4997                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4998            {
4999                let member_inline_size =
5000                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
5001                        decoder.context,
5002                    );
5003                if inlined != (member_inline_size <= 4) {
5004                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5005                }
5006                let inner_offset;
5007                let mut inner_depth = depth.clone();
5008                if inlined {
5009                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5010                    inner_offset = next_offset;
5011                } else {
5012                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5013                    inner_depth.increment()?;
5014                }
5015                let val_ref = self
5016                    .environment
5017                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
5018                fidl::decode!(
5019                    fidl::encoding::BoundedString<100>,
5020                    D,
5021                    val_ref,
5022                    decoder,
5023                    inner_offset,
5024                    inner_depth
5025                )?;
5026                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5027                {
5028                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5029                }
5030                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5031                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5032                }
5033            }
5034
5035            next_offset += envelope_size;
5036            _next_ordinal_to_read += 1;
5037            if next_offset >= end_offset {
5038                return Ok(());
5039            }
5040
5041            // Decode unknown envelopes for gaps in ordinals.
5042            while _next_ordinal_to_read < 5 {
5043                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5044                _next_ordinal_to_read += 1;
5045                next_offset += envelope_size;
5046            }
5047
5048            let next_out_of_line = decoder.next_out_of_line();
5049            let handles_before = decoder.remaining_handles();
5050            if let Some((inlined, num_bytes, num_handles)) =
5051                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5052            {
5053                let member_inline_size =
5054                    <OnTerminate as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5055                if inlined != (member_inline_size <= 4) {
5056                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5057                }
5058                let inner_offset;
5059                let mut inner_depth = depth.clone();
5060                if inlined {
5061                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5062                    inner_offset = next_offset;
5063                } else {
5064                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5065                    inner_depth.increment()?;
5066                }
5067                let val_ref =
5068                    self.on_terminate.get_or_insert_with(|| fidl::new_empty!(OnTerminate, D));
5069                fidl::decode!(OnTerminate, D, val_ref, decoder, inner_offset, inner_depth)?;
5070                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5071                {
5072                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5073                }
5074                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5075                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5076                }
5077            }
5078
5079            next_offset += envelope_size;
5080            _next_ordinal_to_read += 1;
5081            if next_offset >= end_offset {
5082                return Ok(());
5083            }
5084
5085            // Decode unknown envelopes for gaps in ordinals.
5086            while _next_ordinal_to_read < 6 {
5087                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5088                _next_ordinal_to_read += 1;
5089                next_offset += envelope_size;
5090            }
5091
5092            let next_out_of_line = decoder.next_out_of_line();
5093            let handles_before = decoder.remaining_handles();
5094            if let Some((inlined, num_bytes, num_handles)) =
5095                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5096            {
5097                let member_inline_size = <fidl::encoding::UnboundedVector<ConfigOverride> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
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.config_overrides.get_or_insert_with(|| {
5111                    fidl::new_empty!(fidl::encoding::UnboundedVector<ConfigOverride>, D)
5112                });
5113                fidl::decode!(
5114                    fidl::encoding::UnboundedVector<ConfigOverride>,
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
5132            // Decode the remaining unknown envelopes.
5133            while next_offset < end_offset {
5134                _next_ordinal_to_read += 1;
5135                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5136                next_offset += envelope_size;
5137            }
5138
5139            Ok(())
5140        }
5141    }
5142
5143    impl Collection {
5144        #[inline(always)]
5145        fn max_ordinal_present(&self) -> u64 {
5146            if let Some(_) = self.persistent_storage {
5147                return 6;
5148            }
5149            if let Some(_) = self.allow_long_names {
5150                return 5;
5151            }
5152            if let Some(_) = self.allowed_offers {
5153                return 4;
5154            }
5155            if let Some(_) = self.environment {
5156                return 3;
5157            }
5158            if let Some(_) = self.durability {
5159                return 2;
5160            }
5161            if let Some(_) = self.name {
5162                return 1;
5163            }
5164            0
5165        }
5166    }
5167
5168    impl fidl::encoding::ValueTypeMarker for Collection {
5169        type Borrowed<'a> = &'a Self;
5170        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5171            value
5172        }
5173    }
5174
5175    unsafe impl fidl::encoding::TypeMarker for Collection {
5176        type Owned = Self;
5177
5178        #[inline(always)]
5179        fn inline_align(_context: fidl::encoding::Context) -> usize {
5180            8
5181        }
5182
5183        #[inline(always)]
5184        fn inline_size(_context: fidl::encoding::Context) -> usize {
5185            16
5186        }
5187    }
5188
5189    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Collection, D>
5190        for &Collection
5191    {
5192        unsafe fn encode(
5193            self,
5194            encoder: &mut fidl::encoding::Encoder<'_, D>,
5195            offset: usize,
5196            mut depth: fidl::encoding::Depth,
5197        ) -> fidl::Result<()> {
5198            encoder.debug_check_bounds::<Collection>(offset);
5199            // Vector header
5200            let max_ordinal: u64 = self.max_ordinal_present();
5201            encoder.write_num(max_ordinal, offset);
5202            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5203            // Calling encoder.out_of_line_offset(0) is not allowed.
5204            if max_ordinal == 0 {
5205                return Ok(());
5206            }
5207            depth.increment()?;
5208            let envelope_size = 8;
5209            let bytes_len = max_ordinal as usize * envelope_size;
5210            #[allow(unused_variables)]
5211            let offset = encoder.out_of_line_offset(bytes_len);
5212            let mut _prev_end_offset: usize = 0;
5213            if 1 > max_ordinal {
5214                return Ok(());
5215            }
5216
5217            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5218            // are envelope_size bytes.
5219            let cur_offset: usize = (1 - 1) * envelope_size;
5220
5221            // Zero reserved fields.
5222            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5223
5224            // Safety:
5225            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5226            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5227            //   envelope_size bytes, there is always sufficient room.
5228            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
5229                self.name.as_ref().map(
5230                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
5231                ),
5232                encoder,
5233                offset + cur_offset,
5234                depth,
5235            )?;
5236
5237            _prev_end_offset = cur_offset + envelope_size;
5238            if 2 > max_ordinal {
5239                return Ok(());
5240            }
5241
5242            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5243            // are envelope_size bytes.
5244            let cur_offset: usize = (2 - 1) * envelope_size;
5245
5246            // Zero reserved fields.
5247            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5248
5249            // Safety:
5250            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5251            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5252            //   envelope_size bytes, there is always sufficient room.
5253            fidl::encoding::encode_in_envelope_optional::<Durability, D>(
5254                self.durability
5255                    .as_ref()
5256                    .map(<Durability as fidl::encoding::ValueTypeMarker>::borrow),
5257                encoder,
5258                offset + cur_offset,
5259                depth,
5260            )?;
5261
5262            _prev_end_offset = cur_offset + envelope_size;
5263            if 3 > max_ordinal {
5264                return Ok(());
5265            }
5266
5267            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5268            // are envelope_size bytes.
5269            let cur_offset: usize = (3 - 1) * envelope_size;
5270
5271            // Zero reserved fields.
5272            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5273
5274            // Safety:
5275            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5276            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5277            //   envelope_size bytes, there is always sufficient room.
5278            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
5279                self.environment.as_ref().map(
5280                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
5281                ),
5282                encoder,
5283                offset + cur_offset,
5284                depth,
5285            )?;
5286
5287            _prev_end_offset = cur_offset + envelope_size;
5288            if 4 > max_ordinal {
5289                return Ok(());
5290            }
5291
5292            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5293            // are envelope_size bytes.
5294            let cur_offset: usize = (4 - 1) * envelope_size;
5295
5296            // Zero reserved fields.
5297            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5298
5299            // Safety:
5300            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5301            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5302            //   envelope_size bytes, there is always sufficient room.
5303            fidl::encoding::encode_in_envelope_optional::<AllowedOffers, D>(
5304                self.allowed_offers
5305                    .as_ref()
5306                    .map(<AllowedOffers as fidl::encoding::ValueTypeMarker>::borrow),
5307                encoder,
5308                offset + cur_offset,
5309                depth,
5310            )?;
5311
5312            _prev_end_offset = cur_offset + envelope_size;
5313            if 5 > max_ordinal {
5314                return Ok(());
5315            }
5316
5317            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5318            // are envelope_size bytes.
5319            let cur_offset: usize = (5 - 1) * envelope_size;
5320
5321            // Zero reserved fields.
5322            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5323
5324            // Safety:
5325            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5326            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5327            //   envelope_size bytes, there is always sufficient room.
5328            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5329                self.allow_long_names
5330                    .as_ref()
5331                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5332                encoder,
5333                offset + cur_offset,
5334                depth,
5335            )?;
5336
5337            _prev_end_offset = cur_offset + envelope_size;
5338            if 6 > max_ordinal {
5339                return Ok(());
5340            }
5341
5342            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5343            // are envelope_size bytes.
5344            let cur_offset: usize = (6 - 1) * envelope_size;
5345
5346            // Zero reserved fields.
5347            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5348
5349            // Safety:
5350            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5351            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5352            //   envelope_size bytes, there is always sufficient room.
5353            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5354                self.persistent_storage
5355                    .as_ref()
5356                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5357                encoder,
5358                offset + cur_offset,
5359                depth,
5360            )?;
5361
5362            _prev_end_offset = cur_offset + envelope_size;
5363
5364            Ok(())
5365        }
5366    }
5367
5368    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Collection {
5369        #[inline(always)]
5370        fn new_empty() -> Self {
5371            Self::default()
5372        }
5373
5374        unsafe fn decode(
5375            &mut self,
5376            decoder: &mut fidl::encoding::Decoder<'_, D>,
5377            offset: usize,
5378            mut depth: fidl::encoding::Depth,
5379        ) -> fidl::Result<()> {
5380            decoder.debug_check_bounds::<Self>(offset);
5381            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5382                None => return Err(fidl::Error::NotNullable),
5383                Some(len) => len,
5384            };
5385            // Calling decoder.out_of_line_offset(0) is not allowed.
5386            if len == 0 {
5387                return Ok(());
5388            };
5389            depth.increment()?;
5390            let envelope_size = 8;
5391            let bytes_len = len * envelope_size;
5392            let offset = decoder.out_of_line_offset(bytes_len)?;
5393            // Decode the envelope for each type.
5394            let mut _next_ordinal_to_read = 0;
5395            let mut next_offset = offset;
5396            let end_offset = offset + bytes_len;
5397            _next_ordinal_to_read += 1;
5398            if next_offset >= end_offset {
5399                return Ok(());
5400            }
5401
5402            // Decode unknown envelopes for gaps in ordinals.
5403            while _next_ordinal_to_read < 1 {
5404                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5405                _next_ordinal_to_read += 1;
5406                next_offset += envelope_size;
5407            }
5408
5409            let next_out_of_line = decoder.next_out_of_line();
5410            let handles_before = decoder.remaining_handles();
5411            if let Some((inlined, num_bytes, num_handles)) =
5412                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5413            {
5414                let member_inline_size =
5415                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
5416                        decoder.context,
5417                    );
5418                if inlined != (member_inline_size <= 4) {
5419                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5420                }
5421                let inner_offset;
5422                let mut inner_depth = depth.clone();
5423                if inlined {
5424                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5425                    inner_offset = next_offset;
5426                } else {
5427                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5428                    inner_depth.increment()?;
5429                }
5430                let val_ref = self
5431                    .name
5432                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
5433                fidl::decode!(
5434                    fidl::encoding::BoundedString<100>,
5435                    D,
5436                    val_ref,
5437                    decoder,
5438                    inner_offset,
5439                    inner_depth
5440                )?;
5441                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5442                {
5443                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5444                }
5445                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5446                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5447                }
5448            }
5449
5450            next_offset += envelope_size;
5451            _next_ordinal_to_read += 1;
5452            if next_offset >= end_offset {
5453                return Ok(());
5454            }
5455
5456            // Decode unknown envelopes for gaps in ordinals.
5457            while _next_ordinal_to_read < 2 {
5458                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5459                _next_ordinal_to_read += 1;
5460                next_offset += envelope_size;
5461            }
5462
5463            let next_out_of_line = decoder.next_out_of_line();
5464            let handles_before = decoder.remaining_handles();
5465            if let Some((inlined, num_bytes, num_handles)) =
5466                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5467            {
5468                let member_inline_size =
5469                    <Durability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5470                if inlined != (member_inline_size <= 4) {
5471                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5472                }
5473                let inner_offset;
5474                let mut inner_depth = depth.clone();
5475                if inlined {
5476                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5477                    inner_offset = next_offset;
5478                } else {
5479                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5480                    inner_depth.increment()?;
5481                }
5482                let val_ref =
5483                    self.durability.get_or_insert_with(|| fidl::new_empty!(Durability, D));
5484                fidl::decode!(Durability, D, val_ref, decoder, inner_offset, inner_depth)?;
5485                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5486                {
5487                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5488                }
5489                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5490                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5491                }
5492            }
5493
5494            next_offset += envelope_size;
5495            _next_ordinal_to_read += 1;
5496            if next_offset >= end_offset {
5497                return Ok(());
5498            }
5499
5500            // Decode unknown envelopes for gaps in ordinals.
5501            while _next_ordinal_to_read < 3 {
5502                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5503                _next_ordinal_to_read += 1;
5504                next_offset += envelope_size;
5505            }
5506
5507            let next_out_of_line = decoder.next_out_of_line();
5508            let handles_before = decoder.remaining_handles();
5509            if let Some((inlined, num_bytes, num_handles)) =
5510                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5511            {
5512                let member_inline_size =
5513                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
5514                        decoder.context,
5515                    );
5516                if inlined != (member_inline_size <= 4) {
5517                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5518                }
5519                let inner_offset;
5520                let mut inner_depth = depth.clone();
5521                if inlined {
5522                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5523                    inner_offset = next_offset;
5524                } else {
5525                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5526                    inner_depth.increment()?;
5527                }
5528                let val_ref = self
5529                    .environment
5530                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
5531                fidl::decode!(
5532                    fidl::encoding::BoundedString<100>,
5533                    D,
5534                    val_ref,
5535                    decoder,
5536                    inner_offset,
5537                    inner_depth
5538                )?;
5539                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5540                {
5541                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5542                }
5543                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5544                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5545                }
5546            }
5547
5548            next_offset += envelope_size;
5549            _next_ordinal_to_read += 1;
5550            if next_offset >= end_offset {
5551                return Ok(());
5552            }
5553
5554            // Decode unknown envelopes for gaps in ordinals.
5555            while _next_ordinal_to_read < 4 {
5556                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5557                _next_ordinal_to_read += 1;
5558                next_offset += envelope_size;
5559            }
5560
5561            let next_out_of_line = decoder.next_out_of_line();
5562            let handles_before = decoder.remaining_handles();
5563            if let Some((inlined, num_bytes, num_handles)) =
5564                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5565            {
5566                let member_inline_size =
5567                    <AllowedOffers as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5568                if inlined != (member_inline_size <= 4) {
5569                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5570                }
5571                let inner_offset;
5572                let mut inner_depth = depth.clone();
5573                if inlined {
5574                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5575                    inner_offset = next_offset;
5576                } else {
5577                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5578                    inner_depth.increment()?;
5579                }
5580                let val_ref =
5581                    self.allowed_offers.get_or_insert_with(|| fidl::new_empty!(AllowedOffers, D));
5582                fidl::decode!(AllowedOffers, D, val_ref, decoder, inner_offset, inner_depth)?;
5583                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5584                {
5585                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5586                }
5587                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5588                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5589                }
5590            }
5591
5592            next_offset += envelope_size;
5593            _next_ordinal_to_read += 1;
5594            if next_offset >= end_offset {
5595                return Ok(());
5596            }
5597
5598            // Decode unknown envelopes for gaps in ordinals.
5599            while _next_ordinal_to_read < 5 {
5600                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5601                _next_ordinal_to_read += 1;
5602                next_offset += envelope_size;
5603            }
5604
5605            let next_out_of_line = decoder.next_out_of_line();
5606            let handles_before = decoder.remaining_handles();
5607            if let Some((inlined, num_bytes, num_handles)) =
5608                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5609            {
5610                let member_inline_size =
5611                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5612                if inlined != (member_inline_size <= 4) {
5613                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5614                }
5615                let inner_offset;
5616                let mut inner_depth = depth.clone();
5617                if inlined {
5618                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5619                    inner_offset = next_offset;
5620                } else {
5621                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5622                    inner_depth.increment()?;
5623                }
5624                let val_ref =
5625                    self.allow_long_names.get_or_insert_with(|| fidl::new_empty!(bool, D));
5626                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5627                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5628                {
5629                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5630                }
5631                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5632                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5633                }
5634            }
5635
5636            next_offset += envelope_size;
5637            _next_ordinal_to_read += 1;
5638            if next_offset >= end_offset {
5639                return Ok(());
5640            }
5641
5642            // Decode unknown envelopes for gaps in ordinals.
5643            while _next_ordinal_to_read < 6 {
5644                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5645                _next_ordinal_to_read += 1;
5646                next_offset += envelope_size;
5647            }
5648
5649            let next_out_of_line = decoder.next_out_of_line();
5650            let handles_before = decoder.remaining_handles();
5651            if let Some((inlined, num_bytes, num_handles)) =
5652                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5653            {
5654                let member_inline_size =
5655                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5656                if inlined != (member_inline_size <= 4) {
5657                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5658                }
5659                let inner_offset;
5660                let mut inner_depth = depth.clone();
5661                if inlined {
5662                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5663                    inner_offset = next_offset;
5664                } else {
5665                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5666                    inner_depth.increment()?;
5667                }
5668                let val_ref =
5669                    self.persistent_storage.get_or_insert_with(|| fidl::new_empty!(bool, D));
5670                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5671                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5672                {
5673                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5674                }
5675                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5676                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5677                }
5678            }
5679
5680            next_offset += envelope_size;
5681
5682            // Decode the remaining unknown envelopes.
5683            while next_offset < end_offset {
5684                _next_ordinal_to_read += 1;
5685                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5686                next_offset += envelope_size;
5687            }
5688
5689            Ok(())
5690        }
5691    }
5692
5693    impl Component {
5694        #[inline(always)]
5695        fn max_ordinal_present(&self) -> u64 {
5696            if let Some(_) = self.config {
5697                return 10;
5698            }
5699            if let Some(_) = self.facets {
5700                return 9;
5701            }
5702            if let Some(_) = self.environments {
5703                return 8;
5704            }
5705            if let Some(_) = self.collections {
5706                return 7;
5707            }
5708            if let Some(_) = self.children {
5709                return 6;
5710            }
5711            if let Some(_) = self.capabilities {
5712                return 5;
5713            }
5714            if let Some(_) = self.offers {
5715                return 4;
5716            }
5717            if let Some(_) = self.exposes {
5718                return 3;
5719            }
5720            if let Some(_) = self.uses {
5721                return 2;
5722            }
5723            if let Some(_) = self.program {
5724                return 1;
5725            }
5726            0
5727        }
5728    }
5729
5730    impl fidl::encoding::ValueTypeMarker for Component {
5731        type Borrowed<'a> = &'a Self;
5732        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5733            value
5734        }
5735    }
5736
5737    unsafe impl fidl::encoding::TypeMarker for Component {
5738        type Owned = Self;
5739
5740        #[inline(always)]
5741        fn inline_align(_context: fidl::encoding::Context) -> usize {
5742            8
5743        }
5744
5745        #[inline(always)]
5746        fn inline_size(_context: fidl::encoding::Context) -> usize {
5747            16
5748        }
5749    }
5750
5751    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Component, D>
5752        for &Component
5753    {
5754        unsafe fn encode(
5755            self,
5756            encoder: &mut fidl::encoding::Encoder<'_, D>,
5757            offset: usize,
5758            mut depth: fidl::encoding::Depth,
5759        ) -> fidl::Result<()> {
5760            encoder.debug_check_bounds::<Component>(offset);
5761            // Vector header
5762            let max_ordinal: u64 = self.max_ordinal_present();
5763            encoder.write_num(max_ordinal, offset);
5764            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5765            // Calling encoder.out_of_line_offset(0) is not allowed.
5766            if max_ordinal == 0 {
5767                return Ok(());
5768            }
5769            depth.increment()?;
5770            let envelope_size = 8;
5771            let bytes_len = max_ordinal as usize * envelope_size;
5772            #[allow(unused_variables)]
5773            let offset = encoder.out_of_line_offset(bytes_len);
5774            let mut _prev_end_offset: usize = 0;
5775            if 1 > max_ordinal {
5776                return Ok(());
5777            }
5778
5779            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5780            // are envelope_size bytes.
5781            let cur_offset: usize = (1 - 1) * envelope_size;
5782
5783            // Zero reserved fields.
5784            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5785
5786            // Safety:
5787            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5788            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5789            //   envelope_size bytes, there is always sufficient room.
5790            fidl::encoding::encode_in_envelope_optional::<Program, D>(
5791                self.program.as_ref().map(<Program as fidl::encoding::ValueTypeMarker>::borrow),
5792                encoder,
5793                offset + cur_offset,
5794                depth,
5795            )?;
5796
5797            _prev_end_offset = cur_offset + envelope_size;
5798            if 2 > max_ordinal {
5799                return Ok(());
5800            }
5801
5802            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5803            // are envelope_size bytes.
5804            let cur_offset: usize = (2 - 1) * envelope_size;
5805
5806            // Zero reserved fields.
5807            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5808
5809            // Safety:
5810            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5811            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5812            //   envelope_size bytes, there is always sufficient room.
5813            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Use>, D>(
5814            self.uses.as_ref().map(<fidl::encoding::UnboundedVector<Use> as fidl::encoding::ValueTypeMarker>::borrow),
5815            encoder, offset + cur_offset, depth
5816        )?;
5817
5818            _prev_end_offset = cur_offset + envelope_size;
5819            if 3 > max_ordinal {
5820                return Ok(());
5821            }
5822
5823            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5824            // are envelope_size bytes.
5825            let cur_offset: usize = (3 - 1) * envelope_size;
5826
5827            // Zero reserved fields.
5828            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5829
5830            // Safety:
5831            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5832            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5833            //   envelope_size bytes, there is always sufficient room.
5834            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Expose>, D>(
5835            self.exposes.as_ref().map(<fidl::encoding::UnboundedVector<Expose> as fidl::encoding::ValueTypeMarker>::borrow),
5836            encoder, offset + cur_offset, depth
5837        )?;
5838
5839            _prev_end_offset = cur_offset + envelope_size;
5840            if 4 > max_ordinal {
5841                return Ok(());
5842            }
5843
5844            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5845            // are envelope_size bytes.
5846            let cur_offset: usize = (4 - 1) * envelope_size;
5847
5848            // Zero reserved fields.
5849            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5850
5851            // Safety:
5852            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5853            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5854            //   envelope_size bytes, there is always sufficient room.
5855            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Offer>, D>(
5856            self.offers.as_ref().map(<fidl::encoding::UnboundedVector<Offer> as fidl::encoding::ValueTypeMarker>::borrow),
5857            encoder, offset + cur_offset, depth
5858        )?;
5859
5860            _prev_end_offset = cur_offset + envelope_size;
5861            if 5 > max_ordinal {
5862                return Ok(());
5863            }
5864
5865            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5866            // are envelope_size bytes.
5867            let cur_offset: usize = (5 - 1) * envelope_size;
5868
5869            // Zero reserved fields.
5870            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5871
5872            // Safety:
5873            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5874            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5875            //   envelope_size bytes, there is always sufficient room.
5876            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Capability>, D>(
5877            self.capabilities.as_ref().map(<fidl::encoding::UnboundedVector<Capability> as fidl::encoding::ValueTypeMarker>::borrow),
5878            encoder, offset + cur_offset, depth
5879        )?;
5880
5881            _prev_end_offset = cur_offset + envelope_size;
5882            if 6 > max_ordinal {
5883                return Ok(());
5884            }
5885
5886            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5887            // are envelope_size bytes.
5888            let cur_offset: usize = (6 - 1) * envelope_size;
5889
5890            // Zero reserved fields.
5891            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5892
5893            // Safety:
5894            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5895            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5896            //   envelope_size bytes, there is always sufficient room.
5897            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Child>, D>(
5898            self.children.as_ref().map(<fidl::encoding::UnboundedVector<Child> as fidl::encoding::ValueTypeMarker>::borrow),
5899            encoder, offset + cur_offset, depth
5900        )?;
5901
5902            _prev_end_offset = cur_offset + envelope_size;
5903            if 7 > max_ordinal {
5904                return Ok(());
5905            }
5906
5907            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5908            // are envelope_size bytes.
5909            let cur_offset: usize = (7 - 1) * envelope_size;
5910
5911            // Zero reserved fields.
5912            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5913
5914            // Safety:
5915            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5916            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5917            //   envelope_size bytes, there is always sufficient room.
5918            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Collection>, D>(
5919            self.collections.as_ref().map(<fidl::encoding::UnboundedVector<Collection> as fidl::encoding::ValueTypeMarker>::borrow),
5920            encoder, offset + cur_offset, depth
5921        )?;
5922
5923            _prev_end_offset = cur_offset + envelope_size;
5924            if 8 > max_ordinal {
5925                return Ok(());
5926            }
5927
5928            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5929            // are envelope_size bytes.
5930            let cur_offset: usize = (8 - 1) * envelope_size;
5931
5932            // Zero reserved fields.
5933            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5934
5935            // Safety:
5936            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5937            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5938            //   envelope_size bytes, there is always sufficient room.
5939            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Environment>, D>(
5940            self.environments.as_ref().map(<fidl::encoding::UnboundedVector<Environment> as fidl::encoding::ValueTypeMarker>::borrow),
5941            encoder, offset + cur_offset, depth
5942        )?;
5943
5944            _prev_end_offset = cur_offset + envelope_size;
5945            if 9 > max_ordinal {
5946                return Ok(());
5947            }
5948
5949            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5950            // are envelope_size bytes.
5951            let cur_offset: usize = (9 - 1) * envelope_size;
5952
5953            // Zero reserved fields.
5954            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5955
5956            // Safety:
5957            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5958            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5959            //   envelope_size bytes, there is always sufficient room.
5960            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_data__common::Dictionary, D>(
5961            self.facets.as_ref().map(<fidl_fuchsia_data__common::Dictionary as fidl::encoding::ValueTypeMarker>::borrow),
5962            encoder, offset + cur_offset, depth
5963        )?;
5964
5965            _prev_end_offset = cur_offset + envelope_size;
5966            if 10 > max_ordinal {
5967                return Ok(());
5968            }
5969
5970            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5971            // are envelope_size bytes.
5972            let cur_offset: usize = (10 - 1) * envelope_size;
5973
5974            // Zero reserved fields.
5975            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5976
5977            // Safety:
5978            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5979            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5980            //   envelope_size bytes, there is always sufficient room.
5981            fidl::encoding::encode_in_envelope_optional::<ConfigSchema, D>(
5982                self.config.as_ref().map(<ConfigSchema as fidl::encoding::ValueTypeMarker>::borrow),
5983                encoder,
5984                offset + cur_offset,
5985                depth,
5986            )?;
5987
5988            _prev_end_offset = cur_offset + envelope_size;
5989
5990            Ok(())
5991        }
5992    }
5993
5994    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Component {
5995        #[inline(always)]
5996        fn new_empty() -> Self {
5997            Self::default()
5998        }
5999
6000        unsafe fn decode(
6001            &mut self,
6002            decoder: &mut fidl::encoding::Decoder<'_, D>,
6003            offset: usize,
6004            mut depth: fidl::encoding::Depth,
6005        ) -> fidl::Result<()> {
6006            decoder.debug_check_bounds::<Self>(offset);
6007            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6008                None => return Err(fidl::Error::NotNullable),
6009                Some(len) => len,
6010            };
6011            // Calling decoder.out_of_line_offset(0) is not allowed.
6012            if len == 0 {
6013                return Ok(());
6014            };
6015            depth.increment()?;
6016            let envelope_size = 8;
6017            let bytes_len = len * envelope_size;
6018            let offset = decoder.out_of_line_offset(bytes_len)?;
6019            // Decode the envelope for each type.
6020            let mut _next_ordinal_to_read = 0;
6021            let mut next_offset = offset;
6022            let end_offset = offset + bytes_len;
6023            _next_ordinal_to_read += 1;
6024            if next_offset >= end_offset {
6025                return Ok(());
6026            }
6027
6028            // Decode unknown envelopes for gaps in ordinals.
6029            while _next_ordinal_to_read < 1 {
6030                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6031                _next_ordinal_to_read += 1;
6032                next_offset += envelope_size;
6033            }
6034
6035            let next_out_of_line = decoder.next_out_of_line();
6036            let handles_before = decoder.remaining_handles();
6037            if let Some((inlined, num_bytes, num_handles)) =
6038                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6039            {
6040                let member_inline_size =
6041                    <Program as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6042                if inlined != (member_inline_size <= 4) {
6043                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6044                }
6045                let inner_offset;
6046                let mut inner_depth = depth.clone();
6047                if inlined {
6048                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6049                    inner_offset = next_offset;
6050                } else {
6051                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6052                    inner_depth.increment()?;
6053                }
6054                let val_ref = self.program.get_or_insert_with(|| fidl::new_empty!(Program, D));
6055                fidl::decode!(Program, D, val_ref, decoder, inner_offset, inner_depth)?;
6056                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6057                {
6058                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6059                }
6060                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6061                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6062                }
6063            }
6064
6065            next_offset += envelope_size;
6066            _next_ordinal_to_read += 1;
6067            if next_offset >= end_offset {
6068                return Ok(());
6069            }
6070
6071            // Decode unknown envelopes for gaps in ordinals.
6072            while _next_ordinal_to_read < 2 {
6073                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6074                _next_ordinal_to_read += 1;
6075                next_offset += envelope_size;
6076            }
6077
6078            let next_out_of_line = decoder.next_out_of_line();
6079            let handles_before = decoder.remaining_handles();
6080            if let Some((inlined, num_bytes, num_handles)) =
6081                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6082            {
6083                let member_inline_size = <fidl::encoding::UnboundedVector<Use> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6084                if inlined != (member_inline_size <= 4) {
6085                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6086                }
6087                let inner_offset;
6088                let mut inner_depth = depth.clone();
6089                if inlined {
6090                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6091                    inner_offset = next_offset;
6092                } else {
6093                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6094                    inner_depth.increment()?;
6095                }
6096                let val_ref = self.uses.get_or_insert_with(|| {
6097                    fidl::new_empty!(fidl::encoding::UnboundedVector<Use>, D)
6098                });
6099                fidl::decode!(
6100                    fidl::encoding::UnboundedVector<Use>,
6101                    D,
6102                    val_ref,
6103                    decoder,
6104                    inner_offset,
6105                    inner_depth
6106                )?;
6107                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6108                {
6109                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6110                }
6111                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6112                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6113                }
6114            }
6115
6116            next_offset += envelope_size;
6117            _next_ordinal_to_read += 1;
6118            if next_offset >= end_offset {
6119                return Ok(());
6120            }
6121
6122            // Decode unknown envelopes for gaps in ordinals.
6123            while _next_ordinal_to_read < 3 {
6124                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6125                _next_ordinal_to_read += 1;
6126                next_offset += envelope_size;
6127            }
6128
6129            let next_out_of_line = decoder.next_out_of_line();
6130            let handles_before = decoder.remaining_handles();
6131            if let Some((inlined, num_bytes, num_handles)) =
6132                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6133            {
6134                let member_inline_size = <fidl::encoding::UnboundedVector<Expose> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6135                if inlined != (member_inline_size <= 4) {
6136                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6137                }
6138                let inner_offset;
6139                let mut inner_depth = depth.clone();
6140                if inlined {
6141                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6142                    inner_offset = next_offset;
6143                } else {
6144                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6145                    inner_depth.increment()?;
6146                }
6147                let val_ref = self.exposes.get_or_insert_with(|| {
6148                    fidl::new_empty!(fidl::encoding::UnboundedVector<Expose>, D)
6149                });
6150                fidl::decode!(
6151                    fidl::encoding::UnboundedVector<Expose>,
6152                    D,
6153                    val_ref,
6154                    decoder,
6155                    inner_offset,
6156                    inner_depth
6157                )?;
6158                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6159                {
6160                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6161                }
6162                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6163                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6164                }
6165            }
6166
6167            next_offset += envelope_size;
6168            _next_ordinal_to_read += 1;
6169            if next_offset >= end_offset {
6170                return Ok(());
6171            }
6172
6173            // Decode unknown envelopes for gaps in ordinals.
6174            while _next_ordinal_to_read < 4 {
6175                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6176                _next_ordinal_to_read += 1;
6177                next_offset += envelope_size;
6178            }
6179
6180            let next_out_of_line = decoder.next_out_of_line();
6181            let handles_before = decoder.remaining_handles();
6182            if let Some((inlined, num_bytes, num_handles)) =
6183                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6184            {
6185                let member_inline_size = <fidl::encoding::UnboundedVector<Offer> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6186                if inlined != (member_inline_size <= 4) {
6187                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6188                }
6189                let inner_offset;
6190                let mut inner_depth = depth.clone();
6191                if inlined {
6192                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6193                    inner_offset = next_offset;
6194                } else {
6195                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6196                    inner_depth.increment()?;
6197                }
6198                let val_ref = self.offers.get_or_insert_with(|| {
6199                    fidl::new_empty!(fidl::encoding::UnboundedVector<Offer>, D)
6200                });
6201                fidl::decode!(
6202                    fidl::encoding::UnboundedVector<Offer>,
6203                    D,
6204                    val_ref,
6205                    decoder,
6206                    inner_offset,
6207                    inner_depth
6208                )?;
6209                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6210                {
6211                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6212                }
6213                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6214                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6215                }
6216            }
6217
6218            next_offset += envelope_size;
6219            _next_ordinal_to_read += 1;
6220            if next_offset >= end_offset {
6221                return Ok(());
6222            }
6223
6224            // Decode unknown envelopes for gaps in ordinals.
6225            while _next_ordinal_to_read < 5 {
6226                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6227                _next_ordinal_to_read += 1;
6228                next_offset += envelope_size;
6229            }
6230
6231            let next_out_of_line = decoder.next_out_of_line();
6232            let handles_before = decoder.remaining_handles();
6233            if let Some((inlined, num_bytes, num_handles)) =
6234                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6235            {
6236                let member_inline_size = <fidl::encoding::UnboundedVector<Capability> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6237                if inlined != (member_inline_size <= 4) {
6238                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6239                }
6240                let inner_offset;
6241                let mut inner_depth = depth.clone();
6242                if inlined {
6243                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6244                    inner_offset = next_offset;
6245                } else {
6246                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6247                    inner_depth.increment()?;
6248                }
6249                let val_ref = self.capabilities.get_or_insert_with(|| {
6250                    fidl::new_empty!(fidl::encoding::UnboundedVector<Capability>, D)
6251                });
6252                fidl::decode!(
6253                    fidl::encoding::UnboundedVector<Capability>,
6254                    D,
6255                    val_ref,
6256                    decoder,
6257                    inner_offset,
6258                    inner_depth
6259                )?;
6260                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6261                {
6262                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6263                }
6264                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6265                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6266                }
6267            }
6268
6269            next_offset += envelope_size;
6270            _next_ordinal_to_read += 1;
6271            if next_offset >= end_offset {
6272                return Ok(());
6273            }
6274
6275            // Decode unknown envelopes for gaps in ordinals.
6276            while _next_ordinal_to_read < 6 {
6277                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6278                _next_ordinal_to_read += 1;
6279                next_offset += envelope_size;
6280            }
6281
6282            let next_out_of_line = decoder.next_out_of_line();
6283            let handles_before = decoder.remaining_handles();
6284            if let Some((inlined, num_bytes, num_handles)) =
6285                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6286            {
6287                let member_inline_size = <fidl::encoding::UnboundedVector<Child> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6288                if inlined != (member_inline_size <= 4) {
6289                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6290                }
6291                let inner_offset;
6292                let mut inner_depth = depth.clone();
6293                if inlined {
6294                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6295                    inner_offset = next_offset;
6296                } else {
6297                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6298                    inner_depth.increment()?;
6299                }
6300                let val_ref = self.children.get_or_insert_with(|| {
6301                    fidl::new_empty!(fidl::encoding::UnboundedVector<Child>, D)
6302                });
6303                fidl::decode!(
6304                    fidl::encoding::UnboundedVector<Child>,
6305                    D,
6306                    val_ref,
6307                    decoder,
6308                    inner_offset,
6309                    inner_depth
6310                )?;
6311                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6312                {
6313                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6314                }
6315                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6316                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6317                }
6318            }
6319
6320            next_offset += envelope_size;
6321            _next_ordinal_to_read += 1;
6322            if next_offset >= end_offset {
6323                return Ok(());
6324            }
6325
6326            // Decode unknown envelopes for gaps in ordinals.
6327            while _next_ordinal_to_read < 7 {
6328                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6329                _next_ordinal_to_read += 1;
6330                next_offset += envelope_size;
6331            }
6332
6333            let next_out_of_line = decoder.next_out_of_line();
6334            let handles_before = decoder.remaining_handles();
6335            if let Some((inlined, num_bytes, num_handles)) =
6336                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6337            {
6338                let member_inline_size = <fidl::encoding::UnboundedVector<Collection> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6339                if inlined != (member_inline_size <= 4) {
6340                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6341                }
6342                let inner_offset;
6343                let mut inner_depth = depth.clone();
6344                if inlined {
6345                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6346                    inner_offset = next_offset;
6347                } else {
6348                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6349                    inner_depth.increment()?;
6350                }
6351                let val_ref = self.collections.get_or_insert_with(|| {
6352                    fidl::new_empty!(fidl::encoding::UnboundedVector<Collection>, D)
6353                });
6354                fidl::decode!(
6355                    fidl::encoding::UnboundedVector<Collection>,
6356                    D,
6357                    val_ref,
6358                    decoder,
6359                    inner_offset,
6360                    inner_depth
6361                )?;
6362                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6363                {
6364                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6365                }
6366                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6367                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6368                }
6369            }
6370
6371            next_offset += envelope_size;
6372            _next_ordinal_to_read += 1;
6373            if next_offset >= end_offset {
6374                return Ok(());
6375            }
6376
6377            // Decode unknown envelopes for gaps in ordinals.
6378            while _next_ordinal_to_read < 8 {
6379                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6380                _next_ordinal_to_read += 1;
6381                next_offset += envelope_size;
6382            }
6383
6384            let next_out_of_line = decoder.next_out_of_line();
6385            let handles_before = decoder.remaining_handles();
6386            if let Some((inlined, num_bytes, num_handles)) =
6387                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6388            {
6389                let member_inline_size = <fidl::encoding::UnboundedVector<Environment> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6390                if inlined != (member_inline_size <= 4) {
6391                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6392                }
6393                let inner_offset;
6394                let mut inner_depth = depth.clone();
6395                if inlined {
6396                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6397                    inner_offset = next_offset;
6398                } else {
6399                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6400                    inner_depth.increment()?;
6401                }
6402                let val_ref = self.environments.get_or_insert_with(|| {
6403                    fidl::new_empty!(fidl::encoding::UnboundedVector<Environment>, D)
6404                });
6405                fidl::decode!(
6406                    fidl::encoding::UnboundedVector<Environment>,
6407                    D,
6408                    val_ref,
6409                    decoder,
6410                    inner_offset,
6411                    inner_depth
6412                )?;
6413                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6414                {
6415                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6416                }
6417                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6418                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6419                }
6420            }
6421
6422            next_offset += envelope_size;
6423            _next_ordinal_to_read += 1;
6424            if next_offset >= end_offset {
6425                return Ok(());
6426            }
6427
6428            // Decode unknown envelopes for gaps in ordinals.
6429            while _next_ordinal_to_read < 9 {
6430                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6431                _next_ordinal_to_read += 1;
6432                next_offset += envelope_size;
6433            }
6434
6435            let next_out_of_line = decoder.next_out_of_line();
6436            let handles_before = decoder.remaining_handles();
6437            if let Some((inlined, num_bytes, num_handles)) =
6438                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6439            {
6440                let member_inline_size = <fidl_fuchsia_data__common::Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6441                if inlined != (member_inline_size <= 4) {
6442                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6443                }
6444                let inner_offset;
6445                let mut inner_depth = depth.clone();
6446                if inlined {
6447                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6448                    inner_offset = next_offset;
6449                } else {
6450                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6451                    inner_depth.increment()?;
6452                }
6453                let val_ref = self.facets.get_or_insert_with(|| {
6454                    fidl::new_empty!(fidl_fuchsia_data__common::Dictionary, D)
6455                });
6456                fidl::decode!(
6457                    fidl_fuchsia_data__common::Dictionary,
6458                    D,
6459                    val_ref,
6460                    decoder,
6461                    inner_offset,
6462                    inner_depth
6463                )?;
6464                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6465                {
6466                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6467                }
6468                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6469                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6470                }
6471            }
6472
6473            next_offset += envelope_size;
6474            _next_ordinal_to_read += 1;
6475            if next_offset >= end_offset {
6476                return Ok(());
6477            }
6478
6479            // Decode unknown envelopes for gaps in ordinals.
6480            while _next_ordinal_to_read < 10 {
6481                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6482                _next_ordinal_to_read += 1;
6483                next_offset += envelope_size;
6484            }
6485
6486            let next_out_of_line = decoder.next_out_of_line();
6487            let handles_before = decoder.remaining_handles();
6488            if let Some((inlined, num_bytes, num_handles)) =
6489                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6490            {
6491                let member_inline_size =
6492                    <ConfigSchema as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6493                if inlined != (member_inline_size <= 4) {
6494                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6495                }
6496                let inner_offset;
6497                let mut inner_depth = depth.clone();
6498                if inlined {
6499                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6500                    inner_offset = next_offset;
6501                } else {
6502                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6503                    inner_depth.increment()?;
6504                }
6505                let val_ref = self.config.get_or_insert_with(|| fidl::new_empty!(ConfigSchema, D));
6506                fidl::decode!(ConfigSchema, D, val_ref, decoder, inner_offset, inner_depth)?;
6507                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6508                {
6509                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6510                }
6511                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6512                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6513                }
6514            }
6515
6516            next_offset += envelope_size;
6517
6518            // Decode the remaining unknown envelopes.
6519            while next_offset < end_offset {
6520                _next_ordinal_to_read += 1;
6521                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6522                next_offset += envelope_size;
6523            }
6524
6525            Ok(())
6526        }
6527    }
6528
6529    impl ConfigField {
6530        #[inline(always)]
6531        fn max_ordinal_present(&self) -> u64 {
6532            if let Some(_) = self.mutability {
6533                return 3;
6534            }
6535            if let Some(_) = self.type_ {
6536                return 2;
6537            }
6538            if let Some(_) = self.key {
6539                return 1;
6540            }
6541            0
6542        }
6543    }
6544
6545    impl fidl::encoding::ValueTypeMarker for ConfigField {
6546        type Borrowed<'a> = &'a Self;
6547        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6548            value
6549        }
6550    }
6551
6552    unsafe impl fidl::encoding::TypeMarker for ConfigField {
6553        type Owned = Self;
6554
6555        #[inline(always)]
6556        fn inline_align(_context: fidl::encoding::Context) -> usize {
6557            8
6558        }
6559
6560        #[inline(always)]
6561        fn inline_size(_context: fidl::encoding::Context) -> usize {
6562            16
6563        }
6564    }
6565
6566    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigField, D>
6567        for &ConfigField
6568    {
6569        unsafe fn encode(
6570            self,
6571            encoder: &mut fidl::encoding::Encoder<'_, D>,
6572            offset: usize,
6573            mut depth: fidl::encoding::Depth,
6574        ) -> fidl::Result<()> {
6575            encoder.debug_check_bounds::<ConfigField>(offset);
6576            // Vector header
6577            let max_ordinal: u64 = self.max_ordinal_present();
6578            encoder.write_num(max_ordinal, offset);
6579            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6580            // Calling encoder.out_of_line_offset(0) is not allowed.
6581            if max_ordinal == 0 {
6582                return Ok(());
6583            }
6584            depth.increment()?;
6585            let envelope_size = 8;
6586            let bytes_len = max_ordinal as usize * envelope_size;
6587            #[allow(unused_variables)]
6588            let offset = encoder.out_of_line_offset(bytes_len);
6589            let mut _prev_end_offset: usize = 0;
6590            if 1 > max_ordinal {
6591                return Ok(());
6592            }
6593
6594            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6595            // are envelope_size bytes.
6596            let cur_offset: usize = (1 - 1) * envelope_size;
6597
6598            // Zero reserved fields.
6599            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6600
6601            // Safety:
6602            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6603            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6604            //   envelope_size bytes, there is always sufficient room.
6605            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
6606                self.key.as_ref().map(
6607                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
6608                ),
6609                encoder,
6610                offset + cur_offset,
6611                depth,
6612            )?;
6613
6614            _prev_end_offset = cur_offset + envelope_size;
6615            if 2 > max_ordinal {
6616                return Ok(());
6617            }
6618
6619            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6620            // are envelope_size bytes.
6621            let cur_offset: usize = (2 - 1) * envelope_size;
6622
6623            // Zero reserved fields.
6624            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6625
6626            // Safety:
6627            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6628            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6629            //   envelope_size bytes, there is always sufficient room.
6630            fidl::encoding::encode_in_envelope_optional::<ConfigType, D>(
6631                self.type_.as_ref().map(<ConfigType as fidl::encoding::ValueTypeMarker>::borrow),
6632                encoder,
6633                offset + cur_offset,
6634                depth,
6635            )?;
6636
6637            _prev_end_offset = cur_offset + envelope_size;
6638            if 3 > max_ordinal {
6639                return Ok(());
6640            }
6641
6642            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6643            // are envelope_size bytes.
6644            let cur_offset: usize = (3 - 1) * envelope_size;
6645
6646            // Zero reserved fields.
6647            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6648
6649            // Safety:
6650            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6651            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6652            //   envelope_size bytes, there is always sufficient room.
6653            fidl::encoding::encode_in_envelope_optional::<ConfigMutability, D>(
6654                self.mutability
6655                    .as_ref()
6656                    .map(<ConfigMutability as fidl::encoding::ValueTypeMarker>::borrow),
6657                encoder,
6658                offset + cur_offset,
6659                depth,
6660            )?;
6661
6662            _prev_end_offset = cur_offset + envelope_size;
6663
6664            Ok(())
6665        }
6666    }
6667
6668    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigField {
6669        #[inline(always)]
6670        fn new_empty() -> Self {
6671            Self::default()
6672        }
6673
6674        unsafe fn decode(
6675            &mut self,
6676            decoder: &mut fidl::encoding::Decoder<'_, D>,
6677            offset: usize,
6678            mut depth: fidl::encoding::Depth,
6679        ) -> fidl::Result<()> {
6680            decoder.debug_check_bounds::<Self>(offset);
6681            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6682                None => return Err(fidl::Error::NotNullable),
6683                Some(len) => len,
6684            };
6685            // Calling decoder.out_of_line_offset(0) is not allowed.
6686            if len == 0 {
6687                return Ok(());
6688            };
6689            depth.increment()?;
6690            let envelope_size = 8;
6691            let bytes_len = len * envelope_size;
6692            let offset = decoder.out_of_line_offset(bytes_len)?;
6693            // Decode the envelope for each type.
6694            let mut _next_ordinal_to_read = 0;
6695            let mut next_offset = offset;
6696            let end_offset = offset + bytes_len;
6697            _next_ordinal_to_read += 1;
6698            if next_offset >= end_offset {
6699                return Ok(());
6700            }
6701
6702            // Decode unknown envelopes for gaps in ordinals.
6703            while _next_ordinal_to_read < 1 {
6704                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6705                _next_ordinal_to_read += 1;
6706                next_offset += envelope_size;
6707            }
6708
6709            let next_out_of_line = decoder.next_out_of_line();
6710            let handles_before = decoder.remaining_handles();
6711            if let Some((inlined, num_bytes, num_handles)) =
6712                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6713            {
6714                let member_inline_size =
6715                    <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
6716                        decoder.context,
6717                    );
6718                if inlined != (member_inline_size <= 4) {
6719                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6720                }
6721                let inner_offset;
6722                let mut inner_depth = depth.clone();
6723                if inlined {
6724                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6725                    inner_offset = next_offset;
6726                } else {
6727                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6728                    inner_depth.increment()?;
6729                }
6730                let val_ref = self
6731                    .key
6732                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
6733                fidl::decode!(
6734                    fidl::encoding::BoundedString<64>,
6735                    D,
6736                    val_ref,
6737                    decoder,
6738                    inner_offset,
6739                    inner_depth
6740                )?;
6741                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6742                {
6743                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6744                }
6745                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6746                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6747                }
6748            }
6749
6750            next_offset += envelope_size;
6751            _next_ordinal_to_read += 1;
6752            if next_offset >= end_offset {
6753                return Ok(());
6754            }
6755
6756            // Decode unknown envelopes for gaps in ordinals.
6757            while _next_ordinal_to_read < 2 {
6758                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6759                _next_ordinal_to_read += 1;
6760                next_offset += envelope_size;
6761            }
6762
6763            let next_out_of_line = decoder.next_out_of_line();
6764            let handles_before = decoder.remaining_handles();
6765            if let Some((inlined, num_bytes, num_handles)) =
6766                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6767            {
6768                let member_inline_size =
6769                    <ConfigType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6770                if inlined != (member_inline_size <= 4) {
6771                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6772                }
6773                let inner_offset;
6774                let mut inner_depth = depth.clone();
6775                if inlined {
6776                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6777                    inner_offset = next_offset;
6778                } else {
6779                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6780                    inner_depth.increment()?;
6781                }
6782                let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(ConfigType, D));
6783                fidl::decode!(ConfigType, D, val_ref, decoder, inner_offset, inner_depth)?;
6784                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6785                {
6786                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6787                }
6788                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6789                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6790                }
6791            }
6792
6793            next_offset += envelope_size;
6794            _next_ordinal_to_read += 1;
6795            if next_offset >= end_offset {
6796                return Ok(());
6797            }
6798
6799            // Decode unknown envelopes for gaps in ordinals.
6800            while _next_ordinal_to_read < 3 {
6801                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6802                _next_ordinal_to_read += 1;
6803                next_offset += envelope_size;
6804            }
6805
6806            let next_out_of_line = decoder.next_out_of_line();
6807            let handles_before = decoder.remaining_handles();
6808            if let Some((inlined, num_bytes, num_handles)) =
6809                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6810            {
6811                let member_inline_size =
6812                    <ConfigMutability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6813                if inlined != (member_inline_size <= 4) {
6814                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6815                }
6816                let inner_offset;
6817                let mut inner_depth = depth.clone();
6818                if inlined {
6819                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6820                    inner_offset = next_offset;
6821                } else {
6822                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6823                    inner_depth.increment()?;
6824                }
6825                let val_ref =
6826                    self.mutability.get_or_insert_with(|| fidl::new_empty!(ConfigMutability, D));
6827                fidl::decode!(ConfigMutability, D, val_ref, decoder, inner_offset, inner_depth)?;
6828                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6829                {
6830                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6831                }
6832                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6833                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6834                }
6835            }
6836
6837            next_offset += envelope_size;
6838
6839            // Decode the remaining unknown envelopes.
6840            while next_offset < end_offset {
6841                _next_ordinal_to_read += 1;
6842                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6843                next_offset += envelope_size;
6844            }
6845
6846            Ok(())
6847        }
6848    }
6849
6850    impl ConfigOverride {
6851        #[inline(always)]
6852        fn max_ordinal_present(&self) -> u64 {
6853            if let Some(_) = self.value {
6854                return 2;
6855            }
6856            if let Some(_) = self.key {
6857                return 1;
6858            }
6859            0
6860        }
6861    }
6862
6863    impl fidl::encoding::ValueTypeMarker for ConfigOverride {
6864        type Borrowed<'a> = &'a Self;
6865        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6866            value
6867        }
6868    }
6869
6870    unsafe impl fidl::encoding::TypeMarker for ConfigOverride {
6871        type Owned = Self;
6872
6873        #[inline(always)]
6874        fn inline_align(_context: fidl::encoding::Context) -> usize {
6875            8
6876        }
6877
6878        #[inline(always)]
6879        fn inline_size(_context: fidl::encoding::Context) -> usize {
6880            16
6881        }
6882    }
6883
6884    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigOverride, D>
6885        for &ConfigOverride
6886    {
6887        unsafe fn encode(
6888            self,
6889            encoder: &mut fidl::encoding::Encoder<'_, D>,
6890            offset: usize,
6891            mut depth: fidl::encoding::Depth,
6892        ) -> fidl::Result<()> {
6893            encoder.debug_check_bounds::<ConfigOverride>(offset);
6894            // Vector header
6895            let max_ordinal: u64 = self.max_ordinal_present();
6896            encoder.write_num(max_ordinal, offset);
6897            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6898            // Calling encoder.out_of_line_offset(0) is not allowed.
6899            if max_ordinal == 0 {
6900                return Ok(());
6901            }
6902            depth.increment()?;
6903            let envelope_size = 8;
6904            let bytes_len = max_ordinal as usize * envelope_size;
6905            #[allow(unused_variables)]
6906            let offset = encoder.out_of_line_offset(bytes_len);
6907            let mut _prev_end_offset: usize = 0;
6908            if 1 > max_ordinal {
6909                return Ok(());
6910            }
6911
6912            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6913            // are envelope_size bytes.
6914            let cur_offset: usize = (1 - 1) * envelope_size;
6915
6916            // Zero reserved fields.
6917            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6918
6919            // Safety:
6920            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6921            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6922            //   envelope_size bytes, there is always sufficient room.
6923            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
6924                self.key.as_ref().map(
6925                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
6926                ),
6927                encoder,
6928                offset + cur_offset,
6929                depth,
6930            )?;
6931
6932            _prev_end_offset = cur_offset + envelope_size;
6933            if 2 > max_ordinal {
6934                return Ok(());
6935            }
6936
6937            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6938            // are envelope_size bytes.
6939            let cur_offset: usize = (2 - 1) * envelope_size;
6940
6941            // Zero reserved fields.
6942            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6943
6944            // Safety:
6945            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6946            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6947            //   envelope_size bytes, there is always sufficient room.
6948            fidl::encoding::encode_in_envelope_optional::<ConfigValue, D>(
6949                self.value.as_ref().map(<ConfigValue as fidl::encoding::ValueTypeMarker>::borrow),
6950                encoder,
6951                offset + cur_offset,
6952                depth,
6953            )?;
6954
6955            _prev_end_offset = cur_offset + envelope_size;
6956
6957            Ok(())
6958        }
6959    }
6960
6961    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigOverride {
6962        #[inline(always)]
6963        fn new_empty() -> Self {
6964            Self::default()
6965        }
6966
6967        unsafe fn decode(
6968            &mut self,
6969            decoder: &mut fidl::encoding::Decoder<'_, D>,
6970            offset: usize,
6971            mut depth: fidl::encoding::Depth,
6972        ) -> fidl::Result<()> {
6973            decoder.debug_check_bounds::<Self>(offset);
6974            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6975                None => return Err(fidl::Error::NotNullable),
6976                Some(len) => len,
6977            };
6978            // Calling decoder.out_of_line_offset(0) is not allowed.
6979            if len == 0 {
6980                return Ok(());
6981            };
6982            depth.increment()?;
6983            let envelope_size = 8;
6984            let bytes_len = len * envelope_size;
6985            let offset = decoder.out_of_line_offset(bytes_len)?;
6986            // Decode the envelope for each type.
6987            let mut _next_ordinal_to_read = 0;
6988            let mut next_offset = offset;
6989            let end_offset = offset + bytes_len;
6990            _next_ordinal_to_read += 1;
6991            if next_offset >= end_offset {
6992                return Ok(());
6993            }
6994
6995            // Decode unknown envelopes for gaps in ordinals.
6996            while _next_ordinal_to_read < 1 {
6997                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6998                _next_ordinal_to_read += 1;
6999                next_offset += envelope_size;
7000            }
7001
7002            let next_out_of_line = decoder.next_out_of_line();
7003            let handles_before = decoder.remaining_handles();
7004            if let Some((inlined, num_bytes, num_handles)) =
7005                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7006            {
7007                let member_inline_size =
7008                    <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
7009                        decoder.context,
7010                    );
7011                if inlined != (member_inline_size <= 4) {
7012                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7013                }
7014                let inner_offset;
7015                let mut inner_depth = depth.clone();
7016                if inlined {
7017                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7018                    inner_offset = next_offset;
7019                } else {
7020                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7021                    inner_depth.increment()?;
7022                }
7023                let val_ref = self
7024                    .key
7025                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
7026                fidl::decode!(
7027                    fidl::encoding::BoundedString<64>,
7028                    D,
7029                    val_ref,
7030                    decoder,
7031                    inner_offset,
7032                    inner_depth
7033                )?;
7034                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7035                {
7036                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7037                }
7038                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7039                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7040                }
7041            }
7042
7043            next_offset += envelope_size;
7044            _next_ordinal_to_read += 1;
7045            if next_offset >= end_offset {
7046                return Ok(());
7047            }
7048
7049            // Decode unknown envelopes for gaps in ordinals.
7050            while _next_ordinal_to_read < 2 {
7051                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7052                _next_ordinal_to_read += 1;
7053                next_offset += envelope_size;
7054            }
7055
7056            let next_out_of_line = decoder.next_out_of_line();
7057            let handles_before = decoder.remaining_handles();
7058            if let Some((inlined, num_bytes, num_handles)) =
7059                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7060            {
7061                let member_inline_size =
7062                    <ConfigValue as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7063                if inlined != (member_inline_size <= 4) {
7064                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7065                }
7066                let inner_offset;
7067                let mut inner_depth = depth.clone();
7068                if inlined {
7069                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7070                    inner_offset = next_offset;
7071                } else {
7072                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7073                    inner_depth.increment()?;
7074                }
7075                let val_ref = self.value.get_or_insert_with(|| fidl::new_empty!(ConfigValue, D));
7076                fidl::decode!(ConfigValue, D, val_ref, decoder, inner_offset, inner_depth)?;
7077                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7078                {
7079                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7080                }
7081                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7082                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7083                }
7084            }
7085
7086            next_offset += envelope_size;
7087
7088            // Decode the remaining unknown envelopes.
7089            while next_offset < end_offset {
7090                _next_ordinal_to_read += 1;
7091                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7092                next_offset += envelope_size;
7093            }
7094
7095            Ok(())
7096        }
7097    }
7098
7099    impl ConfigSchema {
7100        #[inline(always)]
7101        fn max_ordinal_present(&self) -> u64 {
7102            if let Some(_) = self.value_source {
7103                return 3;
7104            }
7105            if let Some(_) = self.checksum {
7106                return 2;
7107            }
7108            if let Some(_) = self.fields {
7109                return 1;
7110            }
7111            0
7112        }
7113    }
7114
7115    impl fidl::encoding::ValueTypeMarker for ConfigSchema {
7116        type Borrowed<'a> = &'a Self;
7117        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7118            value
7119        }
7120    }
7121
7122    unsafe impl fidl::encoding::TypeMarker for ConfigSchema {
7123        type Owned = Self;
7124
7125        #[inline(always)]
7126        fn inline_align(_context: fidl::encoding::Context) -> usize {
7127            8
7128        }
7129
7130        #[inline(always)]
7131        fn inline_size(_context: fidl::encoding::Context) -> usize {
7132            16
7133        }
7134    }
7135
7136    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigSchema, D>
7137        for &ConfigSchema
7138    {
7139        unsafe fn encode(
7140            self,
7141            encoder: &mut fidl::encoding::Encoder<'_, D>,
7142            offset: usize,
7143            mut depth: fidl::encoding::Depth,
7144        ) -> fidl::Result<()> {
7145            encoder.debug_check_bounds::<ConfigSchema>(offset);
7146            // Vector header
7147            let max_ordinal: u64 = self.max_ordinal_present();
7148            encoder.write_num(max_ordinal, offset);
7149            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7150            // Calling encoder.out_of_line_offset(0) is not allowed.
7151            if max_ordinal == 0 {
7152                return Ok(());
7153            }
7154            depth.increment()?;
7155            let envelope_size = 8;
7156            let bytes_len = max_ordinal as usize * envelope_size;
7157            #[allow(unused_variables)]
7158            let offset = encoder.out_of_line_offset(bytes_len);
7159            let mut _prev_end_offset: usize = 0;
7160            if 1 > max_ordinal {
7161                return Ok(());
7162            }
7163
7164            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7165            // are envelope_size bytes.
7166            let cur_offset: usize = (1 - 1) * envelope_size;
7167
7168            // Zero reserved fields.
7169            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7170
7171            // Safety:
7172            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7173            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7174            //   envelope_size bytes, there is always sufficient room.
7175            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ConfigField>, D>(
7176            self.fields.as_ref().map(<fidl::encoding::UnboundedVector<ConfigField> as fidl::encoding::ValueTypeMarker>::borrow),
7177            encoder, offset + cur_offset, depth
7178        )?;
7179
7180            _prev_end_offset = cur_offset + envelope_size;
7181            if 2 > max_ordinal {
7182                return Ok(());
7183            }
7184
7185            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7186            // are envelope_size bytes.
7187            let cur_offset: usize = (2 - 1) * envelope_size;
7188
7189            // Zero reserved fields.
7190            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7191
7192            // Safety:
7193            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7194            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7195            //   envelope_size bytes, there is always sufficient room.
7196            fidl::encoding::encode_in_envelope_optional::<ConfigChecksum, D>(
7197                self.checksum
7198                    .as_ref()
7199                    .map(<ConfigChecksum as fidl::encoding::ValueTypeMarker>::borrow),
7200                encoder,
7201                offset + cur_offset,
7202                depth,
7203            )?;
7204
7205            _prev_end_offset = cur_offset + envelope_size;
7206            if 3 > max_ordinal {
7207                return Ok(());
7208            }
7209
7210            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7211            // are envelope_size bytes.
7212            let cur_offset: usize = (3 - 1) * envelope_size;
7213
7214            // Zero reserved fields.
7215            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7216
7217            // Safety:
7218            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7219            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7220            //   envelope_size bytes, there is always sufficient room.
7221            fidl::encoding::encode_in_envelope_optional::<ConfigValueSource, D>(
7222                self.value_source
7223                    .as_ref()
7224                    .map(<ConfigValueSource as fidl::encoding::ValueTypeMarker>::borrow),
7225                encoder,
7226                offset + cur_offset,
7227                depth,
7228            )?;
7229
7230            _prev_end_offset = cur_offset + envelope_size;
7231
7232            Ok(())
7233        }
7234    }
7235
7236    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigSchema {
7237        #[inline(always)]
7238        fn new_empty() -> Self {
7239            Self::default()
7240        }
7241
7242        unsafe fn decode(
7243            &mut self,
7244            decoder: &mut fidl::encoding::Decoder<'_, D>,
7245            offset: usize,
7246            mut depth: fidl::encoding::Depth,
7247        ) -> fidl::Result<()> {
7248            decoder.debug_check_bounds::<Self>(offset);
7249            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7250                None => return Err(fidl::Error::NotNullable),
7251                Some(len) => len,
7252            };
7253            // Calling decoder.out_of_line_offset(0) is not allowed.
7254            if len == 0 {
7255                return Ok(());
7256            };
7257            depth.increment()?;
7258            let envelope_size = 8;
7259            let bytes_len = len * envelope_size;
7260            let offset = decoder.out_of_line_offset(bytes_len)?;
7261            // Decode the envelope for each type.
7262            let mut _next_ordinal_to_read = 0;
7263            let mut next_offset = offset;
7264            let end_offset = offset + bytes_len;
7265            _next_ordinal_to_read += 1;
7266            if next_offset >= end_offset {
7267                return Ok(());
7268            }
7269
7270            // Decode unknown envelopes for gaps in ordinals.
7271            while _next_ordinal_to_read < 1 {
7272                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7273                _next_ordinal_to_read += 1;
7274                next_offset += envelope_size;
7275            }
7276
7277            let next_out_of_line = decoder.next_out_of_line();
7278            let handles_before = decoder.remaining_handles();
7279            if let Some((inlined, num_bytes, num_handles)) =
7280                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7281            {
7282                let member_inline_size = <fidl::encoding::UnboundedVector<ConfigField> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7283                if inlined != (member_inline_size <= 4) {
7284                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7285                }
7286                let inner_offset;
7287                let mut inner_depth = depth.clone();
7288                if inlined {
7289                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7290                    inner_offset = next_offset;
7291                } else {
7292                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7293                    inner_depth.increment()?;
7294                }
7295                let val_ref = self.fields.get_or_insert_with(|| {
7296                    fidl::new_empty!(fidl::encoding::UnboundedVector<ConfigField>, D)
7297                });
7298                fidl::decode!(
7299                    fidl::encoding::UnboundedVector<ConfigField>,
7300                    D,
7301                    val_ref,
7302                    decoder,
7303                    inner_offset,
7304                    inner_depth
7305                )?;
7306                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7307                {
7308                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7309                }
7310                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7311                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7312                }
7313            }
7314
7315            next_offset += envelope_size;
7316            _next_ordinal_to_read += 1;
7317            if next_offset >= end_offset {
7318                return Ok(());
7319            }
7320
7321            // Decode unknown envelopes for gaps in ordinals.
7322            while _next_ordinal_to_read < 2 {
7323                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7324                _next_ordinal_to_read += 1;
7325                next_offset += envelope_size;
7326            }
7327
7328            let next_out_of_line = decoder.next_out_of_line();
7329            let handles_before = decoder.remaining_handles();
7330            if let Some((inlined, num_bytes, num_handles)) =
7331                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7332            {
7333                let member_inline_size =
7334                    <ConfigChecksum as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7335                if inlined != (member_inline_size <= 4) {
7336                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7337                }
7338                let inner_offset;
7339                let mut inner_depth = depth.clone();
7340                if inlined {
7341                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7342                    inner_offset = next_offset;
7343                } else {
7344                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7345                    inner_depth.increment()?;
7346                }
7347                let val_ref =
7348                    self.checksum.get_or_insert_with(|| fidl::new_empty!(ConfigChecksum, D));
7349                fidl::decode!(ConfigChecksum, D, val_ref, decoder, inner_offset, inner_depth)?;
7350                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7351                {
7352                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7353                }
7354                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7355                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7356                }
7357            }
7358
7359            next_offset += envelope_size;
7360            _next_ordinal_to_read += 1;
7361            if next_offset >= end_offset {
7362                return Ok(());
7363            }
7364
7365            // Decode unknown envelopes for gaps in ordinals.
7366            while _next_ordinal_to_read < 3 {
7367                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7368                _next_ordinal_to_read += 1;
7369                next_offset += envelope_size;
7370            }
7371
7372            let next_out_of_line = decoder.next_out_of_line();
7373            let handles_before = decoder.remaining_handles();
7374            if let Some((inlined, num_bytes, num_handles)) =
7375                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7376            {
7377                let member_inline_size =
7378                    <ConfigValueSource as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7379                if inlined != (member_inline_size <= 4) {
7380                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7381                }
7382                let inner_offset;
7383                let mut inner_depth = depth.clone();
7384                if inlined {
7385                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7386                    inner_offset = next_offset;
7387                } else {
7388                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7389                    inner_depth.increment()?;
7390                }
7391                let val_ref =
7392                    self.value_source.get_or_insert_with(|| fidl::new_empty!(ConfigValueSource, D));
7393                fidl::decode!(ConfigValueSource, D, val_ref, decoder, inner_offset, inner_depth)?;
7394                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7395                {
7396                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7397                }
7398                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7399                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7400                }
7401            }
7402
7403            next_offset += envelope_size;
7404
7405            // Decode the remaining unknown envelopes.
7406            while next_offset < end_offset {
7407                _next_ordinal_to_read += 1;
7408                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7409                next_offset += envelope_size;
7410            }
7411
7412            Ok(())
7413        }
7414    }
7415
7416    impl ConfigSourceCapabilities {
7417        #[inline(always)]
7418        fn max_ordinal_present(&self) -> u64 {
7419            0
7420        }
7421    }
7422
7423    impl fidl::encoding::ValueTypeMarker for ConfigSourceCapabilities {
7424        type Borrowed<'a> = &'a Self;
7425        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7426            value
7427        }
7428    }
7429
7430    unsafe impl fidl::encoding::TypeMarker for ConfigSourceCapabilities {
7431        type Owned = Self;
7432
7433        #[inline(always)]
7434        fn inline_align(_context: fidl::encoding::Context) -> usize {
7435            8
7436        }
7437
7438        #[inline(always)]
7439        fn inline_size(_context: fidl::encoding::Context) -> usize {
7440            16
7441        }
7442    }
7443
7444    unsafe impl<D: fidl::encoding::ResourceDialect>
7445        fidl::encoding::Encode<ConfigSourceCapabilities, D> for &ConfigSourceCapabilities
7446    {
7447        unsafe fn encode(
7448            self,
7449            encoder: &mut fidl::encoding::Encoder<'_, D>,
7450            offset: usize,
7451            mut depth: fidl::encoding::Depth,
7452        ) -> fidl::Result<()> {
7453            encoder.debug_check_bounds::<ConfigSourceCapabilities>(offset);
7454            // Vector header
7455            let max_ordinal: u64 = self.max_ordinal_present();
7456            encoder.write_num(max_ordinal, offset);
7457            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7458            // Calling encoder.out_of_line_offset(0) is not allowed.
7459            if max_ordinal == 0 {
7460                return Ok(());
7461            }
7462            depth.increment()?;
7463            let envelope_size = 8;
7464            let bytes_len = max_ordinal as usize * envelope_size;
7465            #[allow(unused_variables)]
7466            let offset = encoder.out_of_line_offset(bytes_len);
7467            let mut _prev_end_offset: usize = 0;
7468
7469            Ok(())
7470        }
7471    }
7472
7473    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7474        for ConfigSourceCapabilities
7475    {
7476        #[inline(always)]
7477        fn new_empty() -> Self {
7478            Self::default()
7479        }
7480
7481        unsafe fn decode(
7482            &mut self,
7483            decoder: &mut fidl::encoding::Decoder<'_, D>,
7484            offset: usize,
7485            mut depth: fidl::encoding::Depth,
7486        ) -> fidl::Result<()> {
7487            decoder.debug_check_bounds::<Self>(offset);
7488            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7489                None => return Err(fidl::Error::NotNullable),
7490                Some(len) => len,
7491            };
7492            // Calling decoder.out_of_line_offset(0) is not allowed.
7493            if len == 0 {
7494                return Ok(());
7495            };
7496            depth.increment()?;
7497            let envelope_size = 8;
7498            let bytes_len = len * envelope_size;
7499            let offset = decoder.out_of_line_offset(bytes_len)?;
7500            // Decode the envelope for each type.
7501            let mut _next_ordinal_to_read = 0;
7502            let mut next_offset = offset;
7503            let end_offset = offset + bytes_len;
7504
7505            // Decode the remaining unknown envelopes.
7506            while next_offset < end_offset {
7507                _next_ordinal_to_read += 1;
7508                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7509                next_offset += envelope_size;
7510            }
7511
7512            Ok(())
7513        }
7514    }
7515
7516    impl ConfigValueSpec {
7517        #[inline(always)]
7518        fn max_ordinal_present(&self) -> u64 {
7519            if let Some(_) = self.value {
7520                return 1;
7521            }
7522            0
7523        }
7524    }
7525
7526    impl fidl::encoding::ValueTypeMarker for ConfigValueSpec {
7527        type Borrowed<'a> = &'a Self;
7528        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7529            value
7530        }
7531    }
7532
7533    unsafe impl fidl::encoding::TypeMarker for ConfigValueSpec {
7534        type Owned = Self;
7535
7536        #[inline(always)]
7537        fn inline_align(_context: fidl::encoding::Context) -> usize {
7538            8
7539        }
7540
7541        #[inline(always)]
7542        fn inline_size(_context: fidl::encoding::Context) -> usize {
7543            16
7544        }
7545    }
7546
7547    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigValueSpec, D>
7548        for &ConfigValueSpec
7549    {
7550        unsafe fn encode(
7551            self,
7552            encoder: &mut fidl::encoding::Encoder<'_, D>,
7553            offset: usize,
7554            mut depth: fidl::encoding::Depth,
7555        ) -> fidl::Result<()> {
7556            encoder.debug_check_bounds::<ConfigValueSpec>(offset);
7557            // Vector header
7558            let max_ordinal: u64 = self.max_ordinal_present();
7559            encoder.write_num(max_ordinal, offset);
7560            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7561            // Calling encoder.out_of_line_offset(0) is not allowed.
7562            if max_ordinal == 0 {
7563                return Ok(());
7564            }
7565            depth.increment()?;
7566            let envelope_size = 8;
7567            let bytes_len = max_ordinal as usize * envelope_size;
7568            #[allow(unused_variables)]
7569            let offset = encoder.out_of_line_offset(bytes_len);
7570            let mut _prev_end_offset: usize = 0;
7571            if 1 > max_ordinal {
7572                return Ok(());
7573            }
7574
7575            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7576            // are envelope_size bytes.
7577            let cur_offset: usize = (1 - 1) * envelope_size;
7578
7579            // Zero reserved fields.
7580            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7581
7582            // Safety:
7583            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7584            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7585            //   envelope_size bytes, there is always sufficient room.
7586            fidl::encoding::encode_in_envelope_optional::<ConfigValue, D>(
7587                self.value.as_ref().map(<ConfigValue as fidl::encoding::ValueTypeMarker>::borrow),
7588                encoder,
7589                offset + cur_offset,
7590                depth,
7591            )?;
7592
7593            _prev_end_offset = cur_offset + envelope_size;
7594
7595            Ok(())
7596        }
7597    }
7598
7599    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigValueSpec {
7600        #[inline(always)]
7601        fn new_empty() -> Self {
7602            Self::default()
7603        }
7604
7605        unsafe fn decode(
7606            &mut self,
7607            decoder: &mut fidl::encoding::Decoder<'_, D>,
7608            offset: usize,
7609            mut depth: fidl::encoding::Depth,
7610        ) -> fidl::Result<()> {
7611            decoder.debug_check_bounds::<Self>(offset);
7612            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7613                None => return Err(fidl::Error::NotNullable),
7614                Some(len) => len,
7615            };
7616            // Calling decoder.out_of_line_offset(0) is not allowed.
7617            if len == 0 {
7618                return Ok(());
7619            };
7620            depth.increment()?;
7621            let envelope_size = 8;
7622            let bytes_len = len * envelope_size;
7623            let offset = decoder.out_of_line_offset(bytes_len)?;
7624            // Decode the envelope for each type.
7625            let mut _next_ordinal_to_read = 0;
7626            let mut next_offset = offset;
7627            let end_offset = offset + bytes_len;
7628            _next_ordinal_to_read += 1;
7629            if next_offset >= end_offset {
7630                return Ok(());
7631            }
7632
7633            // Decode unknown envelopes for gaps in ordinals.
7634            while _next_ordinal_to_read < 1 {
7635                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7636                _next_ordinal_to_read += 1;
7637                next_offset += envelope_size;
7638            }
7639
7640            let next_out_of_line = decoder.next_out_of_line();
7641            let handles_before = decoder.remaining_handles();
7642            if let Some((inlined, num_bytes, num_handles)) =
7643                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7644            {
7645                let member_inline_size =
7646                    <ConfigValue as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7647                if inlined != (member_inline_size <= 4) {
7648                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7649                }
7650                let inner_offset;
7651                let mut inner_depth = depth.clone();
7652                if inlined {
7653                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7654                    inner_offset = next_offset;
7655                } else {
7656                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7657                    inner_depth.increment()?;
7658                }
7659                let val_ref = self.value.get_or_insert_with(|| fidl::new_empty!(ConfigValue, D));
7660                fidl::decode!(ConfigValue, D, val_ref, decoder, inner_offset, inner_depth)?;
7661                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7662                {
7663                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7664                }
7665                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7666                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7667                }
7668            }
7669
7670            next_offset += envelope_size;
7671
7672            // Decode the remaining unknown envelopes.
7673            while next_offset < end_offset {
7674                _next_ordinal_to_read += 1;
7675                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7676                next_offset += envelope_size;
7677            }
7678
7679            Ok(())
7680        }
7681    }
7682
7683    impl ConfigValuesData {
7684        #[inline(always)]
7685        fn max_ordinal_present(&self) -> u64 {
7686            if let Some(_) = self.checksum {
7687                return 2;
7688            }
7689            if let Some(_) = self.values {
7690                return 1;
7691            }
7692            0
7693        }
7694    }
7695
7696    impl fidl::encoding::ValueTypeMarker for ConfigValuesData {
7697        type Borrowed<'a> = &'a Self;
7698        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7699            value
7700        }
7701    }
7702
7703    unsafe impl fidl::encoding::TypeMarker for ConfigValuesData {
7704        type Owned = Self;
7705
7706        #[inline(always)]
7707        fn inline_align(_context: fidl::encoding::Context) -> usize {
7708            8
7709        }
7710
7711        #[inline(always)]
7712        fn inline_size(_context: fidl::encoding::Context) -> usize {
7713            16
7714        }
7715    }
7716
7717    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigValuesData, D>
7718        for &ConfigValuesData
7719    {
7720        unsafe fn encode(
7721            self,
7722            encoder: &mut fidl::encoding::Encoder<'_, D>,
7723            offset: usize,
7724            mut depth: fidl::encoding::Depth,
7725        ) -> fidl::Result<()> {
7726            encoder.debug_check_bounds::<ConfigValuesData>(offset);
7727            // Vector header
7728            let max_ordinal: u64 = self.max_ordinal_present();
7729            encoder.write_num(max_ordinal, offset);
7730            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7731            // Calling encoder.out_of_line_offset(0) is not allowed.
7732            if max_ordinal == 0 {
7733                return Ok(());
7734            }
7735            depth.increment()?;
7736            let envelope_size = 8;
7737            let bytes_len = max_ordinal as usize * envelope_size;
7738            #[allow(unused_variables)]
7739            let offset = encoder.out_of_line_offset(bytes_len);
7740            let mut _prev_end_offset: usize = 0;
7741            if 1 > max_ordinal {
7742                return Ok(());
7743            }
7744
7745            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7746            // are envelope_size bytes.
7747            let cur_offset: usize = (1 - 1) * envelope_size;
7748
7749            // Zero reserved fields.
7750            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7751
7752            // Safety:
7753            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7754            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7755            //   envelope_size bytes, there is always sufficient room.
7756            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ConfigValueSpec>, D>(
7757            self.values.as_ref().map(<fidl::encoding::UnboundedVector<ConfigValueSpec> as fidl::encoding::ValueTypeMarker>::borrow),
7758            encoder, offset + cur_offset, depth
7759        )?;
7760
7761            _prev_end_offset = cur_offset + envelope_size;
7762            if 2 > max_ordinal {
7763                return Ok(());
7764            }
7765
7766            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7767            // are envelope_size bytes.
7768            let cur_offset: usize = (2 - 1) * envelope_size;
7769
7770            // Zero reserved fields.
7771            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7772
7773            // Safety:
7774            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7775            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7776            //   envelope_size bytes, there is always sufficient room.
7777            fidl::encoding::encode_in_envelope_optional::<ConfigChecksum, D>(
7778                self.checksum
7779                    .as_ref()
7780                    .map(<ConfigChecksum as fidl::encoding::ValueTypeMarker>::borrow),
7781                encoder,
7782                offset + cur_offset,
7783                depth,
7784            )?;
7785
7786            _prev_end_offset = cur_offset + envelope_size;
7787
7788            Ok(())
7789        }
7790    }
7791
7792    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigValuesData {
7793        #[inline(always)]
7794        fn new_empty() -> Self {
7795            Self::default()
7796        }
7797
7798        unsafe fn decode(
7799            &mut self,
7800            decoder: &mut fidl::encoding::Decoder<'_, D>,
7801            offset: usize,
7802            mut depth: fidl::encoding::Depth,
7803        ) -> fidl::Result<()> {
7804            decoder.debug_check_bounds::<Self>(offset);
7805            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7806                None => return Err(fidl::Error::NotNullable),
7807                Some(len) => len,
7808            };
7809            // Calling decoder.out_of_line_offset(0) is not allowed.
7810            if len == 0 {
7811                return Ok(());
7812            };
7813            depth.increment()?;
7814            let envelope_size = 8;
7815            let bytes_len = len * envelope_size;
7816            let offset = decoder.out_of_line_offset(bytes_len)?;
7817            // Decode the envelope for each type.
7818            let mut _next_ordinal_to_read = 0;
7819            let mut next_offset = offset;
7820            let end_offset = offset + bytes_len;
7821            _next_ordinal_to_read += 1;
7822            if next_offset >= end_offset {
7823                return Ok(());
7824            }
7825
7826            // Decode unknown envelopes for gaps in ordinals.
7827            while _next_ordinal_to_read < 1 {
7828                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7829                _next_ordinal_to_read += 1;
7830                next_offset += envelope_size;
7831            }
7832
7833            let next_out_of_line = decoder.next_out_of_line();
7834            let handles_before = decoder.remaining_handles();
7835            if let Some((inlined, num_bytes, num_handles)) =
7836                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7837            {
7838                let member_inline_size = <fidl::encoding::UnboundedVector<ConfigValueSpec> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7839                if inlined != (member_inline_size <= 4) {
7840                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7841                }
7842                let inner_offset;
7843                let mut inner_depth = depth.clone();
7844                if inlined {
7845                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7846                    inner_offset = next_offset;
7847                } else {
7848                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7849                    inner_depth.increment()?;
7850                }
7851                let val_ref = self.values.get_or_insert_with(|| {
7852                    fidl::new_empty!(fidl::encoding::UnboundedVector<ConfigValueSpec>, D)
7853                });
7854                fidl::decode!(
7855                    fidl::encoding::UnboundedVector<ConfigValueSpec>,
7856                    D,
7857                    val_ref,
7858                    decoder,
7859                    inner_offset,
7860                    inner_depth
7861                )?;
7862                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7863                {
7864                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7865                }
7866                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7867                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7868                }
7869            }
7870
7871            next_offset += envelope_size;
7872            _next_ordinal_to_read += 1;
7873            if next_offset >= end_offset {
7874                return Ok(());
7875            }
7876
7877            // Decode unknown envelopes for gaps in ordinals.
7878            while _next_ordinal_to_read < 2 {
7879                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7880                _next_ordinal_to_read += 1;
7881                next_offset += envelope_size;
7882            }
7883
7884            let next_out_of_line = decoder.next_out_of_line();
7885            let handles_before = decoder.remaining_handles();
7886            if let Some((inlined, num_bytes, num_handles)) =
7887                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7888            {
7889                let member_inline_size =
7890                    <ConfigChecksum as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7891                if inlined != (member_inline_size <= 4) {
7892                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7893                }
7894                let inner_offset;
7895                let mut inner_depth = depth.clone();
7896                if inlined {
7897                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7898                    inner_offset = next_offset;
7899                } else {
7900                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7901                    inner_depth.increment()?;
7902                }
7903                let val_ref =
7904                    self.checksum.get_or_insert_with(|| fidl::new_empty!(ConfigChecksum, D));
7905                fidl::decode!(ConfigChecksum, D, val_ref, decoder, inner_offset, inner_depth)?;
7906                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7907                {
7908                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7909                }
7910                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7911                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7912                }
7913            }
7914
7915            next_offset += envelope_size;
7916
7917            // Decode the remaining unknown envelopes.
7918            while next_offset < end_offset {
7919                _next_ordinal_to_read += 1;
7920                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7921                next_offset += envelope_size;
7922            }
7923
7924            Ok(())
7925        }
7926    }
7927
7928    impl Configuration {
7929        #[inline(always)]
7930        fn max_ordinal_present(&self) -> u64 {
7931            if let Some(_) = self.value {
7932                return 2;
7933            }
7934            if let Some(_) = self.name {
7935                return 1;
7936            }
7937            0
7938        }
7939    }
7940
7941    impl fidl::encoding::ValueTypeMarker for Configuration {
7942        type Borrowed<'a> = &'a Self;
7943        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7944            value
7945        }
7946    }
7947
7948    unsafe impl fidl::encoding::TypeMarker for Configuration {
7949        type Owned = Self;
7950
7951        #[inline(always)]
7952        fn inline_align(_context: fidl::encoding::Context) -> usize {
7953            8
7954        }
7955
7956        #[inline(always)]
7957        fn inline_size(_context: fidl::encoding::Context) -> usize {
7958            16
7959        }
7960    }
7961
7962    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Configuration, D>
7963        for &Configuration
7964    {
7965        unsafe fn encode(
7966            self,
7967            encoder: &mut fidl::encoding::Encoder<'_, D>,
7968            offset: usize,
7969            mut depth: fidl::encoding::Depth,
7970        ) -> fidl::Result<()> {
7971            encoder.debug_check_bounds::<Configuration>(offset);
7972            // Vector header
7973            let max_ordinal: u64 = self.max_ordinal_present();
7974            encoder.write_num(max_ordinal, offset);
7975            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7976            // Calling encoder.out_of_line_offset(0) is not allowed.
7977            if max_ordinal == 0 {
7978                return Ok(());
7979            }
7980            depth.increment()?;
7981            let envelope_size = 8;
7982            let bytes_len = max_ordinal as usize * envelope_size;
7983            #[allow(unused_variables)]
7984            let offset = encoder.out_of_line_offset(bytes_len);
7985            let mut _prev_end_offset: usize = 0;
7986            if 1 > max_ordinal {
7987                return Ok(());
7988            }
7989
7990            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7991            // are envelope_size bytes.
7992            let cur_offset: usize = (1 - 1) * envelope_size;
7993
7994            // Zero reserved fields.
7995            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7996
7997            // Safety:
7998            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7999            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8000            //   envelope_size bytes, there is always sufficient room.
8001            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
8002                self.name.as_ref().map(
8003                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
8004                ),
8005                encoder,
8006                offset + cur_offset,
8007                depth,
8008            )?;
8009
8010            _prev_end_offset = cur_offset + envelope_size;
8011            if 2 > max_ordinal {
8012                return Ok(());
8013            }
8014
8015            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8016            // are envelope_size bytes.
8017            let cur_offset: usize = (2 - 1) * envelope_size;
8018
8019            // Zero reserved fields.
8020            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8021
8022            // Safety:
8023            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8024            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8025            //   envelope_size bytes, there is always sufficient room.
8026            fidl::encoding::encode_in_envelope_optional::<ConfigValue, D>(
8027                self.value.as_ref().map(<ConfigValue as fidl::encoding::ValueTypeMarker>::borrow),
8028                encoder,
8029                offset + cur_offset,
8030                depth,
8031            )?;
8032
8033            _prev_end_offset = cur_offset + envelope_size;
8034
8035            Ok(())
8036        }
8037    }
8038
8039    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Configuration {
8040        #[inline(always)]
8041        fn new_empty() -> Self {
8042            Self::default()
8043        }
8044
8045        unsafe fn decode(
8046            &mut self,
8047            decoder: &mut fidl::encoding::Decoder<'_, D>,
8048            offset: usize,
8049            mut depth: fidl::encoding::Depth,
8050        ) -> fidl::Result<()> {
8051            decoder.debug_check_bounds::<Self>(offset);
8052            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8053                None => return Err(fidl::Error::NotNullable),
8054                Some(len) => len,
8055            };
8056            // Calling decoder.out_of_line_offset(0) is not allowed.
8057            if len == 0 {
8058                return Ok(());
8059            };
8060            depth.increment()?;
8061            let envelope_size = 8;
8062            let bytes_len = len * envelope_size;
8063            let offset = decoder.out_of_line_offset(bytes_len)?;
8064            // Decode the envelope for each type.
8065            let mut _next_ordinal_to_read = 0;
8066            let mut next_offset = offset;
8067            let end_offset = offset + bytes_len;
8068            _next_ordinal_to_read += 1;
8069            if next_offset >= end_offset {
8070                return Ok(());
8071            }
8072
8073            // Decode unknown envelopes for gaps in ordinals.
8074            while _next_ordinal_to_read < 1 {
8075                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8076                _next_ordinal_to_read += 1;
8077                next_offset += envelope_size;
8078            }
8079
8080            let next_out_of_line = decoder.next_out_of_line();
8081            let handles_before = decoder.remaining_handles();
8082            if let Some((inlined, num_bytes, num_handles)) =
8083                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8084            {
8085                let member_inline_size =
8086                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
8087                        decoder.context,
8088                    );
8089                if inlined != (member_inline_size <= 4) {
8090                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8091                }
8092                let inner_offset;
8093                let mut inner_depth = depth.clone();
8094                if inlined {
8095                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8096                    inner_offset = next_offset;
8097                } else {
8098                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8099                    inner_depth.increment()?;
8100                }
8101                let val_ref = self
8102                    .name
8103                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
8104                fidl::decode!(
8105                    fidl::encoding::BoundedString<100>,
8106                    D,
8107                    val_ref,
8108                    decoder,
8109                    inner_offset,
8110                    inner_depth
8111                )?;
8112                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8113                {
8114                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8115                }
8116                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8117                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8118                }
8119            }
8120
8121            next_offset += envelope_size;
8122            _next_ordinal_to_read += 1;
8123            if next_offset >= end_offset {
8124                return Ok(());
8125            }
8126
8127            // Decode unknown envelopes for gaps in ordinals.
8128            while _next_ordinal_to_read < 2 {
8129                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8130                _next_ordinal_to_read += 1;
8131                next_offset += envelope_size;
8132            }
8133
8134            let next_out_of_line = decoder.next_out_of_line();
8135            let handles_before = decoder.remaining_handles();
8136            if let Some((inlined, num_bytes, num_handles)) =
8137                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8138            {
8139                let member_inline_size =
8140                    <ConfigValue as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8141                if inlined != (member_inline_size <= 4) {
8142                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8143                }
8144                let inner_offset;
8145                let mut inner_depth = depth.clone();
8146                if inlined {
8147                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8148                    inner_offset = next_offset;
8149                } else {
8150                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8151                    inner_depth.increment()?;
8152                }
8153                let val_ref = self.value.get_or_insert_with(|| fidl::new_empty!(ConfigValue, D));
8154                fidl::decode!(ConfigValue, D, val_ref, decoder, inner_offset, inner_depth)?;
8155                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8156                {
8157                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8158                }
8159                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8160                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8161                }
8162            }
8163
8164            next_offset += envelope_size;
8165
8166            // Decode the remaining unknown envelopes.
8167            while next_offset < end_offset {
8168                _next_ordinal_to_read += 1;
8169                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8170                next_offset += envelope_size;
8171            }
8172
8173            Ok(())
8174        }
8175    }
8176
8177    impl DebugProtocolRegistration {
8178        #[inline(always)]
8179        fn max_ordinal_present(&self) -> u64 {
8180            if let Some(_) = self.target_name {
8181                return 3;
8182            }
8183            if let Some(_) = self.source_name {
8184                return 2;
8185            }
8186            if let Some(_) = self.source {
8187                return 1;
8188            }
8189            0
8190        }
8191    }
8192
8193    impl fidl::encoding::ValueTypeMarker for DebugProtocolRegistration {
8194        type Borrowed<'a> = &'a Self;
8195        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8196            value
8197        }
8198    }
8199
8200    unsafe impl fidl::encoding::TypeMarker for DebugProtocolRegistration {
8201        type Owned = Self;
8202
8203        #[inline(always)]
8204        fn inline_align(_context: fidl::encoding::Context) -> usize {
8205            8
8206        }
8207
8208        #[inline(always)]
8209        fn inline_size(_context: fidl::encoding::Context) -> usize {
8210            16
8211        }
8212    }
8213
8214    unsafe impl<D: fidl::encoding::ResourceDialect>
8215        fidl::encoding::Encode<DebugProtocolRegistration, D> for &DebugProtocolRegistration
8216    {
8217        unsafe fn encode(
8218            self,
8219            encoder: &mut fidl::encoding::Encoder<'_, D>,
8220            offset: usize,
8221            mut depth: fidl::encoding::Depth,
8222        ) -> fidl::Result<()> {
8223            encoder.debug_check_bounds::<DebugProtocolRegistration>(offset);
8224            // Vector header
8225            let max_ordinal: u64 = self.max_ordinal_present();
8226            encoder.write_num(max_ordinal, offset);
8227            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8228            // Calling encoder.out_of_line_offset(0) is not allowed.
8229            if max_ordinal == 0 {
8230                return Ok(());
8231            }
8232            depth.increment()?;
8233            let envelope_size = 8;
8234            let bytes_len = max_ordinal as usize * envelope_size;
8235            #[allow(unused_variables)]
8236            let offset = encoder.out_of_line_offset(bytes_len);
8237            let mut _prev_end_offset: usize = 0;
8238            if 1 > max_ordinal {
8239                return Ok(());
8240            }
8241
8242            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8243            // are envelope_size bytes.
8244            let cur_offset: usize = (1 - 1) * envelope_size;
8245
8246            // Zero reserved fields.
8247            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8248
8249            // Safety:
8250            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8251            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8252            //   envelope_size bytes, there is always sufficient room.
8253            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
8254                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
8255                encoder,
8256                offset + cur_offset,
8257                depth,
8258            )?;
8259
8260            _prev_end_offset = cur_offset + envelope_size;
8261            if 2 > max_ordinal {
8262                return Ok(());
8263            }
8264
8265            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8266            // are envelope_size bytes.
8267            let cur_offset: usize = (2 - 1) * envelope_size;
8268
8269            // Zero reserved fields.
8270            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8271
8272            // Safety:
8273            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8274            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8275            //   envelope_size bytes, there is always sufficient room.
8276            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
8277                self.source_name.as_ref().map(
8278                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
8279                ),
8280                encoder,
8281                offset + cur_offset,
8282                depth,
8283            )?;
8284
8285            _prev_end_offset = cur_offset + envelope_size;
8286            if 3 > max_ordinal {
8287                return Ok(());
8288            }
8289
8290            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8291            // are envelope_size bytes.
8292            let cur_offset: usize = (3 - 1) * envelope_size;
8293
8294            // Zero reserved fields.
8295            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8296
8297            // Safety:
8298            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8299            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8300            //   envelope_size bytes, there is always sufficient room.
8301            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
8302                self.target_name.as_ref().map(
8303                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
8304                ),
8305                encoder,
8306                offset + cur_offset,
8307                depth,
8308            )?;
8309
8310            _prev_end_offset = cur_offset + envelope_size;
8311
8312            Ok(())
8313        }
8314    }
8315
8316    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8317        for DebugProtocolRegistration
8318    {
8319        #[inline(always)]
8320        fn new_empty() -> Self {
8321            Self::default()
8322        }
8323
8324        unsafe fn decode(
8325            &mut self,
8326            decoder: &mut fidl::encoding::Decoder<'_, D>,
8327            offset: usize,
8328            mut depth: fidl::encoding::Depth,
8329        ) -> fidl::Result<()> {
8330            decoder.debug_check_bounds::<Self>(offset);
8331            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8332                None => return Err(fidl::Error::NotNullable),
8333                Some(len) => len,
8334            };
8335            // Calling decoder.out_of_line_offset(0) is not allowed.
8336            if len == 0 {
8337                return Ok(());
8338            };
8339            depth.increment()?;
8340            let envelope_size = 8;
8341            let bytes_len = len * envelope_size;
8342            let offset = decoder.out_of_line_offset(bytes_len)?;
8343            // Decode the envelope for each type.
8344            let mut _next_ordinal_to_read = 0;
8345            let mut next_offset = offset;
8346            let end_offset = offset + bytes_len;
8347            _next_ordinal_to_read += 1;
8348            if next_offset >= end_offset {
8349                return Ok(());
8350            }
8351
8352            // Decode unknown envelopes for gaps in ordinals.
8353            while _next_ordinal_to_read < 1 {
8354                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8355                _next_ordinal_to_read += 1;
8356                next_offset += envelope_size;
8357            }
8358
8359            let next_out_of_line = decoder.next_out_of_line();
8360            let handles_before = decoder.remaining_handles();
8361            if let Some((inlined, num_bytes, num_handles)) =
8362                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8363            {
8364                let member_inline_size =
8365                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8366                if inlined != (member_inline_size <= 4) {
8367                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8368                }
8369                let inner_offset;
8370                let mut inner_depth = depth.clone();
8371                if inlined {
8372                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8373                    inner_offset = next_offset;
8374                } else {
8375                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8376                    inner_depth.increment()?;
8377                }
8378                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
8379                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
8380                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8381                {
8382                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8383                }
8384                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8385                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8386                }
8387            }
8388
8389            next_offset += envelope_size;
8390            _next_ordinal_to_read += 1;
8391            if next_offset >= end_offset {
8392                return Ok(());
8393            }
8394
8395            // Decode unknown envelopes for gaps in ordinals.
8396            while _next_ordinal_to_read < 2 {
8397                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8398                _next_ordinal_to_read += 1;
8399                next_offset += envelope_size;
8400            }
8401
8402            let next_out_of_line = decoder.next_out_of_line();
8403            let handles_before = decoder.remaining_handles();
8404            if let Some((inlined, num_bytes, num_handles)) =
8405                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8406            {
8407                let member_inline_size =
8408                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
8409                        decoder.context,
8410                    );
8411                if inlined != (member_inline_size <= 4) {
8412                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8413                }
8414                let inner_offset;
8415                let mut inner_depth = depth.clone();
8416                if inlined {
8417                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8418                    inner_offset = next_offset;
8419                } else {
8420                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8421                    inner_depth.increment()?;
8422                }
8423                let val_ref = self
8424                    .source_name
8425                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
8426                fidl::decode!(
8427                    fidl::encoding::BoundedString<100>,
8428                    D,
8429                    val_ref,
8430                    decoder,
8431                    inner_offset,
8432                    inner_depth
8433                )?;
8434                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8435                {
8436                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8437                }
8438                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8439                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8440                }
8441            }
8442
8443            next_offset += envelope_size;
8444            _next_ordinal_to_read += 1;
8445            if next_offset >= end_offset {
8446                return Ok(());
8447            }
8448
8449            // Decode unknown envelopes for gaps in ordinals.
8450            while _next_ordinal_to_read < 3 {
8451                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8452                _next_ordinal_to_read += 1;
8453                next_offset += envelope_size;
8454            }
8455
8456            let next_out_of_line = decoder.next_out_of_line();
8457            let handles_before = decoder.remaining_handles();
8458            if let Some((inlined, num_bytes, num_handles)) =
8459                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8460            {
8461                let member_inline_size =
8462                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
8463                        decoder.context,
8464                    );
8465                if inlined != (member_inline_size <= 4) {
8466                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8467                }
8468                let inner_offset;
8469                let mut inner_depth = depth.clone();
8470                if inlined {
8471                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8472                    inner_offset = next_offset;
8473                } else {
8474                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8475                    inner_depth.increment()?;
8476                }
8477                let val_ref = self
8478                    .target_name
8479                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
8480                fidl::decode!(
8481                    fidl::encoding::BoundedString<100>,
8482                    D,
8483                    val_ref,
8484                    decoder,
8485                    inner_offset,
8486                    inner_depth
8487                )?;
8488                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8489                {
8490                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8491                }
8492                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8493                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8494                }
8495            }
8496
8497            next_offset += envelope_size;
8498
8499            // Decode the remaining unknown envelopes.
8500            while next_offset < end_offset {
8501                _next_ordinal_to_read += 1;
8502                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8503                next_offset += envelope_size;
8504            }
8505
8506            Ok(())
8507        }
8508    }
8509
8510    impl Dictionary {
8511        #[inline(always)]
8512        fn max_ordinal_present(&self) -> u64 {
8513            if let Some(_) = self.source_path {
8514                return 4;
8515            }
8516            if let Some(_) = self.source_dictionary {
8517                return 3;
8518            }
8519            if let Some(_) = self.source {
8520                return 2;
8521            }
8522            if let Some(_) = self.name {
8523                return 1;
8524            }
8525            0
8526        }
8527    }
8528
8529    impl fidl::encoding::ValueTypeMarker for Dictionary {
8530        type Borrowed<'a> = &'a Self;
8531        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8532            value
8533        }
8534    }
8535
8536    unsafe impl fidl::encoding::TypeMarker for Dictionary {
8537        type Owned = Self;
8538
8539        #[inline(always)]
8540        fn inline_align(_context: fidl::encoding::Context) -> usize {
8541            8
8542        }
8543
8544        #[inline(always)]
8545        fn inline_size(_context: fidl::encoding::Context) -> usize {
8546            16
8547        }
8548    }
8549
8550    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Dictionary, D>
8551        for &Dictionary
8552    {
8553        unsafe fn encode(
8554            self,
8555            encoder: &mut fidl::encoding::Encoder<'_, D>,
8556            offset: usize,
8557            mut depth: fidl::encoding::Depth,
8558        ) -> fidl::Result<()> {
8559            encoder.debug_check_bounds::<Dictionary>(offset);
8560            // Vector header
8561            let max_ordinal: u64 = self.max_ordinal_present();
8562            encoder.write_num(max_ordinal, offset);
8563            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8564            // Calling encoder.out_of_line_offset(0) is not allowed.
8565            if max_ordinal == 0 {
8566                return Ok(());
8567            }
8568            depth.increment()?;
8569            let envelope_size = 8;
8570            let bytes_len = max_ordinal as usize * envelope_size;
8571            #[allow(unused_variables)]
8572            let offset = encoder.out_of_line_offset(bytes_len);
8573            let mut _prev_end_offset: usize = 0;
8574            if 1 > max_ordinal {
8575                return Ok(());
8576            }
8577
8578            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8579            // are envelope_size bytes.
8580            let cur_offset: usize = (1 - 1) * envelope_size;
8581
8582            // Zero reserved fields.
8583            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8584
8585            // Safety:
8586            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8587            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8588            //   envelope_size bytes, there is always sufficient room.
8589            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
8590                self.name.as_ref().map(
8591                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
8592                ),
8593                encoder,
8594                offset + cur_offset,
8595                depth,
8596            )?;
8597
8598            _prev_end_offset = cur_offset + envelope_size;
8599            if 2 > max_ordinal {
8600                return Ok(());
8601            }
8602
8603            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8604            // are envelope_size bytes.
8605            let cur_offset: usize = (2 - 1) * envelope_size;
8606
8607            // Zero reserved fields.
8608            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8609
8610            // Safety:
8611            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8612            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8613            //   envelope_size bytes, there is always sufficient room.
8614            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
8615                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
8616                encoder,
8617                offset + cur_offset,
8618                depth,
8619            )?;
8620
8621            _prev_end_offset = cur_offset + envelope_size;
8622            if 3 > max_ordinal {
8623                return Ok(());
8624            }
8625
8626            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8627            // are envelope_size bytes.
8628            let cur_offset: usize = (3 - 1) * envelope_size;
8629
8630            // Zero reserved fields.
8631            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8632
8633            // Safety:
8634            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8635            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8636            //   envelope_size bytes, there is always sufficient room.
8637            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
8638            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
8639            encoder, offset + cur_offset, depth
8640        )?;
8641
8642            _prev_end_offset = cur_offset + envelope_size;
8643            if 4 > max_ordinal {
8644                return Ok(());
8645            }
8646
8647            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8648            // are envelope_size bytes.
8649            let cur_offset: usize = (4 - 1) * envelope_size;
8650
8651            // Zero reserved fields.
8652            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8653
8654            // Safety:
8655            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8656            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8657            //   envelope_size bytes, there is always sufficient room.
8658            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
8659            self.source_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
8660            encoder, offset + cur_offset, depth
8661        )?;
8662
8663            _prev_end_offset = cur_offset + envelope_size;
8664
8665            Ok(())
8666        }
8667    }
8668
8669    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dictionary {
8670        #[inline(always)]
8671        fn new_empty() -> Self {
8672            Self::default()
8673        }
8674
8675        unsafe fn decode(
8676            &mut self,
8677            decoder: &mut fidl::encoding::Decoder<'_, D>,
8678            offset: usize,
8679            mut depth: fidl::encoding::Depth,
8680        ) -> fidl::Result<()> {
8681            decoder.debug_check_bounds::<Self>(offset);
8682            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8683                None => return Err(fidl::Error::NotNullable),
8684                Some(len) => len,
8685            };
8686            // Calling decoder.out_of_line_offset(0) is not allowed.
8687            if len == 0 {
8688                return Ok(());
8689            };
8690            depth.increment()?;
8691            let envelope_size = 8;
8692            let bytes_len = len * envelope_size;
8693            let offset = decoder.out_of_line_offset(bytes_len)?;
8694            // Decode the envelope for each type.
8695            let mut _next_ordinal_to_read = 0;
8696            let mut next_offset = offset;
8697            let end_offset = offset + bytes_len;
8698            _next_ordinal_to_read += 1;
8699            if next_offset >= end_offset {
8700                return Ok(());
8701            }
8702
8703            // Decode unknown envelopes for gaps in ordinals.
8704            while _next_ordinal_to_read < 1 {
8705                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8706                _next_ordinal_to_read += 1;
8707                next_offset += envelope_size;
8708            }
8709
8710            let next_out_of_line = decoder.next_out_of_line();
8711            let handles_before = decoder.remaining_handles();
8712            if let Some((inlined, num_bytes, num_handles)) =
8713                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8714            {
8715                let member_inline_size =
8716                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
8717                        decoder.context,
8718                    );
8719                if inlined != (member_inline_size <= 4) {
8720                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8721                }
8722                let inner_offset;
8723                let mut inner_depth = depth.clone();
8724                if inlined {
8725                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8726                    inner_offset = next_offset;
8727                } else {
8728                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8729                    inner_depth.increment()?;
8730                }
8731                let val_ref = self
8732                    .name
8733                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
8734                fidl::decode!(
8735                    fidl::encoding::BoundedString<100>,
8736                    D,
8737                    val_ref,
8738                    decoder,
8739                    inner_offset,
8740                    inner_depth
8741                )?;
8742                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8743                {
8744                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8745                }
8746                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8747                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8748                }
8749            }
8750
8751            next_offset += envelope_size;
8752            _next_ordinal_to_read += 1;
8753            if next_offset >= end_offset {
8754                return Ok(());
8755            }
8756
8757            // Decode unknown envelopes for gaps in ordinals.
8758            while _next_ordinal_to_read < 2 {
8759                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8760                _next_ordinal_to_read += 1;
8761                next_offset += envelope_size;
8762            }
8763
8764            let next_out_of_line = decoder.next_out_of_line();
8765            let handles_before = decoder.remaining_handles();
8766            if let Some((inlined, num_bytes, num_handles)) =
8767                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8768            {
8769                let member_inline_size =
8770                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8771                if inlined != (member_inline_size <= 4) {
8772                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8773                }
8774                let inner_offset;
8775                let mut inner_depth = depth.clone();
8776                if inlined {
8777                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8778                    inner_offset = next_offset;
8779                } else {
8780                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8781                    inner_depth.increment()?;
8782                }
8783                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
8784                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
8785                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8786                {
8787                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8788                }
8789                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8790                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8791                }
8792            }
8793
8794            next_offset += envelope_size;
8795            _next_ordinal_to_read += 1;
8796            if next_offset >= end_offset {
8797                return Ok(());
8798            }
8799
8800            // Decode unknown envelopes for gaps in ordinals.
8801            while _next_ordinal_to_read < 3 {
8802                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8803                _next_ordinal_to_read += 1;
8804                next_offset += envelope_size;
8805            }
8806
8807            let next_out_of_line = decoder.next_out_of_line();
8808            let handles_before = decoder.remaining_handles();
8809            if let Some((inlined, num_bytes, num_handles)) =
8810                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8811            {
8812                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8813                if inlined != (member_inline_size <= 4) {
8814                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8815                }
8816                let inner_offset;
8817                let mut inner_depth = depth.clone();
8818                if inlined {
8819                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8820                    inner_offset = next_offset;
8821                } else {
8822                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8823                    inner_depth.increment()?;
8824                }
8825                let val_ref = self.source_dictionary.get_or_insert_with(|| {
8826                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
8827                });
8828                fidl::decode!(
8829                    fidl::encoding::BoundedString<1024>,
8830                    D,
8831                    val_ref,
8832                    decoder,
8833                    inner_offset,
8834                    inner_depth
8835                )?;
8836                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8837                {
8838                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8839                }
8840                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8841                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8842                }
8843            }
8844
8845            next_offset += envelope_size;
8846            _next_ordinal_to_read += 1;
8847            if next_offset >= end_offset {
8848                return Ok(());
8849            }
8850
8851            // Decode unknown envelopes for gaps in ordinals.
8852            while _next_ordinal_to_read < 4 {
8853                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8854                _next_ordinal_to_read += 1;
8855                next_offset += envelope_size;
8856            }
8857
8858            let next_out_of_line = decoder.next_out_of_line();
8859            let handles_before = decoder.remaining_handles();
8860            if let Some((inlined, num_bytes, num_handles)) =
8861                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8862            {
8863                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8864                if inlined != (member_inline_size <= 4) {
8865                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8866                }
8867                let inner_offset;
8868                let mut inner_depth = depth.clone();
8869                if inlined {
8870                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8871                    inner_offset = next_offset;
8872                } else {
8873                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8874                    inner_depth.increment()?;
8875                }
8876                let val_ref = self.source_path.get_or_insert_with(|| {
8877                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
8878                });
8879                fidl::decode!(
8880                    fidl::encoding::BoundedString<1024>,
8881                    D,
8882                    val_ref,
8883                    decoder,
8884                    inner_offset,
8885                    inner_depth
8886                )?;
8887                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8888                {
8889                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8890                }
8891                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8892                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8893                }
8894            }
8895
8896            next_offset += envelope_size;
8897
8898            // Decode the remaining unknown envelopes.
8899            while next_offset < end_offset {
8900                _next_ordinal_to_read += 1;
8901                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8902                next_offset += envelope_size;
8903            }
8904
8905            Ok(())
8906        }
8907    }
8908
8909    impl Directory {
8910        #[inline(always)]
8911        fn max_ordinal_present(&self) -> u64 {
8912            if let Some(_) = self.rights {
8913                return 3;
8914            }
8915            if let Some(_) = self.source_path {
8916                return 2;
8917            }
8918            if let Some(_) = self.name {
8919                return 1;
8920            }
8921            0
8922        }
8923    }
8924
8925    impl fidl::encoding::ValueTypeMarker for Directory {
8926        type Borrowed<'a> = &'a Self;
8927        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8928            value
8929        }
8930    }
8931
8932    unsafe impl fidl::encoding::TypeMarker for Directory {
8933        type Owned = Self;
8934
8935        #[inline(always)]
8936        fn inline_align(_context: fidl::encoding::Context) -> usize {
8937            8
8938        }
8939
8940        #[inline(always)]
8941        fn inline_size(_context: fidl::encoding::Context) -> usize {
8942            16
8943        }
8944    }
8945
8946    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Directory, D>
8947        for &Directory
8948    {
8949        unsafe fn encode(
8950            self,
8951            encoder: &mut fidl::encoding::Encoder<'_, D>,
8952            offset: usize,
8953            mut depth: fidl::encoding::Depth,
8954        ) -> fidl::Result<()> {
8955            encoder.debug_check_bounds::<Directory>(offset);
8956            // Vector header
8957            let max_ordinal: u64 = self.max_ordinal_present();
8958            encoder.write_num(max_ordinal, offset);
8959            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8960            // Calling encoder.out_of_line_offset(0) is not allowed.
8961            if max_ordinal == 0 {
8962                return Ok(());
8963            }
8964            depth.increment()?;
8965            let envelope_size = 8;
8966            let bytes_len = max_ordinal as usize * envelope_size;
8967            #[allow(unused_variables)]
8968            let offset = encoder.out_of_line_offset(bytes_len);
8969            let mut _prev_end_offset: usize = 0;
8970            if 1 > max_ordinal {
8971                return Ok(());
8972            }
8973
8974            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8975            // are envelope_size bytes.
8976            let cur_offset: usize = (1 - 1) * envelope_size;
8977
8978            // Zero reserved fields.
8979            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8980
8981            // Safety:
8982            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8983            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8984            //   envelope_size bytes, there is always sufficient room.
8985            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
8986                self.name.as_ref().map(
8987                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
8988                ),
8989                encoder,
8990                offset + cur_offset,
8991                depth,
8992            )?;
8993
8994            _prev_end_offset = cur_offset + envelope_size;
8995            if 2 > max_ordinal {
8996                return Ok(());
8997            }
8998
8999            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9000            // are envelope_size bytes.
9001            let cur_offset: usize = (2 - 1) * envelope_size;
9002
9003            // Zero reserved fields.
9004            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9005
9006            // Safety:
9007            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9008            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9009            //   envelope_size bytes, there is always sufficient room.
9010            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
9011            self.source_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
9012            encoder, offset + cur_offset, depth
9013        )?;
9014
9015            _prev_end_offset = cur_offset + envelope_size;
9016            if 3 > max_ordinal {
9017                return Ok(());
9018            }
9019
9020            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9021            // are envelope_size bytes.
9022            let cur_offset: usize = (3 - 1) * envelope_size;
9023
9024            // Zero reserved fields.
9025            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9026
9027            // Safety:
9028            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9029            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9030            //   envelope_size bytes, there is always sufficient room.
9031            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_io__common::Operations, D>(
9032            self.rights.as_ref().map(<fidl_fuchsia_io__common::Operations as fidl::encoding::ValueTypeMarker>::borrow),
9033            encoder, offset + cur_offset, depth
9034        )?;
9035
9036            _prev_end_offset = cur_offset + envelope_size;
9037
9038            Ok(())
9039        }
9040    }
9041
9042    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Directory {
9043        #[inline(always)]
9044        fn new_empty() -> Self {
9045            Self::default()
9046        }
9047
9048        unsafe fn decode(
9049            &mut self,
9050            decoder: &mut fidl::encoding::Decoder<'_, D>,
9051            offset: usize,
9052            mut depth: fidl::encoding::Depth,
9053        ) -> fidl::Result<()> {
9054            decoder.debug_check_bounds::<Self>(offset);
9055            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9056                None => return Err(fidl::Error::NotNullable),
9057                Some(len) => len,
9058            };
9059            // Calling decoder.out_of_line_offset(0) is not allowed.
9060            if len == 0 {
9061                return Ok(());
9062            };
9063            depth.increment()?;
9064            let envelope_size = 8;
9065            let bytes_len = len * envelope_size;
9066            let offset = decoder.out_of_line_offset(bytes_len)?;
9067            // Decode the envelope for each type.
9068            let mut _next_ordinal_to_read = 0;
9069            let mut next_offset = offset;
9070            let end_offset = offset + bytes_len;
9071            _next_ordinal_to_read += 1;
9072            if next_offset >= end_offset {
9073                return Ok(());
9074            }
9075
9076            // Decode unknown envelopes for gaps in ordinals.
9077            while _next_ordinal_to_read < 1 {
9078                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9079                _next_ordinal_to_read += 1;
9080                next_offset += envelope_size;
9081            }
9082
9083            let next_out_of_line = decoder.next_out_of_line();
9084            let handles_before = decoder.remaining_handles();
9085            if let Some((inlined, num_bytes, num_handles)) =
9086                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9087            {
9088                let member_inline_size =
9089                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
9090                        decoder.context,
9091                    );
9092                if inlined != (member_inline_size <= 4) {
9093                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9094                }
9095                let inner_offset;
9096                let mut inner_depth = depth.clone();
9097                if inlined {
9098                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9099                    inner_offset = next_offset;
9100                } else {
9101                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9102                    inner_depth.increment()?;
9103                }
9104                let val_ref = self
9105                    .name
9106                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
9107                fidl::decode!(
9108                    fidl::encoding::BoundedString<100>,
9109                    D,
9110                    val_ref,
9111                    decoder,
9112                    inner_offset,
9113                    inner_depth
9114                )?;
9115                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9116                {
9117                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9118                }
9119                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9120                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9121                }
9122            }
9123
9124            next_offset += envelope_size;
9125            _next_ordinal_to_read += 1;
9126            if next_offset >= end_offset {
9127                return Ok(());
9128            }
9129
9130            // Decode unknown envelopes for gaps in ordinals.
9131            while _next_ordinal_to_read < 2 {
9132                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9133                _next_ordinal_to_read += 1;
9134                next_offset += envelope_size;
9135            }
9136
9137            let next_out_of_line = decoder.next_out_of_line();
9138            let handles_before = decoder.remaining_handles();
9139            if let Some((inlined, num_bytes, num_handles)) =
9140                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9141            {
9142                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9143                if inlined != (member_inline_size <= 4) {
9144                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9145                }
9146                let inner_offset;
9147                let mut inner_depth = depth.clone();
9148                if inlined {
9149                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9150                    inner_offset = next_offset;
9151                } else {
9152                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9153                    inner_depth.increment()?;
9154                }
9155                let val_ref = self.source_path.get_or_insert_with(|| {
9156                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
9157                });
9158                fidl::decode!(
9159                    fidl::encoding::BoundedString<1024>,
9160                    D,
9161                    val_ref,
9162                    decoder,
9163                    inner_offset,
9164                    inner_depth
9165                )?;
9166                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9167                {
9168                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9169                }
9170                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9171                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9172                }
9173            }
9174
9175            next_offset += envelope_size;
9176            _next_ordinal_to_read += 1;
9177            if next_offset >= end_offset {
9178                return Ok(());
9179            }
9180
9181            // Decode unknown envelopes for gaps in ordinals.
9182            while _next_ordinal_to_read < 3 {
9183                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9184                _next_ordinal_to_read += 1;
9185                next_offset += envelope_size;
9186            }
9187
9188            let next_out_of_line = decoder.next_out_of_line();
9189            let handles_before = decoder.remaining_handles();
9190            if let Some((inlined, num_bytes, num_handles)) =
9191                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9192            {
9193                let member_inline_size = <fidl_fuchsia_io__common::Operations as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9194                if inlined != (member_inline_size <= 4) {
9195                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9196                }
9197                let inner_offset;
9198                let mut inner_depth = depth.clone();
9199                if inlined {
9200                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9201                    inner_offset = next_offset;
9202                } else {
9203                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9204                    inner_depth.increment()?;
9205                }
9206                let val_ref = self.rights.get_or_insert_with(|| {
9207                    fidl::new_empty!(fidl_fuchsia_io__common::Operations, D)
9208                });
9209                fidl::decode!(
9210                    fidl_fuchsia_io__common::Operations,
9211                    D,
9212                    val_ref,
9213                    decoder,
9214                    inner_offset,
9215                    inner_depth
9216                )?;
9217                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9218                {
9219                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9220                }
9221                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9222                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9223                }
9224            }
9225
9226            next_offset += envelope_size;
9227
9228            // Decode the remaining unknown envelopes.
9229            while next_offset < end_offset {
9230                _next_ordinal_to_read += 1;
9231                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9232                next_offset += envelope_size;
9233            }
9234
9235            Ok(())
9236        }
9237    }
9238
9239    impl Environment {
9240        #[inline(always)]
9241        fn max_ordinal_present(&self) -> u64 {
9242            if let Some(_) = self.stop_timeout_ms {
9243                return 6;
9244            }
9245            if let Some(_) = self.debug_capabilities {
9246                return 5;
9247            }
9248            if let Some(_) = self.resolvers {
9249                return 4;
9250            }
9251            if let Some(_) = self.runners {
9252                return 3;
9253            }
9254            if let Some(_) = self.extends {
9255                return 2;
9256            }
9257            if let Some(_) = self.name {
9258                return 1;
9259            }
9260            0
9261        }
9262    }
9263
9264    impl fidl::encoding::ValueTypeMarker for Environment {
9265        type Borrowed<'a> = &'a Self;
9266        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9267            value
9268        }
9269    }
9270
9271    unsafe impl fidl::encoding::TypeMarker for Environment {
9272        type Owned = Self;
9273
9274        #[inline(always)]
9275        fn inline_align(_context: fidl::encoding::Context) -> usize {
9276            8
9277        }
9278
9279        #[inline(always)]
9280        fn inline_size(_context: fidl::encoding::Context) -> usize {
9281            16
9282        }
9283    }
9284
9285    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Environment, D>
9286        for &Environment
9287    {
9288        unsafe fn encode(
9289            self,
9290            encoder: &mut fidl::encoding::Encoder<'_, D>,
9291            offset: usize,
9292            mut depth: fidl::encoding::Depth,
9293        ) -> fidl::Result<()> {
9294            encoder.debug_check_bounds::<Environment>(offset);
9295            // Vector header
9296            let max_ordinal: u64 = self.max_ordinal_present();
9297            encoder.write_num(max_ordinal, offset);
9298            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9299            // Calling encoder.out_of_line_offset(0) is not allowed.
9300            if max_ordinal == 0 {
9301                return Ok(());
9302            }
9303            depth.increment()?;
9304            let envelope_size = 8;
9305            let bytes_len = max_ordinal as usize * envelope_size;
9306            #[allow(unused_variables)]
9307            let offset = encoder.out_of_line_offset(bytes_len);
9308            let mut _prev_end_offset: usize = 0;
9309            if 1 > max_ordinal {
9310                return Ok(());
9311            }
9312
9313            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9314            // are envelope_size bytes.
9315            let cur_offset: usize = (1 - 1) * envelope_size;
9316
9317            // Zero reserved fields.
9318            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9319
9320            // Safety:
9321            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9322            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9323            //   envelope_size bytes, there is always sufficient room.
9324            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
9325                self.name.as_ref().map(
9326                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
9327                ),
9328                encoder,
9329                offset + cur_offset,
9330                depth,
9331            )?;
9332
9333            _prev_end_offset = cur_offset + envelope_size;
9334            if 2 > max_ordinal {
9335                return Ok(());
9336            }
9337
9338            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9339            // are envelope_size bytes.
9340            let cur_offset: usize = (2 - 1) * envelope_size;
9341
9342            // Zero reserved fields.
9343            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9344
9345            // Safety:
9346            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9347            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9348            //   envelope_size bytes, there is always sufficient room.
9349            fidl::encoding::encode_in_envelope_optional::<EnvironmentExtends, D>(
9350                self.extends
9351                    .as_ref()
9352                    .map(<EnvironmentExtends as fidl::encoding::ValueTypeMarker>::borrow),
9353                encoder,
9354                offset + cur_offset,
9355                depth,
9356            )?;
9357
9358            _prev_end_offset = cur_offset + envelope_size;
9359            if 3 > max_ordinal {
9360                return Ok(());
9361            }
9362
9363            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9364            // are envelope_size bytes.
9365            let cur_offset: usize = (3 - 1) * envelope_size;
9366
9367            // Zero reserved fields.
9368            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9369
9370            // Safety:
9371            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9372            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9373            //   envelope_size bytes, there is always sufficient room.
9374            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<RunnerRegistration>, D>(
9375            self.runners.as_ref().map(<fidl::encoding::UnboundedVector<RunnerRegistration> as fidl::encoding::ValueTypeMarker>::borrow),
9376            encoder, offset + cur_offset, depth
9377        )?;
9378
9379            _prev_end_offset = cur_offset + envelope_size;
9380            if 4 > max_ordinal {
9381                return Ok(());
9382            }
9383
9384            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9385            // are envelope_size bytes.
9386            let cur_offset: usize = (4 - 1) * envelope_size;
9387
9388            // Zero reserved fields.
9389            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9390
9391            // Safety:
9392            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9393            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9394            //   envelope_size bytes, there is always sufficient room.
9395            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ResolverRegistration>, D>(
9396            self.resolvers.as_ref().map(<fidl::encoding::UnboundedVector<ResolverRegistration> as fidl::encoding::ValueTypeMarker>::borrow),
9397            encoder, offset + cur_offset, depth
9398        )?;
9399
9400            _prev_end_offset = cur_offset + envelope_size;
9401            if 5 > max_ordinal {
9402                return Ok(());
9403            }
9404
9405            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9406            // are envelope_size bytes.
9407            let cur_offset: usize = (5 - 1) * envelope_size;
9408
9409            // Zero reserved fields.
9410            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9411
9412            // Safety:
9413            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9414            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9415            //   envelope_size bytes, there is always sufficient room.
9416            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<DebugRegistration>, D>(
9417            self.debug_capabilities.as_ref().map(<fidl::encoding::UnboundedVector<DebugRegistration> as fidl::encoding::ValueTypeMarker>::borrow),
9418            encoder, offset + cur_offset, depth
9419        )?;
9420
9421            _prev_end_offset = cur_offset + envelope_size;
9422            if 6 > max_ordinal {
9423                return Ok(());
9424            }
9425
9426            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9427            // are envelope_size bytes.
9428            let cur_offset: usize = (6 - 1) * envelope_size;
9429
9430            // Zero reserved fields.
9431            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9432
9433            // Safety:
9434            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9435            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9436            //   envelope_size bytes, there is always sufficient room.
9437            fidl::encoding::encode_in_envelope_optional::<u32, D>(
9438                self.stop_timeout_ms.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
9439                encoder,
9440                offset + cur_offset,
9441                depth,
9442            )?;
9443
9444            _prev_end_offset = cur_offset + envelope_size;
9445
9446            Ok(())
9447        }
9448    }
9449
9450    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Environment {
9451        #[inline(always)]
9452        fn new_empty() -> Self {
9453            Self::default()
9454        }
9455
9456        unsafe fn decode(
9457            &mut self,
9458            decoder: &mut fidl::encoding::Decoder<'_, D>,
9459            offset: usize,
9460            mut depth: fidl::encoding::Depth,
9461        ) -> fidl::Result<()> {
9462            decoder.debug_check_bounds::<Self>(offset);
9463            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9464                None => return Err(fidl::Error::NotNullable),
9465                Some(len) => len,
9466            };
9467            // Calling decoder.out_of_line_offset(0) is not allowed.
9468            if len == 0 {
9469                return Ok(());
9470            };
9471            depth.increment()?;
9472            let envelope_size = 8;
9473            let bytes_len = len * envelope_size;
9474            let offset = decoder.out_of_line_offset(bytes_len)?;
9475            // Decode the envelope for each type.
9476            let mut _next_ordinal_to_read = 0;
9477            let mut next_offset = offset;
9478            let end_offset = offset + bytes_len;
9479            _next_ordinal_to_read += 1;
9480            if next_offset >= end_offset {
9481                return Ok(());
9482            }
9483
9484            // Decode unknown envelopes for gaps in ordinals.
9485            while _next_ordinal_to_read < 1 {
9486                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9487                _next_ordinal_to_read += 1;
9488                next_offset += envelope_size;
9489            }
9490
9491            let next_out_of_line = decoder.next_out_of_line();
9492            let handles_before = decoder.remaining_handles();
9493            if let Some((inlined, num_bytes, num_handles)) =
9494                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9495            {
9496                let member_inline_size =
9497                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
9498                        decoder.context,
9499                    );
9500                if inlined != (member_inline_size <= 4) {
9501                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9502                }
9503                let inner_offset;
9504                let mut inner_depth = depth.clone();
9505                if inlined {
9506                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9507                    inner_offset = next_offset;
9508                } else {
9509                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9510                    inner_depth.increment()?;
9511                }
9512                let val_ref = self
9513                    .name
9514                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
9515                fidl::decode!(
9516                    fidl::encoding::BoundedString<100>,
9517                    D,
9518                    val_ref,
9519                    decoder,
9520                    inner_offset,
9521                    inner_depth
9522                )?;
9523                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9524                {
9525                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9526                }
9527                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9528                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9529                }
9530            }
9531
9532            next_offset += envelope_size;
9533            _next_ordinal_to_read += 1;
9534            if next_offset >= end_offset {
9535                return Ok(());
9536            }
9537
9538            // Decode unknown envelopes for gaps in ordinals.
9539            while _next_ordinal_to_read < 2 {
9540                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9541                _next_ordinal_to_read += 1;
9542                next_offset += envelope_size;
9543            }
9544
9545            let next_out_of_line = decoder.next_out_of_line();
9546            let handles_before = decoder.remaining_handles();
9547            if let Some((inlined, num_bytes, num_handles)) =
9548                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9549            {
9550                let member_inline_size =
9551                    <EnvironmentExtends as fidl::encoding::TypeMarker>::inline_size(
9552                        decoder.context,
9553                    );
9554                if inlined != (member_inline_size <= 4) {
9555                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9556                }
9557                let inner_offset;
9558                let mut inner_depth = depth.clone();
9559                if inlined {
9560                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9561                    inner_offset = next_offset;
9562                } else {
9563                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9564                    inner_depth.increment()?;
9565                }
9566                let val_ref =
9567                    self.extends.get_or_insert_with(|| fidl::new_empty!(EnvironmentExtends, D));
9568                fidl::decode!(EnvironmentExtends, D, val_ref, decoder, inner_offset, inner_depth)?;
9569                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9570                {
9571                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9572                }
9573                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9574                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9575                }
9576            }
9577
9578            next_offset += envelope_size;
9579            _next_ordinal_to_read += 1;
9580            if next_offset >= end_offset {
9581                return Ok(());
9582            }
9583
9584            // Decode unknown envelopes for gaps in ordinals.
9585            while _next_ordinal_to_read < 3 {
9586                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9587                _next_ordinal_to_read += 1;
9588                next_offset += envelope_size;
9589            }
9590
9591            let next_out_of_line = decoder.next_out_of_line();
9592            let handles_before = decoder.remaining_handles();
9593            if let Some((inlined, num_bytes, num_handles)) =
9594                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9595            {
9596                let member_inline_size = <fidl::encoding::UnboundedVector<RunnerRegistration> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9597                if inlined != (member_inline_size <= 4) {
9598                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9599                }
9600                let inner_offset;
9601                let mut inner_depth = depth.clone();
9602                if inlined {
9603                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9604                    inner_offset = next_offset;
9605                } else {
9606                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9607                    inner_depth.increment()?;
9608                }
9609                let val_ref = self.runners.get_or_insert_with(|| {
9610                    fidl::new_empty!(fidl::encoding::UnboundedVector<RunnerRegistration>, D)
9611                });
9612                fidl::decode!(
9613                    fidl::encoding::UnboundedVector<RunnerRegistration>,
9614                    D,
9615                    val_ref,
9616                    decoder,
9617                    inner_offset,
9618                    inner_depth
9619                )?;
9620                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9621                {
9622                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9623                }
9624                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9625                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9626                }
9627            }
9628
9629            next_offset += envelope_size;
9630            _next_ordinal_to_read += 1;
9631            if next_offset >= end_offset {
9632                return Ok(());
9633            }
9634
9635            // Decode unknown envelopes for gaps in ordinals.
9636            while _next_ordinal_to_read < 4 {
9637                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9638                _next_ordinal_to_read += 1;
9639                next_offset += envelope_size;
9640            }
9641
9642            let next_out_of_line = decoder.next_out_of_line();
9643            let handles_before = decoder.remaining_handles();
9644            if let Some((inlined, num_bytes, num_handles)) =
9645                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9646            {
9647                let member_inline_size = <fidl::encoding::UnboundedVector<ResolverRegistration> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9648                if inlined != (member_inline_size <= 4) {
9649                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9650                }
9651                let inner_offset;
9652                let mut inner_depth = depth.clone();
9653                if inlined {
9654                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9655                    inner_offset = next_offset;
9656                } else {
9657                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9658                    inner_depth.increment()?;
9659                }
9660                let val_ref = self.resolvers.get_or_insert_with(|| {
9661                    fidl::new_empty!(fidl::encoding::UnboundedVector<ResolverRegistration>, D)
9662                });
9663                fidl::decode!(
9664                    fidl::encoding::UnboundedVector<ResolverRegistration>,
9665                    D,
9666                    val_ref,
9667                    decoder,
9668                    inner_offset,
9669                    inner_depth
9670                )?;
9671                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9672                {
9673                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9674                }
9675                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9676                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9677                }
9678            }
9679
9680            next_offset += envelope_size;
9681            _next_ordinal_to_read += 1;
9682            if next_offset >= end_offset {
9683                return Ok(());
9684            }
9685
9686            // Decode unknown envelopes for gaps in ordinals.
9687            while _next_ordinal_to_read < 5 {
9688                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9689                _next_ordinal_to_read += 1;
9690                next_offset += envelope_size;
9691            }
9692
9693            let next_out_of_line = decoder.next_out_of_line();
9694            let handles_before = decoder.remaining_handles();
9695            if let Some((inlined, num_bytes, num_handles)) =
9696                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9697            {
9698                let member_inline_size = <fidl::encoding::UnboundedVector<DebugRegistration> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9699                if inlined != (member_inline_size <= 4) {
9700                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9701                }
9702                let inner_offset;
9703                let mut inner_depth = depth.clone();
9704                if inlined {
9705                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9706                    inner_offset = next_offset;
9707                } else {
9708                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9709                    inner_depth.increment()?;
9710                }
9711                let val_ref = self.debug_capabilities.get_or_insert_with(|| {
9712                    fidl::new_empty!(fidl::encoding::UnboundedVector<DebugRegistration>, D)
9713                });
9714                fidl::decode!(
9715                    fidl::encoding::UnboundedVector<DebugRegistration>,
9716                    D,
9717                    val_ref,
9718                    decoder,
9719                    inner_offset,
9720                    inner_depth
9721                )?;
9722                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9723                {
9724                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9725                }
9726                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9727                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9728                }
9729            }
9730
9731            next_offset += envelope_size;
9732            _next_ordinal_to_read += 1;
9733            if next_offset >= end_offset {
9734                return Ok(());
9735            }
9736
9737            // Decode unknown envelopes for gaps in ordinals.
9738            while _next_ordinal_to_read < 6 {
9739                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9740                _next_ordinal_to_read += 1;
9741                next_offset += envelope_size;
9742            }
9743
9744            let next_out_of_line = decoder.next_out_of_line();
9745            let handles_before = decoder.remaining_handles();
9746            if let Some((inlined, num_bytes, num_handles)) =
9747                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9748            {
9749                let member_inline_size =
9750                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9751                if inlined != (member_inline_size <= 4) {
9752                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9753                }
9754                let inner_offset;
9755                let mut inner_depth = depth.clone();
9756                if inlined {
9757                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9758                    inner_offset = next_offset;
9759                } else {
9760                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9761                    inner_depth.increment()?;
9762                }
9763                let val_ref = self.stop_timeout_ms.get_or_insert_with(|| fidl::new_empty!(u32, D));
9764                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
9765                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9766                {
9767                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9768                }
9769                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9770                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9771                }
9772            }
9773
9774            next_offset += envelope_size;
9775
9776            // Decode the remaining unknown envelopes.
9777            while next_offset < end_offset {
9778                _next_ordinal_to_read += 1;
9779                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9780                next_offset += envelope_size;
9781            }
9782
9783            Ok(())
9784        }
9785    }
9786
9787    impl EventStream {
9788        #[inline(always)]
9789        fn max_ordinal_present(&self) -> u64 {
9790            if let Some(_) = self.name {
9791                return 1;
9792            }
9793            0
9794        }
9795    }
9796
9797    impl fidl::encoding::ValueTypeMarker for EventStream {
9798        type Borrowed<'a> = &'a Self;
9799        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9800            value
9801        }
9802    }
9803
9804    unsafe impl fidl::encoding::TypeMarker for EventStream {
9805        type Owned = Self;
9806
9807        #[inline(always)]
9808        fn inline_align(_context: fidl::encoding::Context) -> usize {
9809            8
9810        }
9811
9812        #[inline(always)]
9813        fn inline_size(_context: fidl::encoding::Context) -> usize {
9814            16
9815        }
9816    }
9817
9818    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EventStream, D>
9819        for &EventStream
9820    {
9821        unsafe fn encode(
9822            self,
9823            encoder: &mut fidl::encoding::Encoder<'_, D>,
9824            offset: usize,
9825            mut depth: fidl::encoding::Depth,
9826        ) -> fidl::Result<()> {
9827            encoder.debug_check_bounds::<EventStream>(offset);
9828            // Vector header
9829            let max_ordinal: u64 = self.max_ordinal_present();
9830            encoder.write_num(max_ordinal, offset);
9831            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9832            // Calling encoder.out_of_line_offset(0) is not allowed.
9833            if max_ordinal == 0 {
9834                return Ok(());
9835            }
9836            depth.increment()?;
9837            let envelope_size = 8;
9838            let bytes_len = max_ordinal as usize * envelope_size;
9839            #[allow(unused_variables)]
9840            let offset = encoder.out_of_line_offset(bytes_len);
9841            let mut _prev_end_offset: usize = 0;
9842            if 1 > max_ordinal {
9843                return Ok(());
9844            }
9845
9846            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9847            // are envelope_size bytes.
9848            let cur_offset: usize = (1 - 1) * envelope_size;
9849
9850            // Zero reserved fields.
9851            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9852
9853            // Safety:
9854            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9855            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9856            //   envelope_size bytes, there is always sufficient room.
9857            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
9858                self.name.as_ref().map(
9859                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
9860                ),
9861                encoder,
9862                offset + cur_offset,
9863                depth,
9864            )?;
9865
9866            _prev_end_offset = cur_offset + envelope_size;
9867
9868            Ok(())
9869        }
9870    }
9871
9872    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EventStream {
9873        #[inline(always)]
9874        fn new_empty() -> Self {
9875            Self::default()
9876        }
9877
9878        unsafe fn decode(
9879            &mut self,
9880            decoder: &mut fidl::encoding::Decoder<'_, D>,
9881            offset: usize,
9882            mut depth: fidl::encoding::Depth,
9883        ) -> fidl::Result<()> {
9884            decoder.debug_check_bounds::<Self>(offset);
9885            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9886                None => return Err(fidl::Error::NotNullable),
9887                Some(len) => len,
9888            };
9889            // Calling decoder.out_of_line_offset(0) is not allowed.
9890            if len == 0 {
9891                return Ok(());
9892            };
9893            depth.increment()?;
9894            let envelope_size = 8;
9895            let bytes_len = len * envelope_size;
9896            let offset = decoder.out_of_line_offset(bytes_len)?;
9897            // Decode the envelope for each type.
9898            let mut _next_ordinal_to_read = 0;
9899            let mut next_offset = offset;
9900            let end_offset = offset + bytes_len;
9901            _next_ordinal_to_read += 1;
9902            if next_offset >= end_offset {
9903                return Ok(());
9904            }
9905
9906            // Decode unknown envelopes for gaps in ordinals.
9907            while _next_ordinal_to_read < 1 {
9908                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9909                _next_ordinal_to_read += 1;
9910                next_offset += envelope_size;
9911            }
9912
9913            let next_out_of_line = decoder.next_out_of_line();
9914            let handles_before = decoder.remaining_handles();
9915            if let Some((inlined, num_bytes, num_handles)) =
9916                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9917            {
9918                let member_inline_size =
9919                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
9920                        decoder.context,
9921                    );
9922                if inlined != (member_inline_size <= 4) {
9923                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9924                }
9925                let inner_offset;
9926                let mut inner_depth = depth.clone();
9927                if inlined {
9928                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9929                    inner_offset = next_offset;
9930                } else {
9931                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9932                    inner_depth.increment()?;
9933                }
9934                let val_ref = self
9935                    .name
9936                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
9937                fidl::decode!(
9938                    fidl::encoding::BoundedString<100>,
9939                    D,
9940                    val_ref,
9941                    decoder,
9942                    inner_offset,
9943                    inner_depth
9944                )?;
9945                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9946                {
9947                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9948                }
9949                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9950                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9951                }
9952            }
9953
9954            next_offset += envelope_size;
9955
9956            // Decode the remaining unknown envelopes.
9957            while next_offset < end_offset {
9958                _next_ordinal_to_read += 1;
9959                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9960                next_offset += envelope_size;
9961            }
9962
9963            Ok(())
9964        }
9965    }
9966
9967    impl EventSubscription {
9968        #[inline(always)]
9969        fn max_ordinal_present(&self) -> u64 {
9970            if let Some(_) = self.event_name {
9971                return 1;
9972            }
9973            0
9974        }
9975    }
9976
9977    impl fidl::encoding::ValueTypeMarker for EventSubscription {
9978        type Borrowed<'a> = &'a Self;
9979        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9980            value
9981        }
9982    }
9983
9984    unsafe impl fidl::encoding::TypeMarker for EventSubscription {
9985        type Owned = Self;
9986
9987        #[inline(always)]
9988        fn inline_align(_context: fidl::encoding::Context) -> usize {
9989            8
9990        }
9991
9992        #[inline(always)]
9993        fn inline_size(_context: fidl::encoding::Context) -> usize {
9994            16
9995        }
9996    }
9997
9998    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EventSubscription, D>
9999        for &EventSubscription
10000    {
10001        unsafe fn encode(
10002            self,
10003            encoder: &mut fidl::encoding::Encoder<'_, D>,
10004            offset: usize,
10005            mut depth: fidl::encoding::Depth,
10006        ) -> fidl::Result<()> {
10007            encoder.debug_check_bounds::<EventSubscription>(offset);
10008            // Vector header
10009            let max_ordinal: u64 = self.max_ordinal_present();
10010            encoder.write_num(max_ordinal, offset);
10011            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10012            // Calling encoder.out_of_line_offset(0) is not allowed.
10013            if max_ordinal == 0 {
10014                return Ok(());
10015            }
10016            depth.increment()?;
10017            let envelope_size = 8;
10018            let bytes_len = max_ordinal as usize * envelope_size;
10019            #[allow(unused_variables)]
10020            let offset = encoder.out_of_line_offset(bytes_len);
10021            let mut _prev_end_offset: usize = 0;
10022            if 1 > max_ordinal {
10023                return Ok(());
10024            }
10025
10026            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10027            // are envelope_size bytes.
10028            let cur_offset: usize = (1 - 1) * envelope_size;
10029
10030            // Zero reserved fields.
10031            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10032
10033            // Safety:
10034            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10035            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10036            //   envelope_size bytes, there is always sufficient room.
10037            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
10038                self.event_name.as_ref().map(
10039                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
10040                ),
10041                encoder,
10042                offset + cur_offset,
10043                depth,
10044            )?;
10045
10046            _prev_end_offset = cur_offset + envelope_size;
10047
10048            Ok(())
10049        }
10050    }
10051
10052    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EventSubscription {
10053        #[inline(always)]
10054        fn new_empty() -> Self {
10055            Self::default()
10056        }
10057
10058        unsafe fn decode(
10059            &mut self,
10060            decoder: &mut fidl::encoding::Decoder<'_, D>,
10061            offset: usize,
10062            mut depth: fidl::encoding::Depth,
10063        ) -> fidl::Result<()> {
10064            decoder.debug_check_bounds::<Self>(offset);
10065            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10066                None => return Err(fidl::Error::NotNullable),
10067                Some(len) => len,
10068            };
10069            // Calling decoder.out_of_line_offset(0) is not allowed.
10070            if len == 0 {
10071                return Ok(());
10072            };
10073            depth.increment()?;
10074            let envelope_size = 8;
10075            let bytes_len = len * envelope_size;
10076            let offset = decoder.out_of_line_offset(bytes_len)?;
10077            // Decode the envelope for each type.
10078            let mut _next_ordinal_to_read = 0;
10079            let mut next_offset = offset;
10080            let end_offset = offset + bytes_len;
10081            _next_ordinal_to_read += 1;
10082            if next_offset >= end_offset {
10083                return Ok(());
10084            }
10085
10086            // Decode unknown envelopes for gaps in ordinals.
10087            while _next_ordinal_to_read < 1 {
10088                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10089                _next_ordinal_to_read += 1;
10090                next_offset += envelope_size;
10091            }
10092
10093            let next_out_of_line = decoder.next_out_of_line();
10094            let handles_before = decoder.remaining_handles();
10095            if let Some((inlined, num_bytes, num_handles)) =
10096                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10097            {
10098                let member_inline_size =
10099                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
10100                        decoder.context,
10101                    );
10102                if inlined != (member_inline_size <= 4) {
10103                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10104                }
10105                let inner_offset;
10106                let mut inner_depth = depth.clone();
10107                if inlined {
10108                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10109                    inner_offset = next_offset;
10110                } else {
10111                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10112                    inner_depth.increment()?;
10113                }
10114                let val_ref = self
10115                    .event_name
10116                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
10117                fidl::decode!(
10118                    fidl::encoding::BoundedString<100>,
10119                    D,
10120                    val_ref,
10121                    decoder,
10122                    inner_offset,
10123                    inner_depth
10124                )?;
10125                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10126                {
10127                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10128                }
10129                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10130                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10131                }
10132            }
10133
10134            next_offset += envelope_size;
10135
10136            // Decode the remaining unknown envelopes.
10137            while next_offset < end_offset {
10138                _next_ordinal_to_read += 1;
10139                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10140                next_offset += envelope_size;
10141            }
10142
10143            Ok(())
10144        }
10145    }
10146
10147    impl ExposeConfiguration {
10148        #[inline(always)]
10149        fn max_ordinal_present(&self) -> u64 {
10150            if let Some(_) = self.source_dictionary {
10151                return 6;
10152            }
10153            if let Some(_) = self.availability {
10154                return 5;
10155            }
10156            if let Some(_) = self.target_name {
10157                return 4;
10158            }
10159            if let Some(_) = self.target {
10160                return 3;
10161            }
10162            if let Some(_) = self.source_name {
10163                return 2;
10164            }
10165            if let Some(_) = self.source {
10166                return 1;
10167            }
10168            0
10169        }
10170    }
10171
10172    impl fidl::encoding::ValueTypeMarker for ExposeConfiguration {
10173        type Borrowed<'a> = &'a Self;
10174        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10175            value
10176        }
10177    }
10178
10179    unsafe impl fidl::encoding::TypeMarker for ExposeConfiguration {
10180        type Owned = Self;
10181
10182        #[inline(always)]
10183        fn inline_align(_context: fidl::encoding::Context) -> usize {
10184            8
10185        }
10186
10187        #[inline(always)]
10188        fn inline_size(_context: fidl::encoding::Context) -> usize {
10189            16
10190        }
10191    }
10192
10193    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExposeConfiguration, D>
10194        for &ExposeConfiguration
10195    {
10196        unsafe fn encode(
10197            self,
10198            encoder: &mut fidl::encoding::Encoder<'_, D>,
10199            offset: usize,
10200            mut depth: fidl::encoding::Depth,
10201        ) -> fidl::Result<()> {
10202            encoder.debug_check_bounds::<ExposeConfiguration>(offset);
10203            // Vector header
10204            let max_ordinal: u64 = self.max_ordinal_present();
10205            encoder.write_num(max_ordinal, offset);
10206            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10207            // Calling encoder.out_of_line_offset(0) is not allowed.
10208            if max_ordinal == 0 {
10209                return Ok(());
10210            }
10211            depth.increment()?;
10212            let envelope_size = 8;
10213            let bytes_len = max_ordinal as usize * envelope_size;
10214            #[allow(unused_variables)]
10215            let offset = encoder.out_of_line_offset(bytes_len);
10216            let mut _prev_end_offset: usize = 0;
10217            if 1 > max_ordinal {
10218                return Ok(());
10219            }
10220
10221            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10222            // are envelope_size bytes.
10223            let cur_offset: usize = (1 - 1) * envelope_size;
10224
10225            // Zero reserved fields.
10226            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10227
10228            // Safety:
10229            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10230            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10231            //   envelope_size bytes, there is always sufficient room.
10232            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
10233                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
10234                encoder,
10235                offset + cur_offset,
10236                depth,
10237            )?;
10238
10239            _prev_end_offset = cur_offset + envelope_size;
10240            if 2 > max_ordinal {
10241                return Ok(());
10242            }
10243
10244            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10245            // are envelope_size bytes.
10246            let cur_offset: usize = (2 - 1) * envelope_size;
10247
10248            // Zero reserved fields.
10249            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10250
10251            // Safety:
10252            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10253            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10254            //   envelope_size bytes, there is always sufficient room.
10255            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
10256                self.source_name.as_ref().map(
10257                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
10258                ),
10259                encoder,
10260                offset + cur_offset,
10261                depth,
10262            )?;
10263
10264            _prev_end_offset = cur_offset + envelope_size;
10265            if 3 > max_ordinal {
10266                return Ok(());
10267            }
10268
10269            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10270            // are envelope_size bytes.
10271            let cur_offset: usize = (3 - 1) * envelope_size;
10272
10273            // Zero reserved fields.
10274            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10275
10276            // Safety:
10277            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10278            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10279            //   envelope_size bytes, there is always sufficient room.
10280            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
10281                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
10282                encoder,
10283                offset + cur_offset,
10284                depth,
10285            )?;
10286
10287            _prev_end_offset = cur_offset + envelope_size;
10288            if 4 > max_ordinal {
10289                return Ok(());
10290            }
10291
10292            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10293            // are envelope_size bytes.
10294            let cur_offset: usize = (4 - 1) * envelope_size;
10295
10296            // Zero reserved fields.
10297            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10298
10299            // Safety:
10300            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10301            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10302            //   envelope_size bytes, there is always sufficient room.
10303            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
10304                self.target_name.as_ref().map(
10305                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
10306                ),
10307                encoder,
10308                offset + cur_offset,
10309                depth,
10310            )?;
10311
10312            _prev_end_offset = cur_offset + envelope_size;
10313            if 5 > max_ordinal {
10314                return Ok(());
10315            }
10316
10317            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10318            // are envelope_size bytes.
10319            let cur_offset: usize = (5 - 1) * envelope_size;
10320
10321            // Zero reserved fields.
10322            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10323
10324            // Safety:
10325            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10326            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10327            //   envelope_size bytes, there is always sufficient room.
10328            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
10329                self.availability
10330                    .as_ref()
10331                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
10332                encoder,
10333                offset + cur_offset,
10334                depth,
10335            )?;
10336
10337            _prev_end_offset = cur_offset + envelope_size;
10338            if 6 > max_ordinal {
10339                return Ok(());
10340            }
10341
10342            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10343            // are envelope_size bytes.
10344            let cur_offset: usize = (6 - 1) * envelope_size;
10345
10346            // Zero reserved fields.
10347            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10348
10349            // Safety:
10350            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10351            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10352            //   envelope_size bytes, there is always sufficient room.
10353            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
10354            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
10355            encoder, offset + cur_offset, depth
10356        )?;
10357
10358            _prev_end_offset = cur_offset + envelope_size;
10359
10360            Ok(())
10361        }
10362    }
10363
10364    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExposeConfiguration {
10365        #[inline(always)]
10366        fn new_empty() -> Self {
10367            Self::default()
10368        }
10369
10370        unsafe fn decode(
10371            &mut self,
10372            decoder: &mut fidl::encoding::Decoder<'_, D>,
10373            offset: usize,
10374            mut depth: fidl::encoding::Depth,
10375        ) -> fidl::Result<()> {
10376            decoder.debug_check_bounds::<Self>(offset);
10377            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10378                None => return Err(fidl::Error::NotNullable),
10379                Some(len) => len,
10380            };
10381            // Calling decoder.out_of_line_offset(0) is not allowed.
10382            if len == 0 {
10383                return Ok(());
10384            };
10385            depth.increment()?;
10386            let envelope_size = 8;
10387            let bytes_len = len * envelope_size;
10388            let offset = decoder.out_of_line_offset(bytes_len)?;
10389            // Decode the envelope for each type.
10390            let mut _next_ordinal_to_read = 0;
10391            let mut next_offset = offset;
10392            let end_offset = offset + bytes_len;
10393            _next_ordinal_to_read += 1;
10394            if next_offset >= end_offset {
10395                return Ok(());
10396            }
10397
10398            // Decode unknown envelopes for gaps in ordinals.
10399            while _next_ordinal_to_read < 1 {
10400                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10401                _next_ordinal_to_read += 1;
10402                next_offset += envelope_size;
10403            }
10404
10405            let next_out_of_line = decoder.next_out_of_line();
10406            let handles_before = decoder.remaining_handles();
10407            if let Some((inlined, num_bytes, num_handles)) =
10408                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10409            {
10410                let member_inline_size =
10411                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10412                if inlined != (member_inline_size <= 4) {
10413                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10414                }
10415                let inner_offset;
10416                let mut inner_depth = depth.clone();
10417                if inlined {
10418                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10419                    inner_offset = next_offset;
10420                } else {
10421                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10422                    inner_depth.increment()?;
10423                }
10424                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
10425                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
10426                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10427                {
10428                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10429                }
10430                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10431                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10432                }
10433            }
10434
10435            next_offset += envelope_size;
10436            _next_ordinal_to_read += 1;
10437            if next_offset >= end_offset {
10438                return Ok(());
10439            }
10440
10441            // Decode unknown envelopes for gaps in ordinals.
10442            while _next_ordinal_to_read < 2 {
10443                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10444                _next_ordinal_to_read += 1;
10445                next_offset += envelope_size;
10446            }
10447
10448            let next_out_of_line = decoder.next_out_of_line();
10449            let handles_before = decoder.remaining_handles();
10450            if let Some((inlined, num_bytes, num_handles)) =
10451                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10452            {
10453                let member_inline_size =
10454                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
10455                        decoder.context,
10456                    );
10457                if inlined != (member_inline_size <= 4) {
10458                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10459                }
10460                let inner_offset;
10461                let mut inner_depth = depth.clone();
10462                if inlined {
10463                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10464                    inner_offset = next_offset;
10465                } else {
10466                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10467                    inner_depth.increment()?;
10468                }
10469                let val_ref = self
10470                    .source_name
10471                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
10472                fidl::decode!(
10473                    fidl::encoding::BoundedString<100>,
10474                    D,
10475                    val_ref,
10476                    decoder,
10477                    inner_offset,
10478                    inner_depth
10479                )?;
10480                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10481                {
10482                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10483                }
10484                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10485                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10486                }
10487            }
10488
10489            next_offset += envelope_size;
10490            _next_ordinal_to_read += 1;
10491            if next_offset >= end_offset {
10492                return Ok(());
10493            }
10494
10495            // Decode unknown envelopes for gaps in ordinals.
10496            while _next_ordinal_to_read < 3 {
10497                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10498                _next_ordinal_to_read += 1;
10499                next_offset += envelope_size;
10500            }
10501
10502            let next_out_of_line = decoder.next_out_of_line();
10503            let handles_before = decoder.remaining_handles();
10504            if let Some((inlined, num_bytes, num_handles)) =
10505                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10506            {
10507                let member_inline_size =
10508                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10509                if inlined != (member_inline_size <= 4) {
10510                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10511                }
10512                let inner_offset;
10513                let mut inner_depth = depth.clone();
10514                if inlined {
10515                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10516                    inner_offset = next_offset;
10517                } else {
10518                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10519                    inner_depth.increment()?;
10520                }
10521                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
10522                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
10523                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10524                {
10525                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10526                }
10527                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10528                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10529                }
10530            }
10531
10532            next_offset += envelope_size;
10533            _next_ordinal_to_read += 1;
10534            if next_offset >= end_offset {
10535                return Ok(());
10536            }
10537
10538            // Decode unknown envelopes for gaps in ordinals.
10539            while _next_ordinal_to_read < 4 {
10540                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10541                _next_ordinal_to_read += 1;
10542                next_offset += envelope_size;
10543            }
10544
10545            let next_out_of_line = decoder.next_out_of_line();
10546            let handles_before = decoder.remaining_handles();
10547            if let Some((inlined, num_bytes, num_handles)) =
10548                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10549            {
10550                let member_inline_size =
10551                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
10552                        decoder.context,
10553                    );
10554                if inlined != (member_inline_size <= 4) {
10555                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10556                }
10557                let inner_offset;
10558                let mut inner_depth = depth.clone();
10559                if inlined {
10560                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10561                    inner_offset = next_offset;
10562                } else {
10563                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10564                    inner_depth.increment()?;
10565                }
10566                let val_ref = self
10567                    .target_name
10568                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
10569                fidl::decode!(
10570                    fidl::encoding::BoundedString<100>,
10571                    D,
10572                    val_ref,
10573                    decoder,
10574                    inner_offset,
10575                    inner_depth
10576                )?;
10577                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10578                {
10579                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10580                }
10581                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10582                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10583                }
10584            }
10585
10586            next_offset += envelope_size;
10587            _next_ordinal_to_read += 1;
10588            if next_offset >= end_offset {
10589                return Ok(());
10590            }
10591
10592            // Decode unknown envelopes for gaps in ordinals.
10593            while _next_ordinal_to_read < 5 {
10594                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10595                _next_ordinal_to_read += 1;
10596                next_offset += envelope_size;
10597            }
10598
10599            let next_out_of_line = decoder.next_out_of_line();
10600            let handles_before = decoder.remaining_handles();
10601            if let Some((inlined, num_bytes, num_handles)) =
10602                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10603            {
10604                let member_inline_size =
10605                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10606                if inlined != (member_inline_size <= 4) {
10607                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10608                }
10609                let inner_offset;
10610                let mut inner_depth = depth.clone();
10611                if inlined {
10612                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10613                    inner_offset = next_offset;
10614                } else {
10615                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10616                    inner_depth.increment()?;
10617                }
10618                let val_ref =
10619                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
10620                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
10621                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10622                {
10623                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10624                }
10625                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10626                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10627                }
10628            }
10629
10630            next_offset += envelope_size;
10631            _next_ordinal_to_read += 1;
10632            if next_offset >= end_offset {
10633                return Ok(());
10634            }
10635
10636            // Decode unknown envelopes for gaps in ordinals.
10637            while _next_ordinal_to_read < 6 {
10638                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10639                _next_ordinal_to_read += 1;
10640                next_offset += envelope_size;
10641            }
10642
10643            let next_out_of_line = decoder.next_out_of_line();
10644            let handles_before = decoder.remaining_handles();
10645            if let Some((inlined, num_bytes, num_handles)) =
10646                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10647            {
10648                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10649                if inlined != (member_inline_size <= 4) {
10650                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10651                }
10652                let inner_offset;
10653                let mut inner_depth = depth.clone();
10654                if inlined {
10655                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10656                    inner_offset = next_offset;
10657                } else {
10658                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10659                    inner_depth.increment()?;
10660                }
10661                let val_ref = self.source_dictionary.get_or_insert_with(|| {
10662                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
10663                });
10664                fidl::decode!(
10665                    fidl::encoding::BoundedString<1024>,
10666                    D,
10667                    val_ref,
10668                    decoder,
10669                    inner_offset,
10670                    inner_depth
10671                )?;
10672                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10673                {
10674                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10675                }
10676                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10677                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10678                }
10679            }
10680
10681            next_offset += envelope_size;
10682
10683            // Decode the remaining unknown envelopes.
10684            while next_offset < end_offset {
10685                _next_ordinal_to_read += 1;
10686                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10687                next_offset += envelope_size;
10688            }
10689
10690            Ok(())
10691        }
10692    }
10693
10694    impl ExposeDictionary {
10695        #[inline(always)]
10696        fn max_ordinal_present(&self) -> u64 {
10697            if let Some(_) = self.source_dictionary {
10698                return 6;
10699            }
10700            if let Some(_) = self.availability {
10701                return 5;
10702            }
10703            if let Some(_) = self.target_name {
10704                return 4;
10705            }
10706            if let Some(_) = self.target {
10707                return 3;
10708            }
10709            if let Some(_) = self.source_name {
10710                return 2;
10711            }
10712            if let Some(_) = self.source {
10713                return 1;
10714            }
10715            0
10716        }
10717    }
10718
10719    impl fidl::encoding::ValueTypeMarker for ExposeDictionary {
10720        type Borrowed<'a> = &'a Self;
10721        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10722            value
10723        }
10724    }
10725
10726    unsafe impl fidl::encoding::TypeMarker for ExposeDictionary {
10727        type Owned = Self;
10728
10729        #[inline(always)]
10730        fn inline_align(_context: fidl::encoding::Context) -> usize {
10731            8
10732        }
10733
10734        #[inline(always)]
10735        fn inline_size(_context: fidl::encoding::Context) -> usize {
10736            16
10737        }
10738    }
10739
10740    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExposeDictionary, D>
10741        for &ExposeDictionary
10742    {
10743        unsafe fn encode(
10744            self,
10745            encoder: &mut fidl::encoding::Encoder<'_, D>,
10746            offset: usize,
10747            mut depth: fidl::encoding::Depth,
10748        ) -> fidl::Result<()> {
10749            encoder.debug_check_bounds::<ExposeDictionary>(offset);
10750            // Vector header
10751            let max_ordinal: u64 = self.max_ordinal_present();
10752            encoder.write_num(max_ordinal, offset);
10753            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10754            // Calling encoder.out_of_line_offset(0) is not allowed.
10755            if max_ordinal == 0 {
10756                return Ok(());
10757            }
10758            depth.increment()?;
10759            let envelope_size = 8;
10760            let bytes_len = max_ordinal as usize * envelope_size;
10761            #[allow(unused_variables)]
10762            let offset = encoder.out_of_line_offset(bytes_len);
10763            let mut _prev_end_offset: usize = 0;
10764            if 1 > max_ordinal {
10765                return Ok(());
10766            }
10767
10768            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10769            // are envelope_size bytes.
10770            let cur_offset: usize = (1 - 1) * envelope_size;
10771
10772            // Zero reserved fields.
10773            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10774
10775            // Safety:
10776            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10777            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10778            //   envelope_size bytes, there is always sufficient room.
10779            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
10780                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
10781                encoder,
10782                offset + cur_offset,
10783                depth,
10784            )?;
10785
10786            _prev_end_offset = cur_offset + envelope_size;
10787            if 2 > max_ordinal {
10788                return Ok(());
10789            }
10790
10791            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10792            // are envelope_size bytes.
10793            let cur_offset: usize = (2 - 1) * envelope_size;
10794
10795            // Zero reserved fields.
10796            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10797
10798            // Safety:
10799            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10800            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10801            //   envelope_size bytes, there is always sufficient room.
10802            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
10803                self.source_name.as_ref().map(
10804                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
10805                ),
10806                encoder,
10807                offset + cur_offset,
10808                depth,
10809            )?;
10810
10811            _prev_end_offset = cur_offset + envelope_size;
10812            if 3 > max_ordinal {
10813                return Ok(());
10814            }
10815
10816            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10817            // are envelope_size bytes.
10818            let cur_offset: usize = (3 - 1) * envelope_size;
10819
10820            // Zero reserved fields.
10821            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10822
10823            // Safety:
10824            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10825            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10826            //   envelope_size bytes, there is always sufficient room.
10827            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
10828                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
10829                encoder,
10830                offset + cur_offset,
10831                depth,
10832            )?;
10833
10834            _prev_end_offset = cur_offset + envelope_size;
10835            if 4 > max_ordinal {
10836                return Ok(());
10837            }
10838
10839            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10840            // are envelope_size bytes.
10841            let cur_offset: usize = (4 - 1) * envelope_size;
10842
10843            // Zero reserved fields.
10844            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10845
10846            // Safety:
10847            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10848            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10849            //   envelope_size bytes, there is always sufficient room.
10850            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
10851                self.target_name.as_ref().map(
10852                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
10853                ),
10854                encoder,
10855                offset + cur_offset,
10856                depth,
10857            )?;
10858
10859            _prev_end_offset = cur_offset + envelope_size;
10860            if 5 > max_ordinal {
10861                return Ok(());
10862            }
10863
10864            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10865            // are envelope_size bytes.
10866            let cur_offset: usize = (5 - 1) * envelope_size;
10867
10868            // Zero reserved fields.
10869            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10870
10871            // Safety:
10872            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10873            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10874            //   envelope_size bytes, there is always sufficient room.
10875            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
10876                self.availability
10877                    .as_ref()
10878                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
10879                encoder,
10880                offset + cur_offset,
10881                depth,
10882            )?;
10883
10884            _prev_end_offset = cur_offset + envelope_size;
10885            if 6 > max_ordinal {
10886                return Ok(());
10887            }
10888
10889            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10890            // are envelope_size bytes.
10891            let cur_offset: usize = (6 - 1) * envelope_size;
10892
10893            // Zero reserved fields.
10894            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10895
10896            // Safety:
10897            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10898            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10899            //   envelope_size bytes, there is always sufficient room.
10900            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
10901            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
10902            encoder, offset + cur_offset, depth
10903        )?;
10904
10905            _prev_end_offset = cur_offset + envelope_size;
10906
10907            Ok(())
10908        }
10909    }
10910
10911    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExposeDictionary {
10912        #[inline(always)]
10913        fn new_empty() -> Self {
10914            Self::default()
10915        }
10916
10917        unsafe fn decode(
10918            &mut self,
10919            decoder: &mut fidl::encoding::Decoder<'_, D>,
10920            offset: usize,
10921            mut depth: fidl::encoding::Depth,
10922        ) -> fidl::Result<()> {
10923            decoder.debug_check_bounds::<Self>(offset);
10924            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10925                None => return Err(fidl::Error::NotNullable),
10926                Some(len) => len,
10927            };
10928            // Calling decoder.out_of_line_offset(0) is not allowed.
10929            if len == 0 {
10930                return Ok(());
10931            };
10932            depth.increment()?;
10933            let envelope_size = 8;
10934            let bytes_len = len * envelope_size;
10935            let offset = decoder.out_of_line_offset(bytes_len)?;
10936            // Decode the envelope for each type.
10937            let mut _next_ordinal_to_read = 0;
10938            let mut next_offset = offset;
10939            let end_offset = offset + bytes_len;
10940            _next_ordinal_to_read += 1;
10941            if next_offset >= end_offset {
10942                return Ok(());
10943            }
10944
10945            // Decode unknown envelopes for gaps in ordinals.
10946            while _next_ordinal_to_read < 1 {
10947                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10948                _next_ordinal_to_read += 1;
10949                next_offset += envelope_size;
10950            }
10951
10952            let next_out_of_line = decoder.next_out_of_line();
10953            let handles_before = decoder.remaining_handles();
10954            if let Some((inlined, num_bytes, num_handles)) =
10955                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10956            {
10957                let member_inline_size =
10958                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10959                if inlined != (member_inline_size <= 4) {
10960                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10961                }
10962                let inner_offset;
10963                let mut inner_depth = depth.clone();
10964                if inlined {
10965                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10966                    inner_offset = next_offset;
10967                } else {
10968                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10969                    inner_depth.increment()?;
10970                }
10971                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
10972                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
10973                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10974                {
10975                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10976                }
10977                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10978                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10979                }
10980            }
10981
10982            next_offset += envelope_size;
10983            _next_ordinal_to_read += 1;
10984            if next_offset >= end_offset {
10985                return Ok(());
10986            }
10987
10988            // Decode unknown envelopes for gaps in ordinals.
10989            while _next_ordinal_to_read < 2 {
10990                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10991                _next_ordinal_to_read += 1;
10992                next_offset += envelope_size;
10993            }
10994
10995            let next_out_of_line = decoder.next_out_of_line();
10996            let handles_before = decoder.remaining_handles();
10997            if let Some((inlined, num_bytes, num_handles)) =
10998                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10999            {
11000                let member_inline_size =
11001                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11002                        decoder.context,
11003                    );
11004                if inlined != (member_inline_size <= 4) {
11005                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11006                }
11007                let inner_offset;
11008                let mut inner_depth = depth.clone();
11009                if inlined {
11010                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11011                    inner_offset = next_offset;
11012                } else {
11013                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11014                    inner_depth.increment()?;
11015                }
11016                let val_ref = self
11017                    .source_name
11018                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
11019                fidl::decode!(
11020                    fidl::encoding::BoundedString<100>,
11021                    D,
11022                    val_ref,
11023                    decoder,
11024                    inner_offset,
11025                    inner_depth
11026                )?;
11027                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11028                {
11029                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11030                }
11031                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11032                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11033                }
11034            }
11035
11036            next_offset += envelope_size;
11037            _next_ordinal_to_read += 1;
11038            if next_offset >= end_offset {
11039                return Ok(());
11040            }
11041
11042            // Decode unknown envelopes for gaps in ordinals.
11043            while _next_ordinal_to_read < 3 {
11044                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11045                _next_ordinal_to_read += 1;
11046                next_offset += envelope_size;
11047            }
11048
11049            let next_out_of_line = decoder.next_out_of_line();
11050            let handles_before = decoder.remaining_handles();
11051            if let Some((inlined, num_bytes, num_handles)) =
11052                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11053            {
11054                let member_inline_size =
11055                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11056                if inlined != (member_inline_size <= 4) {
11057                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11058                }
11059                let inner_offset;
11060                let mut inner_depth = depth.clone();
11061                if inlined {
11062                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11063                    inner_offset = next_offset;
11064                } else {
11065                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11066                    inner_depth.increment()?;
11067                }
11068                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
11069                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
11070                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11071                {
11072                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11073                }
11074                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11075                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11076                }
11077            }
11078
11079            next_offset += envelope_size;
11080            _next_ordinal_to_read += 1;
11081            if next_offset >= end_offset {
11082                return Ok(());
11083            }
11084
11085            // Decode unknown envelopes for gaps in ordinals.
11086            while _next_ordinal_to_read < 4 {
11087                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11088                _next_ordinal_to_read += 1;
11089                next_offset += envelope_size;
11090            }
11091
11092            let next_out_of_line = decoder.next_out_of_line();
11093            let handles_before = decoder.remaining_handles();
11094            if let Some((inlined, num_bytes, num_handles)) =
11095                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11096            {
11097                let member_inline_size =
11098                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11099                        decoder.context,
11100                    );
11101                if inlined != (member_inline_size <= 4) {
11102                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11103                }
11104                let inner_offset;
11105                let mut inner_depth = depth.clone();
11106                if inlined {
11107                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11108                    inner_offset = next_offset;
11109                } else {
11110                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11111                    inner_depth.increment()?;
11112                }
11113                let val_ref = self
11114                    .target_name
11115                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
11116                fidl::decode!(
11117                    fidl::encoding::BoundedString<100>,
11118                    D,
11119                    val_ref,
11120                    decoder,
11121                    inner_offset,
11122                    inner_depth
11123                )?;
11124                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11125                {
11126                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11127                }
11128                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11129                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11130                }
11131            }
11132
11133            next_offset += envelope_size;
11134            _next_ordinal_to_read += 1;
11135            if next_offset >= end_offset {
11136                return Ok(());
11137            }
11138
11139            // Decode unknown envelopes for gaps in ordinals.
11140            while _next_ordinal_to_read < 5 {
11141                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11142                _next_ordinal_to_read += 1;
11143                next_offset += envelope_size;
11144            }
11145
11146            let next_out_of_line = decoder.next_out_of_line();
11147            let handles_before = decoder.remaining_handles();
11148            if let Some((inlined, num_bytes, num_handles)) =
11149                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11150            {
11151                let member_inline_size =
11152                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11153                if inlined != (member_inline_size <= 4) {
11154                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11155                }
11156                let inner_offset;
11157                let mut inner_depth = depth.clone();
11158                if inlined {
11159                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11160                    inner_offset = next_offset;
11161                } else {
11162                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11163                    inner_depth.increment()?;
11164                }
11165                let val_ref =
11166                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
11167                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
11168                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11169                {
11170                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11171                }
11172                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11173                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11174                }
11175            }
11176
11177            next_offset += envelope_size;
11178            _next_ordinal_to_read += 1;
11179            if next_offset >= end_offset {
11180                return Ok(());
11181            }
11182
11183            // Decode unknown envelopes for gaps in ordinals.
11184            while _next_ordinal_to_read < 6 {
11185                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11186                _next_ordinal_to_read += 1;
11187                next_offset += envelope_size;
11188            }
11189
11190            let next_out_of_line = decoder.next_out_of_line();
11191            let handles_before = decoder.remaining_handles();
11192            if let Some((inlined, num_bytes, num_handles)) =
11193                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11194            {
11195                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11196                if inlined != (member_inline_size <= 4) {
11197                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11198                }
11199                let inner_offset;
11200                let mut inner_depth = depth.clone();
11201                if inlined {
11202                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11203                    inner_offset = next_offset;
11204                } else {
11205                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11206                    inner_depth.increment()?;
11207                }
11208                let val_ref = self.source_dictionary.get_or_insert_with(|| {
11209                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
11210                });
11211                fidl::decode!(
11212                    fidl::encoding::BoundedString<1024>,
11213                    D,
11214                    val_ref,
11215                    decoder,
11216                    inner_offset,
11217                    inner_depth
11218                )?;
11219                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11220                {
11221                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11222                }
11223                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11224                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11225                }
11226            }
11227
11228            next_offset += envelope_size;
11229
11230            // Decode the remaining unknown envelopes.
11231            while next_offset < end_offset {
11232                _next_ordinal_to_read += 1;
11233                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11234                next_offset += envelope_size;
11235            }
11236
11237            Ok(())
11238        }
11239    }
11240
11241    impl ExposeDirectory {
11242        #[inline(always)]
11243        fn max_ordinal_present(&self) -> u64 {
11244            if let Some(_) = self.source_dictionary {
11245                return 8;
11246            }
11247            if let Some(_) = self.availability {
11248                return 7;
11249            }
11250            if let Some(_) = self.subdir {
11251                return 6;
11252            }
11253            if let Some(_) = self.rights {
11254                return 5;
11255            }
11256            if let Some(_) = self.target_name {
11257                return 4;
11258            }
11259            if let Some(_) = self.target {
11260                return 3;
11261            }
11262            if let Some(_) = self.source_name {
11263                return 2;
11264            }
11265            if let Some(_) = self.source {
11266                return 1;
11267            }
11268            0
11269        }
11270    }
11271
11272    impl fidl::encoding::ValueTypeMarker for ExposeDirectory {
11273        type Borrowed<'a> = &'a Self;
11274        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11275            value
11276        }
11277    }
11278
11279    unsafe impl fidl::encoding::TypeMarker for ExposeDirectory {
11280        type Owned = Self;
11281
11282        #[inline(always)]
11283        fn inline_align(_context: fidl::encoding::Context) -> usize {
11284            8
11285        }
11286
11287        #[inline(always)]
11288        fn inline_size(_context: fidl::encoding::Context) -> usize {
11289            16
11290        }
11291    }
11292
11293    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExposeDirectory, D>
11294        for &ExposeDirectory
11295    {
11296        unsafe fn encode(
11297            self,
11298            encoder: &mut fidl::encoding::Encoder<'_, D>,
11299            offset: usize,
11300            mut depth: fidl::encoding::Depth,
11301        ) -> fidl::Result<()> {
11302            encoder.debug_check_bounds::<ExposeDirectory>(offset);
11303            // Vector header
11304            let max_ordinal: u64 = self.max_ordinal_present();
11305            encoder.write_num(max_ordinal, offset);
11306            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11307            // Calling encoder.out_of_line_offset(0) is not allowed.
11308            if max_ordinal == 0 {
11309                return Ok(());
11310            }
11311            depth.increment()?;
11312            let envelope_size = 8;
11313            let bytes_len = max_ordinal as usize * envelope_size;
11314            #[allow(unused_variables)]
11315            let offset = encoder.out_of_line_offset(bytes_len);
11316            let mut _prev_end_offset: usize = 0;
11317            if 1 > max_ordinal {
11318                return Ok(());
11319            }
11320
11321            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11322            // are envelope_size bytes.
11323            let cur_offset: usize = (1 - 1) * envelope_size;
11324
11325            // Zero reserved fields.
11326            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11327
11328            // Safety:
11329            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11330            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11331            //   envelope_size bytes, there is always sufficient room.
11332            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
11333                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
11334                encoder,
11335                offset + cur_offset,
11336                depth,
11337            )?;
11338
11339            _prev_end_offset = cur_offset + envelope_size;
11340            if 2 > max_ordinal {
11341                return Ok(());
11342            }
11343
11344            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11345            // are envelope_size bytes.
11346            let cur_offset: usize = (2 - 1) * envelope_size;
11347
11348            // Zero reserved fields.
11349            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11350
11351            // Safety:
11352            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11353            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11354            //   envelope_size bytes, there is always sufficient room.
11355            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
11356                self.source_name.as_ref().map(
11357                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
11358                ),
11359                encoder,
11360                offset + cur_offset,
11361                depth,
11362            )?;
11363
11364            _prev_end_offset = cur_offset + envelope_size;
11365            if 3 > max_ordinal {
11366                return Ok(());
11367            }
11368
11369            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11370            // are envelope_size bytes.
11371            let cur_offset: usize = (3 - 1) * envelope_size;
11372
11373            // Zero reserved fields.
11374            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11375
11376            // Safety:
11377            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11378            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11379            //   envelope_size bytes, there is always sufficient room.
11380            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
11381                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
11382                encoder,
11383                offset + cur_offset,
11384                depth,
11385            )?;
11386
11387            _prev_end_offset = cur_offset + envelope_size;
11388            if 4 > max_ordinal {
11389                return Ok(());
11390            }
11391
11392            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11393            // are envelope_size bytes.
11394            let cur_offset: usize = (4 - 1) * envelope_size;
11395
11396            // Zero reserved fields.
11397            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11398
11399            // Safety:
11400            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11401            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11402            //   envelope_size bytes, there is always sufficient room.
11403            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
11404                self.target_name.as_ref().map(
11405                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
11406                ),
11407                encoder,
11408                offset + cur_offset,
11409                depth,
11410            )?;
11411
11412            _prev_end_offset = cur_offset + envelope_size;
11413            if 5 > max_ordinal {
11414                return Ok(());
11415            }
11416
11417            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11418            // are envelope_size bytes.
11419            let cur_offset: usize = (5 - 1) * envelope_size;
11420
11421            // Zero reserved fields.
11422            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11423
11424            // Safety:
11425            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11426            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11427            //   envelope_size bytes, there is always sufficient room.
11428            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_io__common::Operations, D>(
11429            self.rights.as_ref().map(<fidl_fuchsia_io__common::Operations as fidl::encoding::ValueTypeMarker>::borrow),
11430            encoder, offset + cur_offset, depth
11431        )?;
11432
11433            _prev_end_offset = cur_offset + envelope_size;
11434            if 6 > max_ordinal {
11435                return Ok(());
11436            }
11437
11438            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11439            // are envelope_size bytes.
11440            let cur_offset: usize = (6 - 1) * envelope_size;
11441
11442            // Zero reserved fields.
11443            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11444
11445            // Safety:
11446            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11447            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11448            //   envelope_size bytes, there is always sufficient room.
11449            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
11450            self.subdir.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
11451            encoder, offset + cur_offset, depth
11452        )?;
11453
11454            _prev_end_offset = cur_offset + envelope_size;
11455            if 7 > max_ordinal {
11456                return Ok(());
11457            }
11458
11459            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11460            // are envelope_size bytes.
11461            let cur_offset: usize = (7 - 1) * envelope_size;
11462
11463            // Zero reserved fields.
11464            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11465
11466            // Safety:
11467            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11468            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11469            //   envelope_size bytes, there is always sufficient room.
11470            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
11471                self.availability
11472                    .as_ref()
11473                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
11474                encoder,
11475                offset + cur_offset,
11476                depth,
11477            )?;
11478
11479            _prev_end_offset = cur_offset + envelope_size;
11480            if 8 > max_ordinal {
11481                return Ok(());
11482            }
11483
11484            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11485            // are envelope_size bytes.
11486            let cur_offset: usize = (8 - 1) * envelope_size;
11487
11488            // Zero reserved fields.
11489            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11490
11491            // Safety:
11492            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11493            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11494            //   envelope_size bytes, there is always sufficient room.
11495            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
11496            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
11497            encoder, offset + cur_offset, depth
11498        )?;
11499
11500            _prev_end_offset = cur_offset + envelope_size;
11501
11502            Ok(())
11503        }
11504    }
11505
11506    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExposeDirectory {
11507        #[inline(always)]
11508        fn new_empty() -> Self {
11509            Self::default()
11510        }
11511
11512        unsafe fn decode(
11513            &mut self,
11514            decoder: &mut fidl::encoding::Decoder<'_, D>,
11515            offset: usize,
11516            mut depth: fidl::encoding::Depth,
11517        ) -> fidl::Result<()> {
11518            decoder.debug_check_bounds::<Self>(offset);
11519            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11520                None => return Err(fidl::Error::NotNullable),
11521                Some(len) => len,
11522            };
11523            // Calling decoder.out_of_line_offset(0) is not allowed.
11524            if len == 0 {
11525                return Ok(());
11526            };
11527            depth.increment()?;
11528            let envelope_size = 8;
11529            let bytes_len = len * envelope_size;
11530            let offset = decoder.out_of_line_offset(bytes_len)?;
11531            // Decode the envelope for each type.
11532            let mut _next_ordinal_to_read = 0;
11533            let mut next_offset = offset;
11534            let end_offset = offset + bytes_len;
11535            _next_ordinal_to_read += 1;
11536            if next_offset >= end_offset {
11537                return Ok(());
11538            }
11539
11540            // Decode unknown envelopes for gaps in ordinals.
11541            while _next_ordinal_to_read < 1 {
11542                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11543                _next_ordinal_to_read += 1;
11544                next_offset += envelope_size;
11545            }
11546
11547            let next_out_of_line = decoder.next_out_of_line();
11548            let handles_before = decoder.remaining_handles();
11549            if let Some((inlined, num_bytes, num_handles)) =
11550                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11551            {
11552                let member_inline_size =
11553                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11554                if inlined != (member_inline_size <= 4) {
11555                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11556                }
11557                let inner_offset;
11558                let mut inner_depth = depth.clone();
11559                if inlined {
11560                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11561                    inner_offset = next_offset;
11562                } else {
11563                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11564                    inner_depth.increment()?;
11565                }
11566                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
11567                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
11568                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11569                {
11570                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11571                }
11572                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11573                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11574                }
11575            }
11576
11577            next_offset += envelope_size;
11578            _next_ordinal_to_read += 1;
11579            if next_offset >= end_offset {
11580                return Ok(());
11581            }
11582
11583            // Decode unknown envelopes for gaps in ordinals.
11584            while _next_ordinal_to_read < 2 {
11585                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11586                _next_ordinal_to_read += 1;
11587                next_offset += envelope_size;
11588            }
11589
11590            let next_out_of_line = decoder.next_out_of_line();
11591            let handles_before = decoder.remaining_handles();
11592            if let Some((inlined, num_bytes, num_handles)) =
11593                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11594            {
11595                let member_inline_size =
11596                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11597                        decoder.context,
11598                    );
11599                if inlined != (member_inline_size <= 4) {
11600                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11601                }
11602                let inner_offset;
11603                let mut inner_depth = depth.clone();
11604                if inlined {
11605                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11606                    inner_offset = next_offset;
11607                } else {
11608                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11609                    inner_depth.increment()?;
11610                }
11611                let val_ref = self
11612                    .source_name
11613                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
11614                fidl::decode!(
11615                    fidl::encoding::BoundedString<100>,
11616                    D,
11617                    val_ref,
11618                    decoder,
11619                    inner_offset,
11620                    inner_depth
11621                )?;
11622                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11623                {
11624                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11625                }
11626                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11627                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11628                }
11629            }
11630
11631            next_offset += envelope_size;
11632            _next_ordinal_to_read += 1;
11633            if next_offset >= end_offset {
11634                return Ok(());
11635            }
11636
11637            // Decode unknown envelopes for gaps in ordinals.
11638            while _next_ordinal_to_read < 3 {
11639                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11640                _next_ordinal_to_read += 1;
11641                next_offset += envelope_size;
11642            }
11643
11644            let next_out_of_line = decoder.next_out_of_line();
11645            let handles_before = decoder.remaining_handles();
11646            if let Some((inlined, num_bytes, num_handles)) =
11647                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11648            {
11649                let member_inline_size =
11650                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11651                if inlined != (member_inline_size <= 4) {
11652                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11653                }
11654                let inner_offset;
11655                let mut inner_depth = depth.clone();
11656                if inlined {
11657                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11658                    inner_offset = next_offset;
11659                } else {
11660                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11661                    inner_depth.increment()?;
11662                }
11663                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
11664                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
11665                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11666                {
11667                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11668                }
11669                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11670                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11671                }
11672            }
11673
11674            next_offset += envelope_size;
11675            _next_ordinal_to_read += 1;
11676            if next_offset >= end_offset {
11677                return Ok(());
11678            }
11679
11680            // Decode unknown envelopes for gaps in ordinals.
11681            while _next_ordinal_to_read < 4 {
11682                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11683                _next_ordinal_to_read += 1;
11684                next_offset += envelope_size;
11685            }
11686
11687            let next_out_of_line = decoder.next_out_of_line();
11688            let handles_before = decoder.remaining_handles();
11689            if let Some((inlined, num_bytes, num_handles)) =
11690                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11691            {
11692                let member_inline_size =
11693                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
11694                        decoder.context,
11695                    );
11696                if inlined != (member_inline_size <= 4) {
11697                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11698                }
11699                let inner_offset;
11700                let mut inner_depth = depth.clone();
11701                if inlined {
11702                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11703                    inner_offset = next_offset;
11704                } else {
11705                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11706                    inner_depth.increment()?;
11707                }
11708                let val_ref = self
11709                    .target_name
11710                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
11711                fidl::decode!(
11712                    fidl::encoding::BoundedString<100>,
11713                    D,
11714                    val_ref,
11715                    decoder,
11716                    inner_offset,
11717                    inner_depth
11718                )?;
11719                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11720                {
11721                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11722                }
11723                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11724                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11725                }
11726            }
11727
11728            next_offset += envelope_size;
11729            _next_ordinal_to_read += 1;
11730            if next_offset >= end_offset {
11731                return Ok(());
11732            }
11733
11734            // Decode unknown envelopes for gaps in ordinals.
11735            while _next_ordinal_to_read < 5 {
11736                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11737                _next_ordinal_to_read += 1;
11738                next_offset += envelope_size;
11739            }
11740
11741            let next_out_of_line = decoder.next_out_of_line();
11742            let handles_before = decoder.remaining_handles();
11743            if let Some((inlined, num_bytes, num_handles)) =
11744                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11745            {
11746                let member_inline_size = <fidl_fuchsia_io__common::Operations as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11747                if inlined != (member_inline_size <= 4) {
11748                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11749                }
11750                let inner_offset;
11751                let mut inner_depth = depth.clone();
11752                if inlined {
11753                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11754                    inner_offset = next_offset;
11755                } else {
11756                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11757                    inner_depth.increment()?;
11758                }
11759                let val_ref = self.rights.get_or_insert_with(|| {
11760                    fidl::new_empty!(fidl_fuchsia_io__common::Operations, D)
11761                });
11762                fidl::decode!(
11763                    fidl_fuchsia_io__common::Operations,
11764                    D,
11765                    val_ref,
11766                    decoder,
11767                    inner_offset,
11768                    inner_depth
11769                )?;
11770                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11771                {
11772                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11773                }
11774                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11775                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11776                }
11777            }
11778
11779            next_offset += envelope_size;
11780            _next_ordinal_to_read += 1;
11781            if next_offset >= end_offset {
11782                return Ok(());
11783            }
11784
11785            // Decode unknown envelopes for gaps in ordinals.
11786            while _next_ordinal_to_read < 6 {
11787                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11788                _next_ordinal_to_read += 1;
11789                next_offset += envelope_size;
11790            }
11791
11792            let next_out_of_line = decoder.next_out_of_line();
11793            let handles_before = decoder.remaining_handles();
11794            if let Some((inlined, num_bytes, num_handles)) =
11795                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11796            {
11797                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11798                if inlined != (member_inline_size <= 4) {
11799                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11800                }
11801                let inner_offset;
11802                let mut inner_depth = depth.clone();
11803                if inlined {
11804                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11805                    inner_offset = next_offset;
11806                } else {
11807                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11808                    inner_depth.increment()?;
11809                }
11810                let val_ref = self.subdir.get_or_insert_with(|| {
11811                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
11812                });
11813                fidl::decode!(
11814                    fidl::encoding::BoundedString<1024>,
11815                    D,
11816                    val_ref,
11817                    decoder,
11818                    inner_offset,
11819                    inner_depth
11820                )?;
11821                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11822                {
11823                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11824                }
11825                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11826                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11827                }
11828            }
11829
11830            next_offset += envelope_size;
11831            _next_ordinal_to_read += 1;
11832            if next_offset >= end_offset {
11833                return Ok(());
11834            }
11835
11836            // Decode unknown envelopes for gaps in ordinals.
11837            while _next_ordinal_to_read < 7 {
11838                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11839                _next_ordinal_to_read += 1;
11840                next_offset += envelope_size;
11841            }
11842
11843            let next_out_of_line = decoder.next_out_of_line();
11844            let handles_before = decoder.remaining_handles();
11845            if let Some((inlined, num_bytes, num_handles)) =
11846                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11847            {
11848                let member_inline_size =
11849                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11850                if inlined != (member_inline_size <= 4) {
11851                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11852                }
11853                let inner_offset;
11854                let mut inner_depth = depth.clone();
11855                if inlined {
11856                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11857                    inner_offset = next_offset;
11858                } else {
11859                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11860                    inner_depth.increment()?;
11861                }
11862                let val_ref =
11863                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
11864                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
11865                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11866                {
11867                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11868                }
11869                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11870                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11871                }
11872            }
11873
11874            next_offset += envelope_size;
11875            _next_ordinal_to_read += 1;
11876            if next_offset >= end_offset {
11877                return Ok(());
11878            }
11879
11880            // Decode unknown envelopes for gaps in ordinals.
11881            while _next_ordinal_to_read < 8 {
11882                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11883                _next_ordinal_to_read += 1;
11884                next_offset += envelope_size;
11885            }
11886
11887            let next_out_of_line = decoder.next_out_of_line();
11888            let handles_before = decoder.remaining_handles();
11889            if let Some((inlined, num_bytes, num_handles)) =
11890                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11891            {
11892                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11893                if inlined != (member_inline_size <= 4) {
11894                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11895                }
11896                let inner_offset;
11897                let mut inner_depth = depth.clone();
11898                if inlined {
11899                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11900                    inner_offset = next_offset;
11901                } else {
11902                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11903                    inner_depth.increment()?;
11904                }
11905                let val_ref = self.source_dictionary.get_or_insert_with(|| {
11906                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
11907                });
11908                fidl::decode!(
11909                    fidl::encoding::BoundedString<1024>,
11910                    D,
11911                    val_ref,
11912                    decoder,
11913                    inner_offset,
11914                    inner_depth
11915                )?;
11916                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11917                {
11918                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11919                }
11920                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11921                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11922                }
11923            }
11924
11925            next_offset += envelope_size;
11926
11927            // Decode the remaining unknown envelopes.
11928            while next_offset < end_offset {
11929                _next_ordinal_to_read += 1;
11930                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11931                next_offset += envelope_size;
11932            }
11933
11934            Ok(())
11935        }
11936    }
11937
11938    impl ExposeProtocol {
11939        #[inline(always)]
11940        fn max_ordinal_present(&self) -> u64 {
11941            if let Some(_) = self.source_dictionary {
11942                return 6;
11943            }
11944            if let Some(_) = self.availability {
11945                return 5;
11946            }
11947            if let Some(_) = self.target_name {
11948                return 4;
11949            }
11950            if let Some(_) = self.target {
11951                return 3;
11952            }
11953            if let Some(_) = self.source_name {
11954                return 2;
11955            }
11956            if let Some(_) = self.source {
11957                return 1;
11958            }
11959            0
11960        }
11961    }
11962
11963    impl fidl::encoding::ValueTypeMarker for ExposeProtocol {
11964        type Borrowed<'a> = &'a Self;
11965        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11966            value
11967        }
11968    }
11969
11970    unsafe impl fidl::encoding::TypeMarker for ExposeProtocol {
11971        type Owned = Self;
11972
11973        #[inline(always)]
11974        fn inline_align(_context: fidl::encoding::Context) -> usize {
11975            8
11976        }
11977
11978        #[inline(always)]
11979        fn inline_size(_context: fidl::encoding::Context) -> usize {
11980            16
11981        }
11982    }
11983
11984    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExposeProtocol, D>
11985        for &ExposeProtocol
11986    {
11987        unsafe fn encode(
11988            self,
11989            encoder: &mut fidl::encoding::Encoder<'_, D>,
11990            offset: usize,
11991            mut depth: fidl::encoding::Depth,
11992        ) -> fidl::Result<()> {
11993            encoder.debug_check_bounds::<ExposeProtocol>(offset);
11994            // Vector header
11995            let max_ordinal: u64 = self.max_ordinal_present();
11996            encoder.write_num(max_ordinal, offset);
11997            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11998            // Calling encoder.out_of_line_offset(0) is not allowed.
11999            if max_ordinal == 0 {
12000                return Ok(());
12001            }
12002            depth.increment()?;
12003            let envelope_size = 8;
12004            let bytes_len = max_ordinal as usize * envelope_size;
12005            #[allow(unused_variables)]
12006            let offset = encoder.out_of_line_offset(bytes_len);
12007            let mut _prev_end_offset: usize = 0;
12008            if 1 > max_ordinal {
12009                return Ok(());
12010            }
12011
12012            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12013            // are envelope_size bytes.
12014            let cur_offset: usize = (1 - 1) * envelope_size;
12015
12016            // Zero reserved fields.
12017            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12018
12019            // Safety:
12020            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12021            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12022            //   envelope_size bytes, there is always sufficient room.
12023            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
12024                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
12025                encoder,
12026                offset + cur_offset,
12027                depth,
12028            )?;
12029
12030            _prev_end_offset = cur_offset + envelope_size;
12031            if 2 > max_ordinal {
12032                return Ok(());
12033            }
12034
12035            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12036            // are envelope_size bytes.
12037            let cur_offset: usize = (2 - 1) * envelope_size;
12038
12039            // Zero reserved fields.
12040            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12041
12042            // Safety:
12043            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12044            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12045            //   envelope_size bytes, there is always sufficient room.
12046            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
12047                self.source_name.as_ref().map(
12048                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
12049                ),
12050                encoder,
12051                offset + cur_offset,
12052                depth,
12053            )?;
12054
12055            _prev_end_offset = cur_offset + envelope_size;
12056            if 3 > max_ordinal {
12057                return Ok(());
12058            }
12059
12060            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12061            // are envelope_size bytes.
12062            let cur_offset: usize = (3 - 1) * envelope_size;
12063
12064            // Zero reserved fields.
12065            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12066
12067            // Safety:
12068            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12069            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12070            //   envelope_size bytes, there is always sufficient room.
12071            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
12072                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
12073                encoder,
12074                offset + cur_offset,
12075                depth,
12076            )?;
12077
12078            _prev_end_offset = cur_offset + envelope_size;
12079            if 4 > max_ordinal {
12080                return Ok(());
12081            }
12082
12083            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12084            // are envelope_size bytes.
12085            let cur_offset: usize = (4 - 1) * envelope_size;
12086
12087            // Zero reserved fields.
12088            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12089
12090            // Safety:
12091            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12092            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12093            //   envelope_size bytes, there is always sufficient room.
12094            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
12095                self.target_name.as_ref().map(
12096                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
12097                ),
12098                encoder,
12099                offset + cur_offset,
12100                depth,
12101            )?;
12102
12103            _prev_end_offset = cur_offset + envelope_size;
12104            if 5 > max_ordinal {
12105                return Ok(());
12106            }
12107
12108            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12109            // are envelope_size bytes.
12110            let cur_offset: usize = (5 - 1) * envelope_size;
12111
12112            // Zero reserved fields.
12113            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12114
12115            // Safety:
12116            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12117            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12118            //   envelope_size bytes, there is always sufficient room.
12119            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
12120                self.availability
12121                    .as_ref()
12122                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
12123                encoder,
12124                offset + cur_offset,
12125                depth,
12126            )?;
12127
12128            _prev_end_offset = cur_offset + envelope_size;
12129            if 6 > max_ordinal {
12130                return Ok(());
12131            }
12132
12133            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12134            // are envelope_size bytes.
12135            let cur_offset: usize = (6 - 1) * envelope_size;
12136
12137            // Zero reserved fields.
12138            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12139
12140            // Safety:
12141            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12142            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12143            //   envelope_size bytes, there is always sufficient room.
12144            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
12145            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
12146            encoder, offset + cur_offset, depth
12147        )?;
12148
12149            _prev_end_offset = cur_offset + envelope_size;
12150
12151            Ok(())
12152        }
12153    }
12154
12155    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExposeProtocol {
12156        #[inline(always)]
12157        fn new_empty() -> Self {
12158            Self::default()
12159        }
12160
12161        unsafe fn decode(
12162            &mut self,
12163            decoder: &mut fidl::encoding::Decoder<'_, D>,
12164            offset: usize,
12165            mut depth: fidl::encoding::Depth,
12166        ) -> fidl::Result<()> {
12167            decoder.debug_check_bounds::<Self>(offset);
12168            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12169                None => return Err(fidl::Error::NotNullable),
12170                Some(len) => len,
12171            };
12172            // Calling decoder.out_of_line_offset(0) is not allowed.
12173            if len == 0 {
12174                return Ok(());
12175            };
12176            depth.increment()?;
12177            let envelope_size = 8;
12178            let bytes_len = len * envelope_size;
12179            let offset = decoder.out_of_line_offset(bytes_len)?;
12180            // Decode the envelope for each type.
12181            let mut _next_ordinal_to_read = 0;
12182            let mut next_offset = offset;
12183            let end_offset = offset + bytes_len;
12184            _next_ordinal_to_read += 1;
12185            if next_offset >= end_offset {
12186                return Ok(());
12187            }
12188
12189            // Decode unknown envelopes for gaps in ordinals.
12190            while _next_ordinal_to_read < 1 {
12191                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12192                _next_ordinal_to_read += 1;
12193                next_offset += envelope_size;
12194            }
12195
12196            let next_out_of_line = decoder.next_out_of_line();
12197            let handles_before = decoder.remaining_handles();
12198            if let Some((inlined, num_bytes, num_handles)) =
12199                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12200            {
12201                let member_inline_size =
12202                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12203                if inlined != (member_inline_size <= 4) {
12204                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12205                }
12206                let inner_offset;
12207                let mut inner_depth = depth.clone();
12208                if inlined {
12209                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12210                    inner_offset = next_offset;
12211                } else {
12212                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12213                    inner_depth.increment()?;
12214                }
12215                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
12216                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
12217                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12218                {
12219                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12220                }
12221                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12222                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12223                }
12224            }
12225
12226            next_offset += envelope_size;
12227            _next_ordinal_to_read += 1;
12228            if next_offset >= end_offset {
12229                return Ok(());
12230            }
12231
12232            // Decode unknown envelopes for gaps in ordinals.
12233            while _next_ordinal_to_read < 2 {
12234                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12235                _next_ordinal_to_read += 1;
12236                next_offset += envelope_size;
12237            }
12238
12239            let next_out_of_line = decoder.next_out_of_line();
12240            let handles_before = decoder.remaining_handles();
12241            if let Some((inlined, num_bytes, num_handles)) =
12242                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12243            {
12244                let member_inline_size =
12245                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
12246                        decoder.context,
12247                    );
12248                if inlined != (member_inline_size <= 4) {
12249                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12250                }
12251                let inner_offset;
12252                let mut inner_depth = depth.clone();
12253                if inlined {
12254                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12255                    inner_offset = next_offset;
12256                } else {
12257                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12258                    inner_depth.increment()?;
12259                }
12260                let val_ref = self
12261                    .source_name
12262                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
12263                fidl::decode!(
12264                    fidl::encoding::BoundedString<100>,
12265                    D,
12266                    val_ref,
12267                    decoder,
12268                    inner_offset,
12269                    inner_depth
12270                )?;
12271                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12272                {
12273                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12274                }
12275                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12276                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12277                }
12278            }
12279
12280            next_offset += envelope_size;
12281            _next_ordinal_to_read += 1;
12282            if next_offset >= end_offset {
12283                return Ok(());
12284            }
12285
12286            // Decode unknown envelopes for gaps in ordinals.
12287            while _next_ordinal_to_read < 3 {
12288                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12289                _next_ordinal_to_read += 1;
12290                next_offset += envelope_size;
12291            }
12292
12293            let next_out_of_line = decoder.next_out_of_line();
12294            let handles_before = decoder.remaining_handles();
12295            if let Some((inlined, num_bytes, num_handles)) =
12296                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12297            {
12298                let member_inline_size =
12299                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12300                if inlined != (member_inline_size <= 4) {
12301                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12302                }
12303                let inner_offset;
12304                let mut inner_depth = depth.clone();
12305                if inlined {
12306                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12307                    inner_offset = next_offset;
12308                } else {
12309                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12310                    inner_depth.increment()?;
12311                }
12312                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
12313                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
12314                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12315                {
12316                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12317                }
12318                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12319                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12320                }
12321            }
12322
12323            next_offset += envelope_size;
12324            _next_ordinal_to_read += 1;
12325            if next_offset >= end_offset {
12326                return Ok(());
12327            }
12328
12329            // Decode unknown envelopes for gaps in ordinals.
12330            while _next_ordinal_to_read < 4 {
12331                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12332                _next_ordinal_to_read += 1;
12333                next_offset += envelope_size;
12334            }
12335
12336            let next_out_of_line = decoder.next_out_of_line();
12337            let handles_before = decoder.remaining_handles();
12338            if let Some((inlined, num_bytes, num_handles)) =
12339                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12340            {
12341                let member_inline_size =
12342                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
12343                        decoder.context,
12344                    );
12345                if inlined != (member_inline_size <= 4) {
12346                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12347                }
12348                let inner_offset;
12349                let mut inner_depth = depth.clone();
12350                if inlined {
12351                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12352                    inner_offset = next_offset;
12353                } else {
12354                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12355                    inner_depth.increment()?;
12356                }
12357                let val_ref = self
12358                    .target_name
12359                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
12360                fidl::decode!(
12361                    fidl::encoding::BoundedString<100>,
12362                    D,
12363                    val_ref,
12364                    decoder,
12365                    inner_offset,
12366                    inner_depth
12367                )?;
12368                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12369                {
12370                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12371                }
12372                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12373                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12374                }
12375            }
12376
12377            next_offset += envelope_size;
12378            _next_ordinal_to_read += 1;
12379            if next_offset >= end_offset {
12380                return Ok(());
12381            }
12382
12383            // Decode unknown envelopes for gaps in ordinals.
12384            while _next_ordinal_to_read < 5 {
12385                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12386                _next_ordinal_to_read += 1;
12387                next_offset += envelope_size;
12388            }
12389
12390            let next_out_of_line = decoder.next_out_of_line();
12391            let handles_before = decoder.remaining_handles();
12392            if let Some((inlined, num_bytes, num_handles)) =
12393                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12394            {
12395                let member_inline_size =
12396                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12397                if inlined != (member_inline_size <= 4) {
12398                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12399                }
12400                let inner_offset;
12401                let mut inner_depth = depth.clone();
12402                if inlined {
12403                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12404                    inner_offset = next_offset;
12405                } else {
12406                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12407                    inner_depth.increment()?;
12408                }
12409                let val_ref =
12410                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
12411                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
12412                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12413                {
12414                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12415                }
12416                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12417                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12418                }
12419            }
12420
12421            next_offset += envelope_size;
12422            _next_ordinal_to_read += 1;
12423            if next_offset >= end_offset {
12424                return Ok(());
12425            }
12426
12427            // Decode unknown envelopes for gaps in ordinals.
12428            while _next_ordinal_to_read < 6 {
12429                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12430                _next_ordinal_to_read += 1;
12431                next_offset += envelope_size;
12432            }
12433
12434            let next_out_of_line = decoder.next_out_of_line();
12435            let handles_before = decoder.remaining_handles();
12436            if let Some((inlined, num_bytes, num_handles)) =
12437                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12438            {
12439                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12440                if inlined != (member_inline_size <= 4) {
12441                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12442                }
12443                let inner_offset;
12444                let mut inner_depth = depth.clone();
12445                if inlined {
12446                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12447                    inner_offset = next_offset;
12448                } else {
12449                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12450                    inner_depth.increment()?;
12451                }
12452                let val_ref = self.source_dictionary.get_or_insert_with(|| {
12453                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
12454                });
12455                fidl::decode!(
12456                    fidl::encoding::BoundedString<1024>,
12457                    D,
12458                    val_ref,
12459                    decoder,
12460                    inner_offset,
12461                    inner_depth
12462                )?;
12463                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12464                {
12465                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12466                }
12467                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12468                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12469                }
12470            }
12471
12472            next_offset += envelope_size;
12473
12474            // Decode the remaining unknown envelopes.
12475            while next_offset < end_offset {
12476                _next_ordinal_to_read += 1;
12477                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12478                next_offset += envelope_size;
12479            }
12480
12481            Ok(())
12482        }
12483    }
12484
12485    impl ExposeResolver {
12486        #[inline(always)]
12487        fn max_ordinal_present(&self) -> u64 {
12488            if let Some(_) = self.source_dictionary {
12489                return 6;
12490            }
12491            if let Some(_) = self.target_name {
12492                return 4;
12493            }
12494            if let Some(_) = self.target {
12495                return 3;
12496            }
12497            if let Some(_) = self.source_name {
12498                return 2;
12499            }
12500            if let Some(_) = self.source {
12501                return 1;
12502            }
12503            0
12504        }
12505    }
12506
12507    impl fidl::encoding::ValueTypeMarker for ExposeResolver {
12508        type Borrowed<'a> = &'a Self;
12509        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12510            value
12511        }
12512    }
12513
12514    unsafe impl fidl::encoding::TypeMarker for ExposeResolver {
12515        type Owned = Self;
12516
12517        #[inline(always)]
12518        fn inline_align(_context: fidl::encoding::Context) -> usize {
12519            8
12520        }
12521
12522        #[inline(always)]
12523        fn inline_size(_context: fidl::encoding::Context) -> usize {
12524            16
12525        }
12526    }
12527
12528    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExposeResolver, D>
12529        for &ExposeResolver
12530    {
12531        unsafe fn encode(
12532            self,
12533            encoder: &mut fidl::encoding::Encoder<'_, D>,
12534            offset: usize,
12535            mut depth: fidl::encoding::Depth,
12536        ) -> fidl::Result<()> {
12537            encoder.debug_check_bounds::<ExposeResolver>(offset);
12538            // Vector header
12539            let max_ordinal: u64 = self.max_ordinal_present();
12540            encoder.write_num(max_ordinal, offset);
12541            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12542            // Calling encoder.out_of_line_offset(0) is not allowed.
12543            if max_ordinal == 0 {
12544                return Ok(());
12545            }
12546            depth.increment()?;
12547            let envelope_size = 8;
12548            let bytes_len = max_ordinal as usize * envelope_size;
12549            #[allow(unused_variables)]
12550            let offset = encoder.out_of_line_offset(bytes_len);
12551            let mut _prev_end_offset: usize = 0;
12552            if 1 > max_ordinal {
12553                return Ok(());
12554            }
12555
12556            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12557            // are envelope_size bytes.
12558            let cur_offset: usize = (1 - 1) * envelope_size;
12559
12560            // Zero reserved fields.
12561            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12562
12563            // Safety:
12564            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12565            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12566            //   envelope_size bytes, there is always sufficient room.
12567            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
12568                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
12569                encoder,
12570                offset + cur_offset,
12571                depth,
12572            )?;
12573
12574            _prev_end_offset = cur_offset + envelope_size;
12575            if 2 > max_ordinal {
12576                return Ok(());
12577            }
12578
12579            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12580            // are envelope_size bytes.
12581            let cur_offset: usize = (2 - 1) * envelope_size;
12582
12583            // Zero reserved fields.
12584            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12585
12586            // Safety:
12587            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12588            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12589            //   envelope_size bytes, there is always sufficient room.
12590            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
12591                self.source_name.as_ref().map(
12592                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
12593                ),
12594                encoder,
12595                offset + cur_offset,
12596                depth,
12597            )?;
12598
12599            _prev_end_offset = cur_offset + envelope_size;
12600            if 3 > max_ordinal {
12601                return Ok(());
12602            }
12603
12604            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12605            // are envelope_size bytes.
12606            let cur_offset: usize = (3 - 1) * envelope_size;
12607
12608            // Zero reserved fields.
12609            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12610
12611            // Safety:
12612            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12613            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12614            //   envelope_size bytes, there is always sufficient room.
12615            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
12616                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
12617                encoder,
12618                offset + cur_offset,
12619                depth,
12620            )?;
12621
12622            _prev_end_offset = cur_offset + envelope_size;
12623            if 4 > max_ordinal {
12624                return Ok(());
12625            }
12626
12627            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12628            // are envelope_size bytes.
12629            let cur_offset: usize = (4 - 1) * envelope_size;
12630
12631            // Zero reserved fields.
12632            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12633
12634            // Safety:
12635            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12636            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12637            //   envelope_size bytes, there is always sufficient room.
12638            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
12639                self.target_name.as_ref().map(
12640                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
12641                ),
12642                encoder,
12643                offset + cur_offset,
12644                depth,
12645            )?;
12646
12647            _prev_end_offset = cur_offset + envelope_size;
12648            if 6 > max_ordinal {
12649                return Ok(());
12650            }
12651
12652            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12653            // are envelope_size bytes.
12654            let cur_offset: usize = (6 - 1) * envelope_size;
12655
12656            // Zero reserved fields.
12657            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12658
12659            // Safety:
12660            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12661            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12662            //   envelope_size bytes, there is always sufficient room.
12663            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
12664            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
12665            encoder, offset + cur_offset, depth
12666        )?;
12667
12668            _prev_end_offset = cur_offset + envelope_size;
12669
12670            Ok(())
12671        }
12672    }
12673
12674    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExposeResolver {
12675        #[inline(always)]
12676        fn new_empty() -> Self {
12677            Self::default()
12678        }
12679
12680        unsafe fn decode(
12681            &mut self,
12682            decoder: &mut fidl::encoding::Decoder<'_, D>,
12683            offset: usize,
12684            mut depth: fidl::encoding::Depth,
12685        ) -> fidl::Result<()> {
12686            decoder.debug_check_bounds::<Self>(offset);
12687            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12688                None => return Err(fidl::Error::NotNullable),
12689                Some(len) => len,
12690            };
12691            // Calling decoder.out_of_line_offset(0) is not allowed.
12692            if len == 0 {
12693                return Ok(());
12694            };
12695            depth.increment()?;
12696            let envelope_size = 8;
12697            let bytes_len = len * envelope_size;
12698            let offset = decoder.out_of_line_offset(bytes_len)?;
12699            // Decode the envelope for each type.
12700            let mut _next_ordinal_to_read = 0;
12701            let mut next_offset = offset;
12702            let end_offset = offset + bytes_len;
12703            _next_ordinal_to_read += 1;
12704            if next_offset >= end_offset {
12705                return Ok(());
12706            }
12707
12708            // Decode unknown envelopes for gaps in ordinals.
12709            while _next_ordinal_to_read < 1 {
12710                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12711                _next_ordinal_to_read += 1;
12712                next_offset += envelope_size;
12713            }
12714
12715            let next_out_of_line = decoder.next_out_of_line();
12716            let handles_before = decoder.remaining_handles();
12717            if let Some((inlined, num_bytes, num_handles)) =
12718                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12719            {
12720                let member_inline_size =
12721                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12722                if inlined != (member_inline_size <= 4) {
12723                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12724                }
12725                let inner_offset;
12726                let mut inner_depth = depth.clone();
12727                if inlined {
12728                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12729                    inner_offset = next_offset;
12730                } else {
12731                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12732                    inner_depth.increment()?;
12733                }
12734                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
12735                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
12736                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12737                {
12738                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12739                }
12740                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12741                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12742                }
12743            }
12744
12745            next_offset += envelope_size;
12746            _next_ordinal_to_read += 1;
12747            if next_offset >= end_offset {
12748                return Ok(());
12749            }
12750
12751            // Decode unknown envelopes for gaps in ordinals.
12752            while _next_ordinal_to_read < 2 {
12753                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12754                _next_ordinal_to_read += 1;
12755                next_offset += envelope_size;
12756            }
12757
12758            let next_out_of_line = decoder.next_out_of_line();
12759            let handles_before = decoder.remaining_handles();
12760            if let Some((inlined, num_bytes, num_handles)) =
12761                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12762            {
12763                let member_inline_size =
12764                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
12765                        decoder.context,
12766                    );
12767                if inlined != (member_inline_size <= 4) {
12768                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12769                }
12770                let inner_offset;
12771                let mut inner_depth = depth.clone();
12772                if inlined {
12773                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12774                    inner_offset = next_offset;
12775                } else {
12776                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12777                    inner_depth.increment()?;
12778                }
12779                let val_ref = self
12780                    .source_name
12781                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
12782                fidl::decode!(
12783                    fidl::encoding::BoundedString<100>,
12784                    D,
12785                    val_ref,
12786                    decoder,
12787                    inner_offset,
12788                    inner_depth
12789                )?;
12790                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12791                {
12792                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12793                }
12794                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12795                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12796                }
12797            }
12798
12799            next_offset += envelope_size;
12800            _next_ordinal_to_read += 1;
12801            if next_offset >= end_offset {
12802                return Ok(());
12803            }
12804
12805            // Decode unknown envelopes for gaps in ordinals.
12806            while _next_ordinal_to_read < 3 {
12807                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12808                _next_ordinal_to_read += 1;
12809                next_offset += envelope_size;
12810            }
12811
12812            let next_out_of_line = decoder.next_out_of_line();
12813            let handles_before = decoder.remaining_handles();
12814            if let Some((inlined, num_bytes, num_handles)) =
12815                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12816            {
12817                let member_inline_size =
12818                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12819                if inlined != (member_inline_size <= 4) {
12820                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12821                }
12822                let inner_offset;
12823                let mut inner_depth = depth.clone();
12824                if inlined {
12825                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12826                    inner_offset = next_offset;
12827                } else {
12828                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12829                    inner_depth.increment()?;
12830                }
12831                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
12832                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
12833                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12834                {
12835                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12836                }
12837                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12838                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12839                }
12840            }
12841
12842            next_offset += envelope_size;
12843            _next_ordinal_to_read += 1;
12844            if next_offset >= end_offset {
12845                return Ok(());
12846            }
12847
12848            // Decode unknown envelopes for gaps in ordinals.
12849            while _next_ordinal_to_read < 4 {
12850                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12851                _next_ordinal_to_read += 1;
12852                next_offset += envelope_size;
12853            }
12854
12855            let next_out_of_line = decoder.next_out_of_line();
12856            let handles_before = decoder.remaining_handles();
12857            if let Some((inlined, num_bytes, num_handles)) =
12858                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12859            {
12860                let member_inline_size =
12861                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
12862                        decoder.context,
12863                    );
12864                if inlined != (member_inline_size <= 4) {
12865                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12866                }
12867                let inner_offset;
12868                let mut inner_depth = depth.clone();
12869                if inlined {
12870                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12871                    inner_offset = next_offset;
12872                } else {
12873                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12874                    inner_depth.increment()?;
12875                }
12876                let val_ref = self
12877                    .target_name
12878                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
12879                fidl::decode!(
12880                    fidl::encoding::BoundedString<100>,
12881                    D,
12882                    val_ref,
12883                    decoder,
12884                    inner_offset,
12885                    inner_depth
12886                )?;
12887                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12888                {
12889                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12890                }
12891                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12892                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12893                }
12894            }
12895
12896            next_offset += envelope_size;
12897            _next_ordinal_to_read += 1;
12898            if next_offset >= end_offset {
12899                return Ok(());
12900            }
12901
12902            // Decode unknown envelopes for gaps in ordinals.
12903            while _next_ordinal_to_read < 6 {
12904                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12905                _next_ordinal_to_read += 1;
12906                next_offset += envelope_size;
12907            }
12908
12909            let next_out_of_line = decoder.next_out_of_line();
12910            let handles_before = decoder.remaining_handles();
12911            if let Some((inlined, num_bytes, num_handles)) =
12912                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12913            {
12914                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12915                if inlined != (member_inline_size <= 4) {
12916                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12917                }
12918                let inner_offset;
12919                let mut inner_depth = depth.clone();
12920                if inlined {
12921                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12922                    inner_offset = next_offset;
12923                } else {
12924                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12925                    inner_depth.increment()?;
12926                }
12927                let val_ref = self.source_dictionary.get_or_insert_with(|| {
12928                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
12929                });
12930                fidl::decode!(
12931                    fidl::encoding::BoundedString<1024>,
12932                    D,
12933                    val_ref,
12934                    decoder,
12935                    inner_offset,
12936                    inner_depth
12937                )?;
12938                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12939                {
12940                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12941                }
12942                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12943                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12944                }
12945            }
12946
12947            next_offset += envelope_size;
12948
12949            // Decode the remaining unknown envelopes.
12950            while next_offset < end_offset {
12951                _next_ordinal_to_read += 1;
12952                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12953                next_offset += envelope_size;
12954            }
12955
12956            Ok(())
12957        }
12958    }
12959
12960    impl ExposeRunner {
12961        #[inline(always)]
12962        fn max_ordinal_present(&self) -> u64 {
12963            if let Some(_) = self.source_dictionary {
12964                return 6;
12965            }
12966            if let Some(_) = self.target_name {
12967                return 4;
12968            }
12969            if let Some(_) = self.target {
12970                return 3;
12971            }
12972            if let Some(_) = self.source_name {
12973                return 2;
12974            }
12975            if let Some(_) = self.source {
12976                return 1;
12977            }
12978            0
12979        }
12980    }
12981
12982    impl fidl::encoding::ValueTypeMarker for ExposeRunner {
12983        type Borrowed<'a> = &'a Self;
12984        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12985            value
12986        }
12987    }
12988
12989    unsafe impl fidl::encoding::TypeMarker for ExposeRunner {
12990        type Owned = Self;
12991
12992        #[inline(always)]
12993        fn inline_align(_context: fidl::encoding::Context) -> usize {
12994            8
12995        }
12996
12997        #[inline(always)]
12998        fn inline_size(_context: fidl::encoding::Context) -> usize {
12999            16
13000        }
13001    }
13002
13003    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExposeRunner, D>
13004        for &ExposeRunner
13005    {
13006        unsafe fn encode(
13007            self,
13008            encoder: &mut fidl::encoding::Encoder<'_, D>,
13009            offset: usize,
13010            mut depth: fidl::encoding::Depth,
13011        ) -> fidl::Result<()> {
13012            encoder.debug_check_bounds::<ExposeRunner>(offset);
13013            // Vector header
13014            let max_ordinal: u64 = self.max_ordinal_present();
13015            encoder.write_num(max_ordinal, offset);
13016            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13017            // Calling encoder.out_of_line_offset(0) is not allowed.
13018            if max_ordinal == 0 {
13019                return Ok(());
13020            }
13021            depth.increment()?;
13022            let envelope_size = 8;
13023            let bytes_len = max_ordinal as usize * envelope_size;
13024            #[allow(unused_variables)]
13025            let offset = encoder.out_of_line_offset(bytes_len);
13026            let mut _prev_end_offset: usize = 0;
13027            if 1 > max_ordinal {
13028                return Ok(());
13029            }
13030
13031            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13032            // are envelope_size bytes.
13033            let cur_offset: usize = (1 - 1) * envelope_size;
13034
13035            // Zero reserved fields.
13036            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13037
13038            // Safety:
13039            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13040            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13041            //   envelope_size bytes, there is always sufficient room.
13042            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
13043                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
13044                encoder,
13045                offset + cur_offset,
13046                depth,
13047            )?;
13048
13049            _prev_end_offset = cur_offset + envelope_size;
13050            if 2 > max_ordinal {
13051                return Ok(());
13052            }
13053
13054            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13055            // are envelope_size bytes.
13056            let cur_offset: usize = (2 - 1) * envelope_size;
13057
13058            // Zero reserved fields.
13059            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13060
13061            // Safety:
13062            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13063            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13064            //   envelope_size bytes, there is always sufficient room.
13065            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
13066                self.source_name.as_ref().map(
13067                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
13068                ),
13069                encoder,
13070                offset + cur_offset,
13071                depth,
13072            )?;
13073
13074            _prev_end_offset = cur_offset + envelope_size;
13075            if 3 > max_ordinal {
13076                return Ok(());
13077            }
13078
13079            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13080            // are envelope_size bytes.
13081            let cur_offset: usize = (3 - 1) * envelope_size;
13082
13083            // Zero reserved fields.
13084            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13085
13086            // Safety:
13087            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13088            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13089            //   envelope_size bytes, there is always sufficient room.
13090            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
13091                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
13092                encoder,
13093                offset + cur_offset,
13094                depth,
13095            )?;
13096
13097            _prev_end_offset = cur_offset + envelope_size;
13098            if 4 > max_ordinal {
13099                return Ok(());
13100            }
13101
13102            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13103            // are envelope_size bytes.
13104            let cur_offset: usize = (4 - 1) * envelope_size;
13105
13106            // Zero reserved fields.
13107            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13108
13109            // Safety:
13110            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13111            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13112            //   envelope_size bytes, there is always sufficient room.
13113            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
13114                self.target_name.as_ref().map(
13115                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
13116                ),
13117                encoder,
13118                offset + cur_offset,
13119                depth,
13120            )?;
13121
13122            _prev_end_offset = cur_offset + envelope_size;
13123            if 6 > max_ordinal {
13124                return Ok(());
13125            }
13126
13127            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13128            // are envelope_size bytes.
13129            let cur_offset: usize = (6 - 1) * envelope_size;
13130
13131            // Zero reserved fields.
13132            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13133
13134            // Safety:
13135            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13136            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13137            //   envelope_size bytes, there is always sufficient room.
13138            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
13139            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
13140            encoder, offset + cur_offset, depth
13141        )?;
13142
13143            _prev_end_offset = cur_offset + envelope_size;
13144
13145            Ok(())
13146        }
13147    }
13148
13149    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExposeRunner {
13150        #[inline(always)]
13151        fn new_empty() -> Self {
13152            Self::default()
13153        }
13154
13155        unsafe fn decode(
13156            &mut self,
13157            decoder: &mut fidl::encoding::Decoder<'_, D>,
13158            offset: usize,
13159            mut depth: fidl::encoding::Depth,
13160        ) -> fidl::Result<()> {
13161            decoder.debug_check_bounds::<Self>(offset);
13162            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13163                None => return Err(fidl::Error::NotNullable),
13164                Some(len) => len,
13165            };
13166            // Calling decoder.out_of_line_offset(0) is not allowed.
13167            if len == 0 {
13168                return Ok(());
13169            };
13170            depth.increment()?;
13171            let envelope_size = 8;
13172            let bytes_len = len * envelope_size;
13173            let offset = decoder.out_of_line_offset(bytes_len)?;
13174            // Decode the envelope for each type.
13175            let mut _next_ordinal_to_read = 0;
13176            let mut next_offset = offset;
13177            let end_offset = offset + bytes_len;
13178            _next_ordinal_to_read += 1;
13179            if next_offset >= end_offset {
13180                return Ok(());
13181            }
13182
13183            // Decode unknown envelopes for gaps in ordinals.
13184            while _next_ordinal_to_read < 1 {
13185                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13186                _next_ordinal_to_read += 1;
13187                next_offset += envelope_size;
13188            }
13189
13190            let next_out_of_line = decoder.next_out_of_line();
13191            let handles_before = decoder.remaining_handles();
13192            if let Some((inlined, num_bytes, num_handles)) =
13193                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13194            {
13195                let member_inline_size =
13196                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13197                if inlined != (member_inline_size <= 4) {
13198                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13199                }
13200                let inner_offset;
13201                let mut inner_depth = depth.clone();
13202                if inlined {
13203                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13204                    inner_offset = next_offset;
13205                } else {
13206                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13207                    inner_depth.increment()?;
13208                }
13209                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
13210                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
13211                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13212                {
13213                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13214                }
13215                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13216                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13217                }
13218            }
13219
13220            next_offset += envelope_size;
13221            _next_ordinal_to_read += 1;
13222            if next_offset >= end_offset {
13223                return Ok(());
13224            }
13225
13226            // Decode unknown envelopes for gaps in ordinals.
13227            while _next_ordinal_to_read < 2 {
13228                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13229                _next_ordinal_to_read += 1;
13230                next_offset += envelope_size;
13231            }
13232
13233            let next_out_of_line = decoder.next_out_of_line();
13234            let handles_before = decoder.remaining_handles();
13235            if let Some((inlined, num_bytes, num_handles)) =
13236                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13237            {
13238                let member_inline_size =
13239                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13240                        decoder.context,
13241                    );
13242                if inlined != (member_inline_size <= 4) {
13243                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13244                }
13245                let inner_offset;
13246                let mut inner_depth = depth.clone();
13247                if inlined {
13248                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13249                    inner_offset = next_offset;
13250                } else {
13251                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13252                    inner_depth.increment()?;
13253                }
13254                let val_ref = self
13255                    .source_name
13256                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
13257                fidl::decode!(
13258                    fidl::encoding::BoundedString<100>,
13259                    D,
13260                    val_ref,
13261                    decoder,
13262                    inner_offset,
13263                    inner_depth
13264                )?;
13265                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13266                {
13267                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13268                }
13269                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13270                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13271                }
13272            }
13273
13274            next_offset += envelope_size;
13275            _next_ordinal_to_read += 1;
13276            if next_offset >= end_offset {
13277                return Ok(());
13278            }
13279
13280            // Decode unknown envelopes for gaps in ordinals.
13281            while _next_ordinal_to_read < 3 {
13282                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13283                _next_ordinal_to_read += 1;
13284                next_offset += envelope_size;
13285            }
13286
13287            let next_out_of_line = decoder.next_out_of_line();
13288            let handles_before = decoder.remaining_handles();
13289            if let Some((inlined, num_bytes, num_handles)) =
13290                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13291            {
13292                let member_inline_size =
13293                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13294                if inlined != (member_inline_size <= 4) {
13295                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13296                }
13297                let inner_offset;
13298                let mut inner_depth = depth.clone();
13299                if inlined {
13300                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13301                    inner_offset = next_offset;
13302                } else {
13303                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13304                    inner_depth.increment()?;
13305                }
13306                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
13307                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
13308                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13309                {
13310                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13311                }
13312                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13313                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13314                }
13315            }
13316
13317            next_offset += envelope_size;
13318            _next_ordinal_to_read += 1;
13319            if next_offset >= end_offset {
13320                return Ok(());
13321            }
13322
13323            // Decode unknown envelopes for gaps in ordinals.
13324            while _next_ordinal_to_read < 4 {
13325                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13326                _next_ordinal_to_read += 1;
13327                next_offset += envelope_size;
13328            }
13329
13330            let next_out_of_line = decoder.next_out_of_line();
13331            let handles_before = decoder.remaining_handles();
13332            if let Some((inlined, num_bytes, num_handles)) =
13333                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13334            {
13335                let member_inline_size =
13336                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13337                        decoder.context,
13338                    );
13339                if inlined != (member_inline_size <= 4) {
13340                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13341                }
13342                let inner_offset;
13343                let mut inner_depth = depth.clone();
13344                if inlined {
13345                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13346                    inner_offset = next_offset;
13347                } else {
13348                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13349                    inner_depth.increment()?;
13350                }
13351                let val_ref = self
13352                    .target_name
13353                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
13354                fidl::decode!(
13355                    fidl::encoding::BoundedString<100>,
13356                    D,
13357                    val_ref,
13358                    decoder,
13359                    inner_offset,
13360                    inner_depth
13361                )?;
13362                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13363                {
13364                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13365                }
13366                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13367                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13368                }
13369            }
13370
13371            next_offset += envelope_size;
13372            _next_ordinal_to_read += 1;
13373            if next_offset >= end_offset {
13374                return Ok(());
13375            }
13376
13377            // Decode unknown envelopes for gaps in ordinals.
13378            while _next_ordinal_to_read < 6 {
13379                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13380                _next_ordinal_to_read += 1;
13381                next_offset += envelope_size;
13382            }
13383
13384            let next_out_of_line = decoder.next_out_of_line();
13385            let handles_before = decoder.remaining_handles();
13386            if let Some((inlined, num_bytes, num_handles)) =
13387                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13388            {
13389                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13390                if inlined != (member_inline_size <= 4) {
13391                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13392                }
13393                let inner_offset;
13394                let mut inner_depth = depth.clone();
13395                if inlined {
13396                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13397                    inner_offset = next_offset;
13398                } else {
13399                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13400                    inner_depth.increment()?;
13401                }
13402                let val_ref = self.source_dictionary.get_or_insert_with(|| {
13403                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
13404                });
13405                fidl::decode!(
13406                    fidl::encoding::BoundedString<1024>,
13407                    D,
13408                    val_ref,
13409                    decoder,
13410                    inner_offset,
13411                    inner_depth
13412                )?;
13413                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13414                {
13415                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13416                }
13417                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13418                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13419                }
13420            }
13421
13422            next_offset += envelope_size;
13423
13424            // Decode the remaining unknown envelopes.
13425            while next_offset < end_offset {
13426                _next_ordinal_to_read += 1;
13427                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13428                next_offset += envelope_size;
13429            }
13430
13431            Ok(())
13432        }
13433    }
13434
13435    impl ExposeService {
13436        #[inline(always)]
13437        fn max_ordinal_present(&self) -> u64 {
13438            if let Some(_) = self.source_dictionary {
13439                return 6;
13440            }
13441            if let Some(_) = self.availability {
13442                return 5;
13443            }
13444            if let Some(_) = self.target_name {
13445                return 4;
13446            }
13447            if let Some(_) = self.target {
13448                return 3;
13449            }
13450            if let Some(_) = self.source_name {
13451                return 2;
13452            }
13453            if let Some(_) = self.source {
13454                return 1;
13455            }
13456            0
13457        }
13458    }
13459
13460    impl fidl::encoding::ValueTypeMarker for ExposeService {
13461        type Borrowed<'a> = &'a Self;
13462        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13463            value
13464        }
13465    }
13466
13467    unsafe impl fidl::encoding::TypeMarker for ExposeService {
13468        type Owned = Self;
13469
13470        #[inline(always)]
13471        fn inline_align(_context: fidl::encoding::Context) -> usize {
13472            8
13473        }
13474
13475        #[inline(always)]
13476        fn inline_size(_context: fidl::encoding::Context) -> usize {
13477            16
13478        }
13479    }
13480
13481    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExposeService, D>
13482        for &ExposeService
13483    {
13484        unsafe fn encode(
13485            self,
13486            encoder: &mut fidl::encoding::Encoder<'_, D>,
13487            offset: usize,
13488            mut depth: fidl::encoding::Depth,
13489        ) -> fidl::Result<()> {
13490            encoder.debug_check_bounds::<ExposeService>(offset);
13491            // Vector header
13492            let max_ordinal: u64 = self.max_ordinal_present();
13493            encoder.write_num(max_ordinal, offset);
13494            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13495            // Calling encoder.out_of_line_offset(0) is not allowed.
13496            if max_ordinal == 0 {
13497                return Ok(());
13498            }
13499            depth.increment()?;
13500            let envelope_size = 8;
13501            let bytes_len = max_ordinal as usize * envelope_size;
13502            #[allow(unused_variables)]
13503            let offset = encoder.out_of_line_offset(bytes_len);
13504            let mut _prev_end_offset: usize = 0;
13505            if 1 > max_ordinal {
13506                return Ok(());
13507            }
13508
13509            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13510            // are envelope_size bytes.
13511            let cur_offset: usize = (1 - 1) * envelope_size;
13512
13513            // Zero reserved fields.
13514            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13515
13516            // Safety:
13517            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13518            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13519            //   envelope_size bytes, there is always sufficient room.
13520            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
13521                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
13522                encoder,
13523                offset + cur_offset,
13524                depth,
13525            )?;
13526
13527            _prev_end_offset = cur_offset + envelope_size;
13528            if 2 > max_ordinal {
13529                return Ok(());
13530            }
13531
13532            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13533            // are envelope_size bytes.
13534            let cur_offset: usize = (2 - 1) * envelope_size;
13535
13536            // Zero reserved fields.
13537            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13538
13539            // Safety:
13540            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13541            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13542            //   envelope_size bytes, there is always sufficient room.
13543            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
13544                self.source_name.as_ref().map(
13545                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
13546                ),
13547                encoder,
13548                offset + cur_offset,
13549                depth,
13550            )?;
13551
13552            _prev_end_offset = cur_offset + envelope_size;
13553            if 3 > max_ordinal {
13554                return Ok(());
13555            }
13556
13557            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13558            // are envelope_size bytes.
13559            let cur_offset: usize = (3 - 1) * envelope_size;
13560
13561            // Zero reserved fields.
13562            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13563
13564            // Safety:
13565            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13566            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13567            //   envelope_size bytes, there is always sufficient room.
13568            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
13569                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
13570                encoder,
13571                offset + cur_offset,
13572                depth,
13573            )?;
13574
13575            _prev_end_offset = cur_offset + envelope_size;
13576            if 4 > max_ordinal {
13577                return Ok(());
13578            }
13579
13580            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13581            // are envelope_size bytes.
13582            let cur_offset: usize = (4 - 1) * envelope_size;
13583
13584            // Zero reserved fields.
13585            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13586
13587            // Safety:
13588            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13589            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13590            //   envelope_size bytes, there is always sufficient room.
13591            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
13592                self.target_name.as_ref().map(
13593                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
13594                ),
13595                encoder,
13596                offset + cur_offset,
13597                depth,
13598            )?;
13599
13600            _prev_end_offset = cur_offset + envelope_size;
13601            if 5 > max_ordinal {
13602                return Ok(());
13603            }
13604
13605            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13606            // are envelope_size bytes.
13607            let cur_offset: usize = (5 - 1) * envelope_size;
13608
13609            // Zero reserved fields.
13610            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13611
13612            // Safety:
13613            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13614            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13615            //   envelope_size bytes, there is always sufficient room.
13616            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
13617                self.availability
13618                    .as_ref()
13619                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
13620                encoder,
13621                offset + cur_offset,
13622                depth,
13623            )?;
13624
13625            _prev_end_offset = cur_offset + envelope_size;
13626            if 6 > max_ordinal {
13627                return Ok(());
13628            }
13629
13630            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13631            // are envelope_size bytes.
13632            let cur_offset: usize = (6 - 1) * envelope_size;
13633
13634            // Zero reserved fields.
13635            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13636
13637            // Safety:
13638            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13639            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13640            //   envelope_size bytes, there is always sufficient room.
13641            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
13642            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
13643            encoder, offset + cur_offset, depth
13644        )?;
13645
13646            _prev_end_offset = cur_offset + envelope_size;
13647
13648            Ok(())
13649        }
13650    }
13651
13652    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExposeService {
13653        #[inline(always)]
13654        fn new_empty() -> Self {
13655            Self::default()
13656        }
13657
13658        unsafe fn decode(
13659            &mut self,
13660            decoder: &mut fidl::encoding::Decoder<'_, D>,
13661            offset: usize,
13662            mut depth: fidl::encoding::Depth,
13663        ) -> fidl::Result<()> {
13664            decoder.debug_check_bounds::<Self>(offset);
13665            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13666                None => return Err(fidl::Error::NotNullable),
13667                Some(len) => len,
13668            };
13669            // Calling decoder.out_of_line_offset(0) is not allowed.
13670            if len == 0 {
13671                return Ok(());
13672            };
13673            depth.increment()?;
13674            let envelope_size = 8;
13675            let bytes_len = len * envelope_size;
13676            let offset = decoder.out_of_line_offset(bytes_len)?;
13677            // Decode the envelope for each type.
13678            let mut _next_ordinal_to_read = 0;
13679            let mut next_offset = offset;
13680            let end_offset = offset + bytes_len;
13681            _next_ordinal_to_read += 1;
13682            if next_offset >= end_offset {
13683                return Ok(());
13684            }
13685
13686            // Decode unknown envelopes for gaps in ordinals.
13687            while _next_ordinal_to_read < 1 {
13688                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13689                _next_ordinal_to_read += 1;
13690                next_offset += envelope_size;
13691            }
13692
13693            let next_out_of_line = decoder.next_out_of_line();
13694            let handles_before = decoder.remaining_handles();
13695            if let Some((inlined, num_bytes, num_handles)) =
13696                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13697            {
13698                let member_inline_size =
13699                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13700                if inlined != (member_inline_size <= 4) {
13701                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13702                }
13703                let inner_offset;
13704                let mut inner_depth = depth.clone();
13705                if inlined {
13706                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13707                    inner_offset = next_offset;
13708                } else {
13709                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13710                    inner_depth.increment()?;
13711                }
13712                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
13713                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
13714                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13715                {
13716                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13717                }
13718                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13719                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13720                }
13721            }
13722
13723            next_offset += envelope_size;
13724            _next_ordinal_to_read += 1;
13725            if next_offset >= end_offset {
13726                return Ok(());
13727            }
13728
13729            // Decode unknown envelopes for gaps in ordinals.
13730            while _next_ordinal_to_read < 2 {
13731                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13732                _next_ordinal_to_read += 1;
13733                next_offset += envelope_size;
13734            }
13735
13736            let next_out_of_line = decoder.next_out_of_line();
13737            let handles_before = decoder.remaining_handles();
13738            if let Some((inlined, num_bytes, num_handles)) =
13739                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13740            {
13741                let member_inline_size =
13742                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13743                        decoder.context,
13744                    );
13745                if inlined != (member_inline_size <= 4) {
13746                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13747                }
13748                let inner_offset;
13749                let mut inner_depth = depth.clone();
13750                if inlined {
13751                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13752                    inner_offset = next_offset;
13753                } else {
13754                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13755                    inner_depth.increment()?;
13756                }
13757                let val_ref = self
13758                    .source_name
13759                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
13760                fidl::decode!(
13761                    fidl::encoding::BoundedString<100>,
13762                    D,
13763                    val_ref,
13764                    decoder,
13765                    inner_offset,
13766                    inner_depth
13767                )?;
13768                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13769                {
13770                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13771                }
13772                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13773                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13774                }
13775            }
13776
13777            next_offset += envelope_size;
13778            _next_ordinal_to_read += 1;
13779            if next_offset >= end_offset {
13780                return Ok(());
13781            }
13782
13783            // Decode unknown envelopes for gaps in ordinals.
13784            while _next_ordinal_to_read < 3 {
13785                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13786                _next_ordinal_to_read += 1;
13787                next_offset += envelope_size;
13788            }
13789
13790            let next_out_of_line = decoder.next_out_of_line();
13791            let handles_before = decoder.remaining_handles();
13792            if let Some((inlined, num_bytes, num_handles)) =
13793                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13794            {
13795                let member_inline_size =
13796                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13797                if inlined != (member_inline_size <= 4) {
13798                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13799                }
13800                let inner_offset;
13801                let mut inner_depth = depth.clone();
13802                if inlined {
13803                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13804                    inner_offset = next_offset;
13805                } else {
13806                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13807                    inner_depth.increment()?;
13808                }
13809                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
13810                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
13811                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13812                {
13813                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13814                }
13815                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13816                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13817                }
13818            }
13819
13820            next_offset += envelope_size;
13821            _next_ordinal_to_read += 1;
13822            if next_offset >= end_offset {
13823                return Ok(());
13824            }
13825
13826            // Decode unknown envelopes for gaps in ordinals.
13827            while _next_ordinal_to_read < 4 {
13828                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13829                _next_ordinal_to_read += 1;
13830                next_offset += envelope_size;
13831            }
13832
13833            let next_out_of_line = decoder.next_out_of_line();
13834            let handles_before = decoder.remaining_handles();
13835            if let Some((inlined, num_bytes, num_handles)) =
13836                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13837            {
13838                let member_inline_size =
13839                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
13840                        decoder.context,
13841                    );
13842                if inlined != (member_inline_size <= 4) {
13843                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13844                }
13845                let inner_offset;
13846                let mut inner_depth = depth.clone();
13847                if inlined {
13848                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13849                    inner_offset = next_offset;
13850                } else {
13851                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13852                    inner_depth.increment()?;
13853                }
13854                let val_ref = self
13855                    .target_name
13856                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
13857                fidl::decode!(
13858                    fidl::encoding::BoundedString<100>,
13859                    D,
13860                    val_ref,
13861                    decoder,
13862                    inner_offset,
13863                    inner_depth
13864                )?;
13865                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13866                {
13867                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13868                }
13869                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13870                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13871                }
13872            }
13873
13874            next_offset += envelope_size;
13875            _next_ordinal_to_read += 1;
13876            if next_offset >= end_offset {
13877                return Ok(());
13878            }
13879
13880            // Decode unknown envelopes for gaps in ordinals.
13881            while _next_ordinal_to_read < 5 {
13882                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13883                _next_ordinal_to_read += 1;
13884                next_offset += envelope_size;
13885            }
13886
13887            let next_out_of_line = decoder.next_out_of_line();
13888            let handles_before = decoder.remaining_handles();
13889            if let Some((inlined, num_bytes, num_handles)) =
13890                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13891            {
13892                let member_inline_size =
13893                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13894                if inlined != (member_inline_size <= 4) {
13895                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13896                }
13897                let inner_offset;
13898                let mut inner_depth = depth.clone();
13899                if inlined {
13900                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13901                    inner_offset = next_offset;
13902                } else {
13903                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13904                    inner_depth.increment()?;
13905                }
13906                let val_ref =
13907                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
13908                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
13909                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13910                {
13911                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13912                }
13913                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13914                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13915                }
13916            }
13917
13918            next_offset += envelope_size;
13919            _next_ordinal_to_read += 1;
13920            if next_offset >= end_offset {
13921                return Ok(());
13922            }
13923
13924            // Decode unknown envelopes for gaps in ordinals.
13925            while _next_ordinal_to_read < 6 {
13926                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13927                _next_ordinal_to_read += 1;
13928                next_offset += envelope_size;
13929            }
13930
13931            let next_out_of_line = decoder.next_out_of_line();
13932            let handles_before = decoder.remaining_handles();
13933            if let Some((inlined, num_bytes, num_handles)) =
13934                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13935            {
13936                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13937                if inlined != (member_inline_size <= 4) {
13938                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13939                }
13940                let inner_offset;
13941                let mut inner_depth = depth.clone();
13942                if inlined {
13943                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13944                    inner_offset = next_offset;
13945                } else {
13946                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13947                    inner_depth.increment()?;
13948                }
13949                let val_ref = self.source_dictionary.get_or_insert_with(|| {
13950                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
13951                });
13952                fidl::decode!(
13953                    fidl::encoding::BoundedString<1024>,
13954                    D,
13955                    val_ref,
13956                    decoder,
13957                    inner_offset,
13958                    inner_depth
13959                )?;
13960                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13961                {
13962                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13963                }
13964                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13965                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13966                }
13967            }
13968
13969            next_offset += envelope_size;
13970
13971            // Decode the remaining unknown envelopes.
13972            while next_offset < end_offset {
13973                _next_ordinal_to_read += 1;
13974                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13975                next_offset += envelope_size;
13976            }
13977
13978            Ok(())
13979        }
13980    }
13981
13982    impl OfferConfiguration {
13983        #[inline(always)]
13984        fn max_ordinal_present(&self) -> u64 {
13985            if let Some(_) = self.source_dictionary {
13986                return 6;
13987            }
13988            if let Some(_) = self.availability {
13989                return 5;
13990            }
13991            if let Some(_) = self.target_name {
13992                return 4;
13993            }
13994            if let Some(_) = self.target {
13995                return 3;
13996            }
13997            if let Some(_) = self.source_name {
13998                return 2;
13999            }
14000            if let Some(_) = self.source {
14001                return 1;
14002            }
14003            0
14004        }
14005    }
14006
14007    impl fidl::encoding::ValueTypeMarker for OfferConfiguration {
14008        type Borrowed<'a> = &'a Self;
14009        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14010            value
14011        }
14012    }
14013
14014    unsafe impl fidl::encoding::TypeMarker for OfferConfiguration {
14015        type Owned = Self;
14016
14017        #[inline(always)]
14018        fn inline_align(_context: fidl::encoding::Context) -> usize {
14019            8
14020        }
14021
14022        #[inline(always)]
14023        fn inline_size(_context: fidl::encoding::Context) -> usize {
14024            16
14025        }
14026    }
14027
14028    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferConfiguration, D>
14029        for &OfferConfiguration
14030    {
14031        unsafe fn encode(
14032            self,
14033            encoder: &mut fidl::encoding::Encoder<'_, D>,
14034            offset: usize,
14035            mut depth: fidl::encoding::Depth,
14036        ) -> fidl::Result<()> {
14037            encoder.debug_check_bounds::<OfferConfiguration>(offset);
14038            // Vector header
14039            let max_ordinal: u64 = self.max_ordinal_present();
14040            encoder.write_num(max_ordinal, offset);
14041            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14042            // Calling encoder.out_of_line_offset(0) is not allowed.
14043            if max_ordinal == 0 {
14044                return Ok(());
14045            }
14046            depth.increment()?;
14047            let envelope_size = 8;
14048            let bytes_len = max_ordinal as usize * envelope_size;
14049            #[allow(unused_variables)]
14050            let offset = encoder.out_of_line_offset(bytes_len);
14051            let mut _prev_end_offset: usize = 0;
14052            if 1 > max_ordinal {
14053                return Ok(());
14054            }
14055
14056            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14057            // are envelope_size bytes.
14058            let cur_offset: usize = (1 - 1) * envelope_size;
14059
14060            // Zero reserved fields.
14061            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14062
14063            // Safety:
14064            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14065            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14066            //   envelope_size bytes, there is always sufficient room.
14067            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
14068                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
14069                encoder,
14070                offset + cur_offset,
14071                depth,
14072            )?;
14073
14074            _prev_end_offset = cur_offset + envelope_size;
14075            if 2 > max_ordinal {
14076                return Ok(());
14077            }
14078
14079            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14080            // are envelope_size bytes.
14081            let cur_offset: usize = (2 - 1) * envelope_size;
14082
14083            // Zero reserved fields.
14084            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14085
14086            // Safety:
14087            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14088            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14089            //   envelope_size bytes, there is always sufficient room.
14090            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
14091                self.source_name.as_ref().map(
14092                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
14093                ),
14094                encoder,
14095                offset + cur_offset,
14096                depth,
14097            )?;
14098
14099            _prev_end_offset = cur_offset + envelope_size;
14100            if 3 > max_ordinal {
14101                return Ok(());
14102            }
14103
14104            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14105            // are envelope_size bytes.
14106            let cur_offset: usize = (3 - 1) * envelope_size;
14107
14108            // Zero reserved fields.
14109            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14110
14111            // Safety:
14112            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14113            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14114            //   envelope_size bytes, there is always sufficient room.
14115            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
14116                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
14117                encoder,
14118                offset + cur_offset,
14119                depth,
14120            )?;
14121
14122            _prev_end_offset = cur_offset + envelope_size;
14123            if 4 > max_ordinal {
14124                return Ok(());
14125            }
14126
14127            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14128            // are envelope_size bytes.
14129            let cur_offset: usize = (4 - 1) * envelope_size;
14130
14131            // Zero reserved fields.
14132            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14133
14134            // Safety:
14135            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14136            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14137            //   envelope_size bytes, there is always sufficient room.
14138            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
14139                self.target_name.as_ref().map(
14140                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
14141                ),
14142                encoder,
14143                offset + cur_offset,
14144                depth,
14145            )?;
14146
14147            _prev_end_offset = cur_offset + envelope_size;
14148            if 5 > max_ordinal {
14149                return Ok(());
14150            }
14151
14152            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14153            // are envelope_size bytes.
14154            let cur_offset: usize = (5 - 1) * envelope_size;
14155
14156            // Zero reserved fields.
14157            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14158
14159            // Safety:
14160            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14161            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14162            //   envelope_size bytes, there is always sufficient room.
14163            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
14164                self.availability
14165                    .as_ref()
14166                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
14167                encoder,
14168                offset + cur_offset,
14169                depth,
14170            )?;
14171
14172            _prev_end_offset = cur_offset + envelope_size;
14173            if 6 > max_ordinal {
14174                return Ok(());
14175            }
14176
14177            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14178            // are envelope_size bytes.
14179            let cur_offset: usize = (6 - 1) * envelope_size;
14180
14181            // Zero reserved fields.
14182            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14183
14184            // Safety:
14185            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14186            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14187            //   envelope_size bytes, there is always sufficient room.
14188            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
14189            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
14190            encoder, offset + cur_offset, depth
14191        )?;
14192
14193            _prev_end_offset = cur_offset + envelope_size;
14194
14195            Ok(())
14196        }
14197    }
14198
14199    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferConfiguration {
14200        #[inline(always)]
14201        fn new_empty() -> Self {
14202            Self::default()
14203        }
14204
14205        unsafe fn decode(
14206            &mut self,
14207            decoder: &mut fidl::encoding::Decoder<'_, D>,
14208            offset: usize,
14209            mut depth: fidl::encoding::Depth,
14210        ) -> fidl::Result<()> {
14211            decoder.debug_check_bounds::<Self>(offset);
14212            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
14213                None => return Err(fidl::Error::NotNullable),
14214                Some(len) => len,
14215            };
14216            // Calling decoder.out_of_line_offset(0) is not allowed.
14217            if len == 0 {
14218                return Ok(());
14219            };
14220            depth.increment()?;
14221            let envelope_size = 8;
14222            let bytes_len = len * envelope_size;
14223            let offset = decoder.out_of_line_offset(bytes_len)?;
14224            // Decode the envelope for each type.
14225            let mut _next_ordinal_to_read = 0;
14226            let mut next_offset = offset;
14227            let end_offset = offset + bytes_len;
14228            _next_ordinal_to_read += 1;
14229            if next_offset >= end_offset {
14230                return Ok(());
14231            }
14232
14233            // Decode unknown envelopes for gaps in ordinals.
14234            while _next_ordinal_to_read < 1 {
14235                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14236                _next_ordinal_to_read += 1;
14237                next_offset += envelope_size;
14238            }
14239
14240            let next_out_of_line = decoder.next_out_of_line();
14241            let handles_before = decoder.remaining_handles();
14242            if let Some((inlined, num_bytes, num_handles)) =
14243                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14244            {
14245                let member_inline_size =
14246                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14247                if inlined != (member_inline_size <= 4) {
14248                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14249                }
14250                let inner_offset;
14251                let mut inner_depth = depth.clone();
14252                if inlined {
14253                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14254                    inner_offset = next_offset;
14255                } else {
14256                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14257                    inner_depth.increment()?;
14258                }
14259                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
14260                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
14261                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14262                {
14263                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14264                }
14265                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14266                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14267                }
14268            }
14269
14270            next_offset += envelope_size;
14271            _next_ordinal_to_read += 1;
14272            if next_offset >= end_offset {
14273                return Ok(());
14274            }
14275
14276            // Decode unknown envelopes for gaps in ordinals.
14277            while _next_ordinal_to_read < 2 {
14278                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14279                _next_ordinal_to_read += 1;
14280                next_offset += envelope_size;
14281            }
14282
14283            let next_out_of_line = decoder.next_out_of_line();
14284            let handles_before = decoder.remaining_handles();
14285            if let Some((inlined, num_bytes, num_handles)) =
14286                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14287            {
14288                let member_inline_size =
14289                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
14290                        decoder.context,
14291                    );
14292                if inlined != (member_inline_size <= 4) {
14293                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14294                }
14295                let inner_offset;
14296                let mut inner_depth = depth.clone();
14297                if inlined {
14298                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14299                    inner_offset = next_offset;
14300                } else {
14301                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14302                    inner_depth.increment()?;
14303                }
14304                let val_ref = self
14305                    .source_name
14306                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
14307                fidl::decode!(
14308                    fidl::encoding::BoundedString<100>,
14309                    D,
14310                    val_ref,
14311                    decoder,
14312                    inner_offset,
14313                    inner_depth
14314                )?;
14315                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14316                {
14317                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14318                }
14319                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14320                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14321                }
14322            }
14323
14324            next_offset += envelope_size;
14325            _next_ordinal_to_read += 1;
14326            if next_offset >= end_offset {
14327                return Ok(());
14328            }
14329
14330            // Decode unknown envelopes for gaps in ordinals.
14331            while _next_ordinal_to_read < 3 {
14332                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14333                _next_ordinal_to_read += 1;
14334                next_offset += envelope_size;
14335            }
14336
14337            let next_out_of_line = decoder.next_out_of_line();
14338            let handles_before = decoder.remaining_handles();
14339            if let Some((inlined, num_bytes, num_handles)) =
14340                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14341            {
14342                let member_inline_size =
14343                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14344                if inlined != (member_inline_size <= 4) {
14345                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14346                }
14347                let inner_offset;
14348                let mut inner_depth = depth.clone();
14349                if inlined {
14350                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14351                    inner_offset = next_offset;
14352                } else {
14353                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14354                    inner_depth.increment()?;
14355                }
14356                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
14357                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
14358                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14359                {
14360                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14361                }
14362                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14363                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14364                }
14365            }
14366
14367            next_offset += envelope_size;
14368            _next_ordinal_to_read += 1;
14369            if next_offset >= end_offset {
14370                return Ok(());
14371            }
14372
14373            // Decode unknown envelopes for gaps in ordinals.
14374            while _next_ordinal_to_read < 4 {
14375                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14376                _next_ordinal_to_read += 1;
14377                next_offset += envelope_size;
14378            }
14379
14380            let next_out_of_line = decoder.next_out_of_line();
14381            let handles_before = decoder.remaining_handles();
14382            if let Some((inlined, num_bytes, num_handles)) =
14383                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14384            {
14385                let member_inline_size =
14386                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
14387                        decoder.context,
14388                    );
14389                if inlined != (member_inline_size <= 4) {
14390                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14391                }
14392                let inner_offset;
14393                let mut inner_depth = depth.clone();
14394                if inlined {
14395                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14396                    inner_offset = next_offset;
14397                } else {
14398                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14399                    inner_depth.increment()?;
14400                }
14401                let val_ref = self
14402                    .target_name
14403                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
14404                fidl::decode!(
14405                    fidl::encoding::BoundedString<100>,
14406                    D,
14407                    val_ref,
14408                    decoder,
14409                    inner_offset,
14410                    inner_depth
14411                )?;
14412                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14413                {
14414                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14415                }
14416                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14417                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14418                }
14419            }
14420
14421            next_offset += envelope_size;
14422            _next_ordinal_to_read += 1;
14423            if next_offset >= end_offset {
14424                return Ok(());
14425            }
14426
14427            // Decode unknown envelopes for gaps in ordinals.
14428            while _next_ordinal_to_read < 5 {
14429                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14430                _next_ordinal_to_read += 1;
14431                next_offset += envelope_size;
14432            }
14433
14434            let next_out_of_line = decoder.next_out_of_line();
14435            let handles_before = decoder.remaining_handles();
14436            if let Some((inlined, num_bytes, num_handles)) =
14437                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14438            {
14439                let member_inline_size =
14440                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14441                if inlined != (member_inline_size <= 4) {
14442                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14443                }
14444                let inner_offset;
14445                let mut inner_depth = depth.clone();
14446                if inlined {
14447                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14448                    inner_offset = next_offset;
14449                } else {
14450                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14451                    inner_depth.increment()?;
14452                }
14453                let val_ref =
14454                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
14455                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
14456                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14457                {
14458                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14459                }
14460                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14461                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14462                }
14463            }
14464
14465            next_offset += envelope_size;
14466            _next_ordinal_to_read += 1;
14467            if next_offset >= end_offset {
14468                return Ok(());
14469            }
14470
14471            // Decode unknown envelopes for gaps in ordinals.
14472            while _next_ordinal_to_read < 6 {
14473                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14474                _next_ordinal_to_read += 1;
14475                next_offset += envelope_size;
14476            }
14477
14478            let next_out_of_line = decoder.next_out_of_line();
14479            let handles_before = decoder.remaining_handles();
14480            if let Some((inlined, num_bytes, num_handles)) =
14481                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14482            {
14483                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14484                if inlined != (member_inline_size <= 4) {
14485                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14486                }
14487                let inner_offset;
14488                let mut inner_depth = depth.clone();
14489                if inlined {
14490                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14491                    inner_offset = next_offset;
14492                } else {
14493                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14494                    inner_depth.increment()?;
14495                }
14496                let val_ref = self.source_dictionary.get_or_insert_with(|| {
14497                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
14498                });
14499                fidl::decode!(
14500                    fidl::encoding::BoundedString<1024>,
14501                    D,
14502                    val_ref,
14503                    decoder,
14504                    inner_offset,
14505                    inner_depth
14506                )?;
14507                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14508                {
14509                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14510                }
14511                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14512                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14513                }
14514            }
14515
14516            next_offset += envelope_size;
14517
14518            // Decode the remaining unknown envelopes.
14519            while next_offset < end_offset {
14520                _next_ordinal_to_read += 1;
14521                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14522                next_offset += envelope_size;
14523            }
14524
14525            Ok(())
14526        }
14527    }
14528
14529    impl OfferDictionary {
14530        #[inline(always)]
14531        fn max_ordinal_present(&self) -> u64 {
14532            if let Some(_) = self.source_dictionary {
14533                return 7;
14534            }
14535            if let Some(_) = self.availability {
14536                return 6;
14537            }
14538            if let Some(_) = self.dependency_type {
14539                return 5;
14540            }
14541            if let Some(_) = self.target_name {
14542                return 4;
14543            }
14544            if let Some(_) = self.target {
14545                return 3;
14546            }
14547            if let Some(_) = self.source_name {
14548                return 2;
14549            }
14550            if let Some(_) = self.source {
14551                return 1;
14552            }
14553            0
14554        }
14555    }
14556
14557    impl fidl::encoding::ValueTypeMarker for OfferDictionary {
14558        type Borrowed<'a> = &'a Self;
14559        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14560            value
14561        }
14562    }
14563
14564    unsafe impl fidl::encoding::TypeMarker for OfferDictionary {
14565        type Owned = Self;
14566
14567        #[inline(always)]
14568        fn inline_align(_context: fidl::encoding::Context) -> usize {
14569            8
14570        }
14571
14572        #[inline(always)]
14573        fn inline_size(_context: fidl::encoding::Context) -> usize {
14574            16
14575        }
14576    }
14577
14578    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferDictionary, D>
14579        for &OfferDictionary
14580    {
14581        unsafe fn encode(
14582            self,
14583            encoder: &mut fidl::encoding::Encoder<'_, D>,
14584            offset: usize,
14585            mut depth: fidl::encoding::Depth,
14586        ) -> fidl::Result<()> {
14587            encoder.debug_check_bounds::<OfferDictionary>(offset);
14588            // Vector header
14589            let max_ordinal: u64 = self.max_ordinal_present();
14590            encoder.write_num(max_ordinal, offset);
14591            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14592            // Calling encoder.out_of_line_offset(0) is not allowed.
14593            if max_ordinal == 0 {
14594                return Ok(());
14595            }
14596            depth.increment()?;
14597            let envelope_size = 8;
14598            let bytes_len = max_ordinal as usize * envelope_size;
14599            #[allow(unused_variables)]
14600            let offset = encoder.out_of_line_offset(bytes_len);
14601            let mut _prev_end_offset: usize = 0;
14602            if 1 > max_ordinal {
14603                return Ok(());
14604            }
14605
14606            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14607            // are envelope_size bytes.
14608            let cur_offset: usize = (1 - 1) * envelope_size;
14609
14610            // Zero reserved fields.
14611            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14612
14613            // Safety:
14614            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14615            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14616            //   envelope_size bytes, there is always sufficient room.
14617            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
14618                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
14619                encoder,
14620                offset + cur_offset,
14621                depth,
14622            )?;
14623
14624            _prev_end_offset = cur_offset + envelope_size;
14625            if 2 > max_ordinal {
14626                return Ok(());
14627            }
14628
14629            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14630            // are envelope_size bytes.
14631            let cur_offset: usize = (2 - 1) * envelope_size;
14632
14633            // Zero reserved fields.
14634            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14635
14636            // Safety:
14637            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14638            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14639            //   envelope_size bytes, there is always sufficient room.
14640            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
14641                self.source_name.as_ref().map(
14642                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
14643                ),
14644                encoder,
14645                offset + cur_offset,
14646                depth,
14647            )?;
14648
14649            _prev_end_offset = cur_offset + envelope_size;
14650            if 3 > max_ordinal {
14651                return Ok(());
14652            }
14653
14654            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14655            // are envelope_size bytes.
14656            let cur_offset: usize = (3 - 1) * envelope_size;
14657
14658            // Zero reserved fields.
14659            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14660
14661            // Safety:
14662            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14663            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14664            //   envelope_size bytes, there is always sufficient room.
14665            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
14666                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
14667                encoder,
14668                offset + cur_offset,
14669                depth,
14670            )?;
14671
14672            _prev_end_offset = cur_offset + envelope_size;
14673            if 4 > max_ordinal {
14674                return Ok(());
14675            }
14676
14677            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14678            // are envelope_size bytes.
14679            let cur_offset: usize = (4 - 1) * envelope_size;
14680
14681            // Zero reserved fields.
14682            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14683
14684            // Safety:
14685            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14686            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14687            //   envelope_size bytes, there is always sufficient room.
14688            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
14689                self.target_name.as_ref().map(
14690                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
14691                ),
14692                encoder,
14693                offset + cur_offset,
14694                depth,
14695            )?;
14696
14697            _prev_end_offset = cur_offset + envelope_size;
14698            if 5 > max_ordinal {
14699                return Ok(());
14700            }
14701
14702            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14703            // are envelope_size bytes.
14704            let cur_offset: usize = (5 - 1) * envelope_size;
14705
14706            // Zero reserved fields.
14707            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14708
14709            // Safety:
14710            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14711            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14712            //   envelope_size bytes, there is always sufficient room.
14713            fidl::encoding::encode_in_envelope_optional::<DependencyType, D>(
14714                self.dependency_type
14715                    .as_ref()
14716                    .map(<DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
14717                encoder,
14718                offset + cur_offset,
14719                depth,
14720            )?;
14721
14722            _prev_end_offset = cur_offset + envelope_size;
14723            if 6 > max_ordinal {
14724                return Ok(());
14725            }
14726
14727            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14728            // are envelope_size bytes.
14729            let cur_offset: usize = (6 - 1) * envelope_size;
14730
14731            // Zero reserved fields.
14732            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14733
14734            // Safety:
14735            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14736            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14737            //   envelope_size bytes, there is always sufficient room.
14738            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
14739                self.availability
14740                    .as_ref()
14741                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
14742                encoder,
14743                offset + cur_offset,
14744                depth,
14745            )?;
14746
14747            _prev_end_offset = cur_offset + envelope_size;
14748            if 7 > max_ordinal {
14749                return Ok(());
14750            }
14751
14752            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14753            // are envelope_size bytes.
14754            let cur_offset: usize = (7 - 1) * envelope_size;
14755
14756            // Zero reserved fields.
14757            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14758
14759            // Safety:
14760            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14761            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14762            //   envelope_size bytes, there is always sufficient room.
14763            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
14764            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
14765            encoder, offset + cur_offset, depth
14766        )?;
14767
14768            _prev_end_offset = cur_offset + envelope_size;
14769
14770            Ok(())
14771        }
14772    }
14773
14774    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferDictionary {
14775        #[inline(always)]
14776        fn new_empty() -> Self {
14777            Self::default()
14778        }
14779
14780        unsafe fn decode(
14781            &mut self,
14782            decoder: &mut fidl::encoding::Decoder<'_, D>,
14783            offset: usize,
14784            mut depth: fidl::encoding::Depth,
14785        ) -> fidl::Result<()> {
14786            decoder.debug_check_bounds::<Self>(offset);
14787            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
14788                None => return Err(fidl::Error::NotNullable),
14789                Some(len) => len,
14790            };
14791            // Calling decoder.out_of_line_offset(0) is not allowed.
14792            if len == 0 {
14793                return Ok(());
14794            };
14795            depth.increment()?;
14796            let envelope_size = 8;
14797            let bytes_len = len * envelope_size;
14798            let offset = decoder.out_of_line_offset(bytes_len)?;
14799            // Decode the envelope for each type.
14800            let mut _next_ordinal_to_read = 0;
14801            let mut next_offset = offset;
14802            let end_offset = offset + bytes_len;
14803            _next_ordinal_to_read += 1;
14804            if next_offset >= end_offset {
14805                return Ok(());
14806            }
14807
14808            // Decode unknown envelopes for gaps in ordinals.
14809            while _next_ordinal_to_read < 1 {
14810                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14811                _next_ordinal_to_read += 1;
14812                next_offset += envelope_size;
14813            }
14814
14815            let next_out_of_line = decoder.next_out_of_line();
14816            let handles_before = decoder.remaining_handles();
14817            if let Some((inlined, num_bytes, num_handles)) =
14818                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14819            {
14820                let member_inline_size =
14821                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14822                if inlined != (member_inline_size <= 4) {
14823                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14824                }
14825                let inner_offset;
14826                let mut inner_depth = depth.clone();
14827                if inlined {
14828                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14829                    inner_offset = next_offset;
14830                } else {
14831                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14832                    inner_depth.increment()?;
14833                }
14834                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
14835                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
14836                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14837                {
14838                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14839                }
14840                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14841                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14842                }
14843            }
14844
14845            next_offset += envelope_size;
14846            _next_ordinal_to_read += 1;
14847            if next_offset >= end_offset {
14848                return Ok(());
14849            }
14850
14851            // Decode unknown envelopes for gaps in ordinals.
14852            while _next_ordinal_to_read < 2 {
14853                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14854                _next_ordinal_to_read += 1;
14855                next_offset += envelope_size;
14856            }
14857
14858            let next_out_of_line = decoder.next_out_of_line();
14859            let handles_before = decoder.remaining_handles();
14860            if let Some((inlined, num_bytes, num_handles)) =
14861                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14862            {
14863                let member_inline_size =
14864                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
14865                        decoder.context,
14866                    );
14867                if inlined != (member_inline_size <= 4) {
14868                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14869                }
14870                let inner_offset;
14871                let mut inner_depth = depth.clone();
14872                if inlined {
14873                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14874                    inner_offset = next_offset;
14875                } else {
14876                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14877                    inner_depth.increment()?;
14878                }
14879                let val_ref = self
14880                    .source_name
14881                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
14882                fidl::decode!(
14883                    fidl::encoding::BoundedString<100>,
14884                    D,
14885                    val_ref,
14886                    decoder,
14887                    inner_offset,
14888                    inner_depth
14889                )?;
14890                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14891                {
14892                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14893                }
14894                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14895                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14896                }
14897            }
14898
14899            next_offset += envelope_size;
14900            _next_ordinal_to_read += 1;
14901            if next_offset >= end_offset {
14902                return Ok(());
14903            }
14904
14905            // Decode unknown envelopes for gaps in ordinals.
14906            while _next_ordinal_to_read < 3 {
14907                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14908                _next_ordinal_to_read += 1;
14909                next_offset += envelope_size;
14910            }
14911
14912            let next_out_of_line = decoder.next_out_of_line();
14913            let handles_before = decoder.remaining_handles();
14914            if let Some((inlined, num_bytes, num_handles)) =
14915                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14916            {
14917                let member_inline_size =
14918                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14919                if inlined != (member_inline_size <= 4) {
14920                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14921                }
14922                let inner_offset;
14923                let mut inner_depth = depth.clone();
14924                if inlined {
14925                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14926                    inner_offset = next_offset;
14927                } else {
14928                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14929                    inner_depth.increment()?;
14930                }
14931                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
14932                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
14933                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14934                {
14935                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14936                }
14937                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14938                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14939                }
14940            }
14941
14942            next_offset += envelope_size;
14943            _next_ordinal_to_read += 1;
14944            if next_offset >= end_offset {
14945                return Ok(());
14946            }
14947
14948            // Decode unknown envelopes for gaps in ordinals.
14949            while _next_ordinal_to_read < 4 {
14950                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14951                _next_ordinal_to_read += 1;
14952                next_offset += envelope_size;
14953            }
14954
14955            let next_out_of_line = decoder.next_out_of_line();
14956            let handles_before = decoder.remaining_handles();
14957            if let Some((inlined, num_bytes, num_handles)) =
14958                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14959            {
14960                let member_inline_size =
14961                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
14962                        decoder.context,
14963                    );
14964                if inlined != (member_inline_size <= 4) {
14965                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14966                }
14967                let inner_offset;
14968                let mut inner_depth = depth.clone();
14969                if inlined {
14970                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14971                    inner_offset = next_offset;
14972                } else {
14973                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14974                    inner_depth.increment()?;
14975                }
14976                let val_ref = self
14977                    .target_name
14978                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
14979                fidl::decode!(
14980                    fidl::encoding::BoundedString<100>,
14981                    D,
14982                    val_ref,
14983                    decoder,
14984                    inner_offset,
14985                    inner_depth
14986                )?;
14987                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14988                {
14989                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14990                }
14991                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14992                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14993                }
14994            }
14995
14996            next_offset += envelope_size;
14997            _next_ordinal_to_read += 1;
14998            if next_offset >= end_offset {
14999                return Ok(());
15000            }
15001
15002            // Decode unknown envelopes for gaps in ordinals.
15003            while _next_ordinal_to_read < 5 {
15004                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15005                _next_ordinal_to_read += 1;
15006                next_offset += envelope_size;
15007            }
15008
15009            let next_out_of_line = decoder.next_out_of_line();
15010            let handles_before = decoder.remaining_handles();
15011            if let Some((inlined, num_bytes, num_handles)) =
15012                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15013            {
15014                let member_inline_size =
15015                    <DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15016                if inlined != (member_inline_size <= 4) {
15017                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15018                }
15019                let inner_offset;
15020                let mut inner_depth = depth.clone();
15021                if inlined {
15022                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15023                    inner_offset = next_offset;
15024                } else {
15025                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15026                    inner_depth.increment()?;
15027                }
15028                let val_ref =
15029                    self.dependency_type.get_or_insert_with(|| fidl::new_empty!(DependencyType, D));
15030                fidl::decode!(DependencyType, D, val_ref, decoder, inner_offset, inner_depth)?;
15031                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15032                {
15033                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15034                }
15035                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15036                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15037                }
15038            }
15039
15040            next_offset += envelope_size;
15041            _next_ordinal_to_read += 1;
15042            if next_offset >= end_offset {
15043                return Ok(());
15044            }
15045
15046            // Decode unknown envelopes for gaps in ordinals.
15047            while _next_ordinal_to_read < 6 {
15048                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15049                _next_ordinal_to_read += 1;
15050                next_offset += envelope_size;
15051            }
15052
15053            let next_out_of_line = decoder.next_out_of_line();
15054            let handles_before = decoder.remaining_handles();
15055            if let Some((inlined, num_bytes, num_handles)) =
15056                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15057            {
15058                let member_inline_size =
15059                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15060                if inlined != (member_inline_size <= 4) {
15061                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15062                }
15063                let inner_offset;
15064                let mut inner_depth = depth.clone();
15065                if inlined {
15066                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15067                    inner_offset = next_offset;
15068                } else {
15069                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15070                    inner_depth.increment()?;
15071                }
15072                let val_ref =
15073                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
15074                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
15075                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15076                {
15077                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15078                }
15079                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15080                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15081                }
15082            }
15083
15084            next_offset += envelope_size;
15085            _next_ordinal_to_read += 1;
15086            if next_offset >= end_offset {
15087                return Ok(());
15088            }
15089
15090            // Decode unknown envelopes for gaps in ordinals.
15091            while _next_ordinal_to_read < 7 {
15092                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15093                _next_ordinal_to_read += 1;
15094                next_offset += envelope_size;
15095            }
15096
15097            let next_out_of_line = decoder.next_out_of_line();
15098            let handles_before = decoder.remaining_handles();
15099            if let Some((inlined, num_bytes, num_handles)) =
15100                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15101            {
15102                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15103                if inlined != (member_inline_size <= 4) {
15104                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15105                }
15106                let inner_offset;
15107                let mut inner_depth = depth.clone();
15108                if inlined {
15109                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15110                    inner_offset = next_offset;
15111                } else {
15112                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15113                    inner_depth.increment()?;
15114                }
15115                let val_ref = self.source_dictionary.get_or_insert_with(|| {
15116                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
15117                });
15118                fidl::decode!(
15119                    fidl::encoding::BoundedString<1024>,
15120                    D,
15121                    val_ref,
15122                    decoder,
15123                    inner_offset,
15124                    inner_depth
15125                )?;
15126                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15127                {
15128                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15129                }
15130                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15131                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15132                }
15133            }
15134
15135            next_offset += envelope_size;
15136
15137            // Decode the remaining unknown envelopes.
15138            while next_offset < end_offset {
15139                _next_ordinal_to_read += 1;
15140                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15141                next_offset += envelope_size;
15142            }
15143
15144            Ok(())
15145        }
15146    }
15147
15148    impl OfferDirectory {
15149        #[inline(always)]
15150        fn max_ordinal_present(&self) -> u64 {
15151            if let Some(_) = self.source_dictionary {
15152                return 9;
15153            }
15154            if let Some(_) = self.availability {
15155                return 8;
15156            }
15157            if let Some(_) = self.dependency_type {
15158                return 7;
15159            }
15160            if let Some(_) = self.subdir {
15161                return 6;
15162            }
15163            if let Some(_) = self.rights {
15164                return 5;
15165            }
15166            if let Some(_) = self.target_name {
15167                return 4;
15168            }
15169            if let Some(_) = self.target {
15170                return 3;
15171            }
15172            if let Some(_) = self.source_name {
15173                return 2;
15174            }
15175            if let Some(_) = self.source {
15176                return 1;
15177            }
15178            0
15179        }
15180    }
15181
15182    impl fidl::encoding::ValueTypeMarker for OfferDirectory {
15183        type Borrowed<'a> = &'a Self;
15184        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15185            value
15186        }
15187    }
15188
15189    unsafe impl fidl::encoding::TypeMarker for OfferDirectory {
15190        type Owned = Self;
15191
15192        #[inline(always)]
15193        fn inline_align(_context: fidl::encoding::Context) -> usize {
15194            8
15195        }
15196
15197        #[inline(always)]
15198        fn inline_size(_context: fidl::encoding::Context) -> usize {
15199            16
15200        }
15201    }
15202
15203    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferDirectory, D>
15204        for &OfferDirectory
15205    {
15206        unsafe fn encode(
15207            self,
15208            encoder: &mut fidl::encoding::Encoder<'_, D>,
15209            offset: usize,
15210            mut depth: fidl::encoding::Depth,
15211        ) -> fidl::Result<()> {
15212            encoder.debug_check_bounds::<OfferDirectory>(offset);
15213            // Vector header
15214            let max_ordinal: u64 = self.max_ordinal_present();
15215            encoder.write_num(max_ordinal, offset);
15216            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15217            // Calling encoder.out_of_line_offset(0) is not allowed.
15218            if max_ordinal == 0 {
15219                return Ok(());
15220            }
15221            depth.increment()?;
15222            let envelope_size = 8;
15223            let bytes_len = max_ordinal as usize * envelope_size;
15224            #[allow(unused_variables)]
15225            let offset = encoder.out_of_line_offset(bytes_len);
15226            let mut _prev_end_offset: usize = 0;
15227            if 1 > max_ordinal {
15228                return Ok(());
15229            }
15230
15231            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15232            // are envelope_size bytes.
15233            let cur_offset: usize = (1 - 1) * envelope_size;
15234
15235            // Zero reserved fields.
15236            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15237
15238            // Safety:
15239            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15240            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15241            //   envelope_size bytes, there is always sufficient room.
15242            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
15243                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
15244                encoder,
15245                offset + cur_offset,
15246                depth,
15247            )?;
15248
15249            _prev_end_offset = cur_offset + envelope_size;
15250            if 2 > max_ordinal {
15251                return Ok(());
15252            }
15253
15254            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15255            // are envelope_size bytes.
15256            let cur_offset: usize = (2 - 1) * envelope_size;
15257
15258            // Zero reserved fields.
15259            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15260
15261            // Safety:
15262            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15263            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15264            //   envelope_size bytes, there is always sufficient room.
15265            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
15266                self.source_name.as_ref().map(
15267                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
15268                ),
15269                encoder,
15270                offset + cur_offset,
15271                depth,
15272            )?;
15273
15274            _prev_end_offset = cur_offset + envelope_size;
15275            if 3 > max_ordinal {
15276                return Ok(());
15277            }
15278
15279            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15280            // are envelope_size bytes.
15281            let cur_offset: usize = (3 - 1) * envelope_size;
15282
15283            // Zero reserved fields.
15284            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15285
15286            // Safety:
15287            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15288            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15289            //   envelope_size bytes, there is always sufficient room.
15290            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
15291                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
15292                encoder,
15293                offset + cur_offset,
15294                depth,
15295            )?;
15296
15297            _prev_end_offset = cur_offset + envelope_size;
15298            if 4 > max_ordinal {
15299                return Ok(());
15300            }
15301
15302            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15303            // are envelope_size bytes.
15304            let cur_offset: usize = (4 - 1) * envelope_size;
15305
15306            // Zero reserved fields.
15307            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15308
15309            // Safety:
15310            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15311            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15312            //   envelope_size bytes, there is always sufficient room.
15313            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
15314                self.target_name.as_ref().map(
15315                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
15316                ),
15317                encoder,
15318                offset + cur_offset,
15319                depth,
15320            )?;
15321
15322            _prev_end_offset = cur_offset + envelope_size;
15323            if 5 > max_ordinal {
15324                return Ok(());
15325            }
15326
15327            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15328            // are envelope_size bytes.
15329            let cur_offset: usize = (5 - 1) * envelope_size;
15330
15331            // Zero reserved fields.
15332            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15333
15334            // Safety:
15335            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15336            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15337            //   envelope_size bytes, there is always sufficient room.
15338            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_io__common::Operations, D>(
15339            self.rights.as_ref().map(<fidl_fuchsia_io__common::Operations as fidl::encoding::ValueTypeMarker>::borrow),
15340            encoder, offset + cur_offset, depth
15341        )?;
15342
15343            _prev_end_offset = cur_offset + envelope_size;
15344            if 6 > max_ordinal {
15345                return Ok(());
15346            }
15347
15348            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15349            // are envelope_size bytes.
15350            let cur_offset: usize = (6 - 1) * envelope_size;
15351
15352            // Zero reserved fields.
15353            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15354
15355            // Safety:
15356            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15357            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15358            //   envelope_size bytes, there is always sufficient room.
15359            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
15360            self.subdir.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
15361            encoder, offset + cur_offset, depth
15362        )?;
15363
15364            _prev_end_offset = cur_offset + envelope_size;
15365            if 7 > max_ordinal {
15366                return Ok(());
15367            }
15368
15369            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15370            // are envelope_size bytes.
15371            let cur_offset: usize = (7 - 1) * envelope_size;
15372
15373            // Zero reserved fields.
15374            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15375
15376            // Safety:
15377            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15378            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15379            //   envelope_size bytes, there is always sufficient room.
15380            fidl::encoding::encode_in_envelope_optional::<DependencyType, D>(
15381                self.dependency_type
15382                    .as_ref()
15383                    .map(<DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
15384                encoder,
15385                offset + cur_offset,
15386                depth,
15387            )?;
15388
15389            _prev_end_offset = cur_offset + envelope_size;
15390            if 8 > max_ordinal {
15391                return Ok(());
15392            }
15393
15394            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15395            // are envelope_size bytes.
15396            let cur_offset: usize = (8 - 1) * envelope_size;
15397
15398            // Zero reserved fields.
15399            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15400
15401            // Safety:
15402            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15403            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15404            //   envelope_size bytes, there is always sufficient room.
15405            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
15406                self.availability
15407                    .as_ref()
15408                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
15409                encoder,
15410                offset + cur_offset,
15411                depth,
15412            )?;
15413
15414            _prev_end_offset = cur_offset + envelope_size;
15415            if 9 > max_ordinal {
15416                return Ok(());
15417            }
15418
15419            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15420            // are envelope_size bytes.
15421            let cur_offset: usize = (9 - 1) * envelope_size;
15422
15423            // Zero reserved fields.
15424            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15425
15426            // Safety:
15427            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15428            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15429            //   envelope_size bytes, there is always sufficient room.
15430            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
15431            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
15432            encoder, offset + cur_offset, depth
15433        )?;
15434
15435            _prev_end_offset = cur_offset + envelope_size;
15436
15437            Ok(())
15438        }
15439    }
15440
15441    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferDirectory {
15442        #[inline(always)]
15443        fn new_empty() -> Self {
15444            Self::default()
15445        }
15446
15447        unsafe fn decode(
15448            &mut self,
15449            decoder: &mut fidl::encoding::Decoder<'_, D>,
15450            offset: usize,
15451            mut depth: fidl::encoding::Depth,
15452        ) -> fidl::Result<()> {
15453            decoder.debug_check_bounds::<Self>(offset);
15454            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15455                None => return Err(fidl::Error::NotNullable),
15456                Some(len) => len,
15457            };
15458            // Calling decoder.out_of_line_offset(0) is not allowed.
15459            if len == 0 {
15460                return Ok(());
15461            };
15462            depth.increment()?;
15463            let envelope_size = 8;
15464            let bytes_len = len * envelope_size;
15465            let offset = decoder.out_of_line_offset(bytes_len)?;
15466            // Decode the envelope for each type.
15467            let mut _next_ordinal_to_read = 0;
15468            let mut next_offset = offset;
15469            let end_offset = offset + bytes_len;
15470            _next_ordinal_to_read += 1;
15471            if next_offset >= end_offset {
15472                return Ok(());
15473            }
15474
15475            // Decode unknown envelopes for gaps in ordinals.
15476            while _next_ordinal_to_read < 1 {
15477                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15478                _next_ordinal_to_read += 1;
15479                next_offset += envelope_size;
15480            }
15481
15482            let next_out_of_line = decoder.next_out_of_line();
15483            let handles_before = decoder.remaining_handles();
15484            if let Some((inlined, num_bytes, num_handles)) =
15485                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15486            {
15487                let member_inline_size =
15488                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15489                if inlined != (member_inline_size <= 4) {
15490                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15491                }
15492                let inner_offset;
15493                let mut inner_depth = depth.clone();
15494                if inlined {
15495                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15496                    inner_offset = next_offset;
15497                } else {
15498                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15499                    inner_depth.increment()?;
15500                }
15501                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
15502                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
15503                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15504                {
15505                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15506                }
15507                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15508                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15509                }
15510            }
15511
15512            next_offset += envelope_size;
15513            _next_ordinal_to_read += 1;
15514            if next_offset >= end_offset {
15515                return Ok(());
15516            }
15517
15518            // Decode unknown envelopes for gaps in ordinals.
15519            while _next_ordinal_to_read < 2 {
15520                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15521                _next_ordinal_to_read += 1;
15522                next_offset += envelope_size;
15523            }
15524
15525            let next_out_of_line = decoder.next_out_of_line();
15526            let handles_before = decoder.remaining_handles();
15527            if let Some((inlined, num_bytes, num_handles)) =
15528                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15529            {
15530                let member_inline_size =
15531                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
15532                        decoder.context,
15533                    );
15534                if inlined != (member_inline_size <= 4) {
15535                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15536                }
15537                let inner_offset;
15538                let mut inner_depth = depth.clone();
15539                if inlined {
15540                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15541                    inner_offset = next_offset;
15542                } else {
15543                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15544                    inner_depth.increment()?;
15545                }
15546                let val_ref = self
15547                    .source_name
15548                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
15549                fidl::decode!(
15550                    fidl::encoding::BoundedString<100>,
15551                    D,
15552                    val_ref,
15553                    decoder,
15554                    inner_offset,
15555                    inner_depth
15556                )?;
15557                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15558                {
15559                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15560                }
15561                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15562                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15563                }
15564            }
15565
15566            next_offset += envelope_size;
15567            _next_ordinal_to_read += 1;
15568            if next_offset >= end_offset {
15569                return Ok(());
15570            }
15571
15572            // Decode unknown envelopes for gaps in ordinals.
15573            while _next_ordinal_to_read < 3 {
15574                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15575                _next_ordinal_to_read += 1;
15576                next_offset += envelope_size;
15577            }
15578
15579            let next_out_of_line = decoder.next_out_of_line();
15580            let handles_before = decoder.remaining_handles();
15581            if let Some((inlined, num_bytes, num_handles)) =
15582                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15583            {
15584                let member_inline_size =
15585                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15586                if inlined != (member_inline_size <= 4) {
15587                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15588                }
15589                let inner_offset;
15590                let mut inner_depth = depth.clone();
15591                if inlined {
15592                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15593                    inner_offset = next_offset;
15594                } else {
15595                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15596                    inner_depth.increment()?;
15597                }
15598                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
15599                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
15600                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15601                {
15602                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15603                }
15604                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15605                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15606                }
15607            }
15608
15609            next_offset += envelope_size;
15610            _next_ordinal_to_read += 1;
15611            if next_offset >= end_offset {
15612                return Ok(());
15613            }
15614
15615            // Decode unknown envelopes for gaps in ordinals.
15616            while _next_ordinal_to_read < 4 {
15617                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15618                _next_ordinal_to_read += 1;
15619                next_offset += envelope_size;
15620            }
15621
15622            let next_out_of_line = decoder.next_out_of_line();
15623            let handles_before = decoder.remaining_handles();
15624            if let Some((inlined, num_bytes, num_handles)) =
15625                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15626            {
15627                let member_inline_size =
15628                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
15629                        decoder.context,
15630                    );
15631                if inlined != (member_inline_size <= 4) {
15632                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15633                }
15634                let inner_offset;
15635                let mut inner_depth = depth.clone();
15636                if inlined {
15637                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15638                    inner_offset = next_offset;
15639                } else {
15640                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15641                    inner_depth.increment()?;
15642                }
15643                let val_ref = self
15644                    .target_name
15645                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
15646                fidl::decode!(
15647                    fidl::encoding::BoundedString<100>,
15648                    D,
15649                    val_ref,
15650                    decoder,
15651                    inner_offset,
15652                    inner_depth
15653                )?;
15654                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15655                {
15656                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15657                }
15658                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15659                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15660                }
15661            }
15662
15663            next_offset += envelope_size;
15664            _next_ordinal_to_read += 1;
15665            if next_offset >= end_offset {
15666                return Ok(());
15667            }
15668
15669            // Decode unknown envelopes for gaps in ordinals.
15670            while _next_ordinal_to_read < 5 {
15671                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15672                _next_ordinal_to_read += 1;
15673                next_offset += envelope_size;
15674            }
15675
15676            let next_out_of_line = decoder.next_out_of_line();
15677            let handles_before = decoder.remaining_handles();
15678            if let Some((inlined, num_bytes, num_handles)) =
15679                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15680            {
15681                let member_inline_size = <fidl_fuchsia_io__common::Operations as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15682                if inlined != (member_inline_size <= 4) {
15683                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15684                }
15685                let inner_offset;
15686                let mut inner_depth = depth.clone();
15687                if inlined {
15688                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15689                    inner_offset = next_offset;
15690                } else {
15691                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15692                    inner_depth.increment()?;
15693                }
15694                let val_ref = self.rights.get_or_insert_with(|| {
15695                    fidl::new_empty!(fidl_fuchsia_io__common::Operations, D)
15696                });
15697                fidl::decode!(
15698                    fidl_fuchsia_io__common::Operations,
15699                    D,
15700                    val_ref,
15701                    decoder,
15702                    inner_offset,
15703                    inner_depth
15704                )?;
15705                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15706                {
15707                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15708                }
15709                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15710                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15711                }
15712            }
15713
15714            next_offset += envelope_size;
15715            _next_ordinal_to_read += 1;
15716            if next_offset >= end_offset {
15717                return Ok(());
15718            }
15719
15720            // Decode unknown envelopes for gaps in ordinals.
15721            while _next_ordinal_to_read < 6 {
15722                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15723                _next_ordinal_to_read += 1;
15724                next_offset += envelope_size;
15725            }
15726
15727            let next_out_of_line = decoder.next_out_of_line();
15728            let handles_before = decoder.remaining_handles();
15729            if let Some((inlined, num_bytes, num_handles)) =
15730                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15731            {
15732                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15733                if inlined != (member_inline_size <= 4) {
15734                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15735                }
15736                let inner_offset;
15737                let mut inner_depth = depth.clone();
15738                if inlined {
15739                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15740                    inner_offset = next_offset;
15741                } else {
15742                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15743                    inner_depth.increment()?;
15744                }
15745                let val_ref = self.subdir.get_or_insert_with(|| {
15746                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
15747                });
15748                fidl::decode!(
15749                    fidl::encoding::BoundedString<1024>,
15750                    D,
15751                    val_ref,
15752                    decoder,
15753                    inner_offset,
15754                    inner_depth
15755                )?;
15756                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15757                {
15758                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15759                }
15760                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15761                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15762                }
15763            }
15764
15765            next_offset += envelope_size;
15766            _next_ordinal_to_read += 1;
15767            if next_offset >= end_offset {
15768                return Ok(());
15769            }
15770
15771            // Decode unknown envelopes for gaps in ordinals.
15772            while _next_ordinal_to_read < 7 {
15773                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15774                _next_ordinal_to_read += 1;
15775                next_offset += envelope_size;
15776            }
15777
15778            let next_out_of_line = decoder.next_out_of_line();
15779            let handles_before = decoder.remaining_handles();
15780            if let Some((inlined, num_bytes, num_handles)) =
15781                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15782            {
15783                let member_inline_size =
15784                    <DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15785                if inlined != (member_inline_size <= 4) {
15786                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15787                }
15788                let inner_offset;
15789                let mut inner_depth = depth.clone();
15790                if inlined {
15791                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15792                    inner_offset = next_offset;
15793                } else {
15794                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15795                    inner_depth.increment()?;
15796                }
15797                let val_ref =
15798                    self.dependency_type.get_or_insert_with(|| fidl::new_empty!(DependencyType, D));
15799                fidl::decode!(DependencyType, D, val_ref, decoder, inner_offset, inner_depth)?;
15800                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15801                {
15802                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15803                }
15804                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15805                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15806                }
15807            }
15808
15809            next_offset += envelope_size;
15810            _next_ordinal_to_read += 1;
15811            if next_offset >= end_offset {
15812                return Ok(());
15813            }
15814
15815            // Decode unknown envelopes for gaps in ordinals.
15816            while _next_ordinal_to_read < 8 {
15817                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15818                _next_ordinal_to_read += 1;
15819                next_offset += envelope_size;
15820            }
15821
15822            let next_out_of_line = decoder.next_out_of_line();
15823            let handles_before = decoder.remaining_handles();
15824            if let Some((inlined, num_bytes, num_handles)) =
15825                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15826            {
15827                let member_inline_size =
15828                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15829                if inlined != (member_inline_size <= 4) {
15830                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15831                }
15832                let inner_offset;
15833                let mut inner_depth = depth.clone();
15834                if inlined {
15835                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15836                    inner_offset = next_offset;
15837                } else {
15838                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15839                    inner_depth.increment()?;
15840                }
15841                let val_ref =
15842                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
15843                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
15844                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15845                {
15846                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15847                }
15848                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15849                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15850                }
15851            }
15852
15853            next_offset += envelope_size;
15854            _next_ordinal_to_read += 1;
15855            if next_offset >= end_offset {
15856                return Ok(());
15857            }
15858
15859            // Decode unknown envelopes for gaps in ordinals.
15860            while _next_ordinal_to_read < 9 {
15861                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15862                _next_ordinal_to_read += 1;
15863                next_offset += envelope_size;
15864            }
15865
15866            let next_out_of_line = decoder.next_out_of_line();
15867            let handles_before = decoder.remaining_handles();
15868            if let Some((inlined, num_bytes, num_handles)) =
15869                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15870            {
15871                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15872                if inlined != (member_inline_size <= 4) {
15873                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15874                }
15875                let inner_offset;
15876                let mut inner_depth = depth.clone();
15877                if inlined {
15878                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15879                    inner_offset = next_offset;
15880                } else {
15881                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15882                    inner_depth.increment()?;
15883                }
15884                let val_ref = self.source_dictionary.get_or_insert_with(|| {
15885                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
15886                });
15887                fidl::decode!(
15888                    fidl::encoding::BoundedString<1024>,
15889                    D,
15890                    val_ref,
15891                    decoder,
15892                    inner_offset,
15893                    inner_depth
15894                )?;
15895                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15896                {
15897                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15898                }
15899                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15900                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15901                }
15902            }
15903
15904            next_offset += envelope_size;
15905
15906            // Decode the remaining unknown envelopes.
15907            while next_offset < end_offset {
15908                _next_ordinal_to_read += 1;
15909                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15910                next_offset += envelope_size;
15911            }
15912
15913            Ok(())
15914        }
15915    }
15916
15917    impl OfferEventStream {
15918        #[inline(always)]
15919        fn max_ordinal_present(&self) -> u64 {
15920            if let Some(_) = self.availability {
15921                return 7;
15922            }
15923            if let Some(_) = self.target_name {
15924                return 5;
15925            }
15926            if let Some(_) = self.target {
15927                return 4;
15928            }
15929            if let Some(_) = self.scope {
15930                return 3;
15931            }
15932            if let Some(_) = self.source_name {
15933                return 2;
15934            }
15935            if let Some(_) = self.source {
15936                return 1;
15937            }
15938            0
15939        }
15940    }
15941
15942    impl fidl::encoding::ValueTypeMarker for OfferEventStream {
15943        type Borrowed<'a> = &'a Self;
15944        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15945            value
15946        }
15947    }
15948
15949    unsafe impl fidl::encoding::TypeMarker for OfferEventStream {
15950        type Owned = Self;
15951
15952        #[inline(always)]
15953        fn inline_align(_context: fidl::encoding::Context) -> usize {
15954            8
15955        }
15956
15957        #[inline(always)]
15958        fn inline_size(_context: fidl::encoding::Context) -> usize {
15959            16
15960        }
15961    }
15962
15963    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferEventStream, D>
15964        for &OfferEventStream
15965    {
15966        unsafe fn encode(
15967            self,
15968            encoder: &mut fidl::encoding::Encoder<'_, D>,
15969            offset: usize,
15970            mut depth: fidl::encoding::Depth,
15971        ) -> fidl::Result<()> {
15972            encoder.debug_check_bounds::<OfferEventStream>(offset);
15973            // Vector header
15974            let max_ordinal: u64 = self.max_ordinal_present();
15975            encoder.write_num(max_ordinal, offset);
15976            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15977            // Calling encoder.out_of_line_offset(0) is not allowed.
15978            if max_ordinal == 0 {
15979                return Ok(());
15980            }
15981            depth.increment()?;
15982            let envelope_size = 8;
15983            let bytes_len = max_ordinal as usize * envelope_size;
15984            #[allow(unused_variables)]
15985            let offset = encoder.out_of_line_offset(bytes_len);
15986            let mut _prev_end_offset: usize = 0;
15987            if 1 > max_ordinal {
15988                return Ok(());
15989            }
15990
15991            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15992            // are envelope_size bytes.
15993            let cur_offset: usize = (1 - 1) * envelope_size;
15994
15995            // Zero reserved fields.
15996            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15997
15998            // Safety:
15999            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16000            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16001            //   envelope_size bytes, there is always sufficient room.
16002            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
16003                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
16004                encoder,
16005                offset + cur_offset,
16006                depth,
16007            )?;
16008
16009            _prev_end_offset = cur_offset + envelope_size;
16010            if 2 > max_ordinal {
16011                return Ok(());
16012            }
16013
16014            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16015            // are envelope_size bytes.
16016            let cur_offset: usize = (2 - 1) * envelope_size;
16017
16018            // Zero reserved fields.
16019            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16020
16021            // Safety:
16022            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16023            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16024            //   envelope_size bytes, there is always sufficient room.
16025            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
16026                self.source_name.as_ref().map(
16027                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
16028                ),
16029                encoder,
16030                offset + cur_offset,
16031                depth,
16032            )?;
16033
16034            _prev_end_offset = cur_offset + envelope_size;
16035            if 3 > max_ordinal {
16036                return Ok(());
16037            }
16038
16039            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16040            // are envelope_size bytes.
16041            let cur_offset: usize = (3 - 1) * envelope_size;
16042
16043            // Zero reserved fields.
16044            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16045
16046            // Safety:
16047            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16048            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16049            //   envelope_size bytes, there is always sufficient room.
16050            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Ref>, D>(
16051            self.scope.as_ref().map(<fidl::encoding::UnboundedVector<Ref> as fidl::encoding::ValueTypeMarker>::borrow),
16052            encoder, offset + cur_offset, depth
16053        )?;
16054
16055            _prev_end_offset = cur_offset + envelope_size;
16056            if 4 > max_ordinal {
16057                return Ok(());
16058            }
16059
16060            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16061            // are envelope_size bytes.
16062            let cur_offset: usize = (4 - 1) * envelope_size;
16063
16064            // Zero reserved fields.
16065            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16066
16067            // Safety:
16068            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16069            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16070            //   envelope_size bytes, there is always sufficient room.
16071            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
16072                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
16073                encoder,
16074                offset + cur_offset,
16075                depth,
16076            )?;
16077
16078            _prev_end_offset = cur_offset + envelope_size;
16079            if 5 > max_ordinal {
16080                return Ok(());
16081            }
16082
16083            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16084            // are envelope_size bytes.
16085            let cur_offset: usize = (5 - 1) * envelope_size;
16086
16087            // Zero reserved fields.
16088            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16089
16090            // Safety:
16091            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16092            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16093            //   envelope_size bytes, there is always sufficient room.
16094            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
16095                self.target_name.as_ref().map(
16096                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
16097                ),
16098                encoder,
16099                offset + cur_offset,
16100                depth,
16101            )?;
16102
16103            _prev_end_offset = cur_offset + envelope_size;
16104            if 7 > max_ordinal {
16105                return Ok(());
16106            }
16107
16108            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16109            // are envelope_size bytes.
16110            let cur_offset: usize = (7 - 1) * envelope_size;
16111
16112            // Zero reserved fields.
16113            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16114
16115            // Safety:
16116            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16117            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16118            //   envelope_size bytes, there is always sufficient room.
16119            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
16120                self.availability
16121                    .as_ref()
16122                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
16123                encoder,
16124                offset + cur_offset,
16125                depth,
16126            )?;
16127
16128            _prev_end_offset = cur_offset + envelope_size;
16129
16130            Ok(())
16131        }
16132    }
16133
16134    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferEventStream {
16135        #[inline(always)]
16136        fn new_empty() -> Self {
16137            Self::default()
16138        }
16139
16140        unsafe fn decode(
16141            &mut self,
16142            decoder: &mut fidl::encoding::Decoder<'_, D>,
16143            offset: usize,
16144            mut depth: fidl::encoding::Depth,
16145        ) -> fidl::Result<()> {
16146            decoder.debug_check_bounds::<Self>(offset);
16147            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
16148                None => return Err(fidl::Error::NotNullable),
16149                Some(len) => len,
16150            };
16151            // Calling decoder.out_of_line_offset(0) is not allowed.
16152            if len == 0 {
16153                return Ok(());
16154            };
16155            depth.increment()?;
16156            let envelope_size = 8;
16157            let bytes_len = len * envelope_size;
16158            let offset = decoder.out_of_line_offset(bytes_len)?;
16159            // Decode the envelope for each type.
16160            let mut _next_ordinal_to_read = 0;
16161            let mut next_offset = offset;
16162            let end_offset = offset + bytes_len;
16163            _next_ordinal_to_read += 1;
16164            if next_offset >= end_offset {
16165                return Ok(());
16166            }
16167
16168            // Decode unknown envelopes for gaps in ordinals.
16169            while _next_ordinal_to_read < 1 {
16170                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16171                _next_ordinal_to_read += 1;
16172                next_offset += envelope_size;
16173            }
16174
16175            let next_out_of_line = decoder.next_out_of_line();
16176            let handles_before = decoder.remaining_handles();
16177            if let Some((inlined, num_bytes, num_handles)) =
16178                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16179            {
16180                let member_inline_size =
16181                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16182                if inlined != (member_inline_size <= 4) {
16183                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16184                }
16185                let inner_offset;
16186                let mut inner_depth = depth.clone();
16187                if inlined {
16188                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16189                    inner_offset = next_offset;
16190                } else {
16191                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16192                    inner_depth.increment()?;
16193                }
16194                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
16195                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
16196                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16197                {
16198                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16199                }
16200                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16201                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16202                }
16203            }
16204
16205            next_offset += envelope_size;
16206            _next_ordinal_to_read += 1;
16207            if next_offset >= end_offset {
16208                return Ok(());
16209            }
16210
16211            // Decode unknown envelopes for gaps in ordinals.
16212            while _next_ordinal_to_read < 2 {
16213                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16214                _next_ordinal_to_read += 1;
16215                next_offset += envelope_size;
16216            }
16217
16218            let next_out_of_line = decoder.next_out_of_line();
16219            let handles_before = decoder.remaining_handles();
16220            if let Some((inlined, num_bytes, num_handles)) =
16221                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16222            {
16223                let member_inline_size =
16224                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
16225                        decoder.context,
16226                    );
16227                if inlined != (member_inline_size <= 4) {
16228                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16229                }
16230                let inner_offset;
16231                let mut inner_depth = depth.clone();
16232                if inlined {
16233                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16234                    inner_offset = next_offset;
16235                } else {
16236                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16237                    inner_depth.increment()?;
16238                }
16239                let val_ref = self
16240                    .source_name
16241                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
16242                fidl::decode!(
16243                    fidl::encoding::BoundedString<100>,
16244                    D,
16245                    val_ref,
16246                    decoder,
16247                    inner_offset,
16248                    inner_depth
16249                )?;
16250                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16251                {
16252                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16253                }
16254                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16255                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16256                }
16257            }
16258
16259            next_offset += envelope_size;
16260            _next_ordinal_to_read += 1;
16261            if next_offset >= end_offset {
16262                return Ok(());
16263            }
16264
16265            // Decode unknown envelopes for gaps in ordinals.
16266            while _next_ordinal_to_read < 3 {
16267                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16268                _next_ordinal_to_read += 1;
16269                next_offset += envelope_size;
16270            }
16271
16272            let next_out_of_line = decoder.next_out_of_line();
16273            let handles_before = decoder.remaining_handles();
16274            if let Some((inlined, num_bytes, num_handles)) =
16275                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16276            {
16277                let member_inline_size = <fidl::encoding::UnboundedVector<Ref> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16278                if inlined != (member_inline_size <= 4) {
16279                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16280                }
16281                let inner_offset;
16282                let mut inner_depth = depth.clone();
16283                if inlined {
16284                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16285                    inner_offset = next_offset;
16286                } else {
16287                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16288                    inner_depth.increment()?;
16289                }
16290                let val_ref = self.scope.get_or_insert_with(|| {
16291                    fidl::new_empty!(fidl::encoding::UnboundedVector<Ref>, D)
16292                });
16293                fidl::decode!(
16294                    fidl::encoding::UnboundedVector<Ref>,
16295                    D,
16296                    val_ref,
16297                    decoder,
16298                    inner_offset,
16299                    inner_depth
16300                )?;
16301                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16302                {
16303                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16304                }
16305                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16306                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16307                }
16308            }
16309
16310            next_offset += envelope_size;
16311            _next_ordinal_to_read += 1;
16312            if next_offset >= end_offset {
16313                return Ok(());
16314            }
16315
16316            // Decode unknown envelopes for gaps in ordinals.
16317            while _next_ordinal_to_read < 4 {
16318                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16319                _next_ordinal_to_read += 1;
16320                next_offset += envelope_size;
16321            }
16322
16323            let next_out_of_line = decoder.next_out_of_line();
16324            let handles_before = decoder.remaining_handles();
16325            if let Some((inlined, num_bytes, num_handles)) =
16326                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16327            {
16328                let member_inline_size =
16329                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16330                if inlined != (member_inline_size <= 4) {
16331                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16332                }
16333                let inner_offset;
16334                let mut inner_depth = depth.clone();
16335                if inlined {
16336                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16337                    inner_offset = next_offset;
16338                } else {
16339                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16340                    inner_depth.increment()?;
16341                }
16342                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
16343                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
16344                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16345                {
16346                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16347                }
16348                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16349                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16350                }
16351            }
16352
16353            next_offset += envelope_size;
16354            _next_ordinal_to_read += 1;
16355            if next_offset >= end_offset {
16356                return Ok(());
16357            }
16358
16359            // Decode unknown envelopes for gaps in ordinals.
16360            while _next_ordinal_to_read < 5 {
16361                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16362                _next_ordinal_to_read += 1;
16363                next_offset += envelope_size;
16364            }
16365
16366            let next_out_of_line = decoder.next_out_of_line();
16367            let handles_before = decoder.remaining_handles();
16368            if let Some((inlined, num_bytes, num_handles)) =
16369                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16370            {
16371                let member_inline_size =
16372                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
16373                        decoder.context,
16374                    );
16375                if inlined != (member_inline_size <= 4) {
16376                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16377                }
16378                let inner_offset;
16379                let mut inner_depth = depth.clone();
16380                if inlined {
16381                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16382                    inner_offset = next_offset;
16383                } else {
16384                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16385                    inner_depth.increment()?;
16386                }
16387                let val_ref = self
16388                    .target_name
16389                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
16390                fidl::decode!(
16391                    fidl::encoding::BoundedString<100>,
16392                    D,
16393                    val_ref,
16394                    decoder,
16395                    inner_offset,
16396                    inner_depth
16397                )?;
16398                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16399                {
16400                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16401                }
16402                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16403                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16404                }
16405            }
16406
16407            next_offset += envelope_size;
16408            _next_ordinal_to_read += 1;
16409            if next_offset >= end_offset {
16410                return Ok(());
16411            }
16412
16413            // Decode unknown envelopes for gaps in ordinals.
16414            while _next_ordinal_to_read < 7 {
16415                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16416                _next_ordinal_to_read += 1;
16417                next_offset += envelope_size;
16418            }
16419
16420            let next_out_of_line = decoder.next_out_of_line();
16421            let handles_before = decoder.remaining_handles();
16422            if let Some((inlined, num_bytes, num_handles)) =
16423                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16424            {
16425                let member_inline_size =
16426                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16427                if inlined != (member_inline_size <= 4) {
16428                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16429                }
16430                let inner_offset;
16431                let mut inner_depth = depth.clone();
16432                if inlined {
16433                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16434                    inner_offset = next_offset;
16435                } else {
16436                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16437                    inner_depth.increment()?;
16438                }
16439                let val_ref =
16440                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
16441                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
16442                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16443                {
16444                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16445                }
16446                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16447                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16448                }
16449            }
16450
16451            next_offset += envelope_size;
16452
16453            // Decode the remaining unknown envelopes.
16454            while next_offset < end_offset {
16455                _next_ordinal_to_read += 1;
16456                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16457                next_offset += envelope_size;
16458            }
16459
16460            Ok(())
16461        }
16462    }
16463
16464    impl OfferProtocol {
16465        #[inline(always)]
16466        fn max_ordinal_present(&self) -> u64 {
16467            if let Some(_) = self.source_dictionary {
16468                return 7;
16469            }
16470            if let Some(_) = self.availability {
16471                return 6;
16472            }
16473            if let Some(_) = self.dependency_type {
16474                return 5;
16475            }
16476            if let Some(_) = self.target_name {
16477                return 4;
16478            }
16479            if let Some(_) = self.target {
16480                return 3;
16481            }
16482            if let Some(_) = self.source_name {
16483                return 2;
16484            }
16485            if let Some(_) = self.source {
16486                return 1;
16487            }
16488            0
16489        }
16490    }
16491
16492    impl fidl::encoding::ValueTypeMarker for OfferProtocol {
16493        type Borrowed<'a> = &'a Self;
16494        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
16495            value
16496        }
16497    }
16498
16499    unsafe impl fidl::encoding::TypeMarker for OfferProtocol {
16500        type Owned = Self;
16501
16502        #[inline(always)]
16503        fn inline_align(_context: fidl::encoding::Context) -> usize {
16504            8
16505        }
16506
16507        #[inline(always)]
16508        fn inline_size(_context: fidl::encoding::Context) -> usize {
16509            16
16510        }
16511    }
16512
16513    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferProtocol, D>
16514        for &OfferProtocol
16515    {
16516        unsafe fn encode(
16517            self,
16518            encoder: &mut fidl::encoding::Encoder<'_, D>,
16519            offset: usize,
16520            mut depth: fidl::encoding::Depth,
16521        ) -> fidl::Result<()> {
16522            encoder.debug_check_bounds::<OfferProtocol>(offset);
16523            // Vector header
16524            let max_ordinal: u64 = self.max_ordinal_present();
16525            encoder.write_num(max_ordinal, offset);
16526            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
16527            // Calling encoder.out_of_line_offset(0) is not allowed.
16528            if max_ordinal == 0 {
16529                return Ok(());
16530            }
16531            depth.increment()?;
16532            let envelope_size = 8;
16533            let bytes_len = max_ordinal as usize * envelope_size;
16534            #[allow(unused_variables)]
16535            let offset = encoder.out_of_line_offset(bytes_len);
16536            let mut _prev_end_offset: usize = 0;
16537            if 1 > max_ordinal {
16538                return Ok(());
16539            }
16540
16541            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16542            // are envelope_size bytes.
16543            let cur_offset: usize = (1 - 1) * envelope_size;
16544
16545            // Zero reserved fields.
16546            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16547
16548            // Safety:
16549            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16550            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16551            //   envelope_size bytes, there is always sufficient room.
16552            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
16553                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
16554                encoder,
16555                offset + cur_offset,
16556                depth,
16557            )?;
16558
16559            _prev_end_offset = cur_offset + envelope_size;
16560            if 2 > max_ordinal {
16561                return Ok(());
16562            }
16563
16564            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16565            // are envelope_size bytes.
16566            let cur_offset: usize = (2 - 1) * envelope_size;
16567
16568            // Zero reserved fields.
16569            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16570
16571            // Safety:
16572            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16573            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16574            //   envelope_size bytes, there is always sufficient room.
16575            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
16576                self.source_name.as_ref().map(
16577                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
16578                ),
16579                encoder,
16580                offset + cur_offset,
16581                depth,
16582            )?;
16583
16584            _prev_end_offset = cur_offset + envelope_size;
16585            if 3 > max_ordinal {
16586                return Ok(());
16587            }
16588
16589            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16590            // are envelope_size bytes.
16591            let cur_offset: usize = (3 - 1) * envelope_size;
16592
16593            // Zero reserved fields.
16594            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16595
16596            // Safety:
16597            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16598            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16599            //   envelope_size bytes, there is always sufficient room.
16600            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
16601                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
16602                encoder,
16603                offset + cur_offset,
16604                depth,
16605            )?;
16606
16607            _prev_end_offset = cur_offset + envelope_size;
16608            if 4 > max_ordinal {
16609                return Ok(());
16610            }
16611
16612            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16613            // are envelope_size bytes.
16614            let cur_offset: usize = (4 - 1) * envelope_size;
16615
16616            // Zero reserved fields.
16617            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16618
16619            // Safety:
16620            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16621            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16622            //   envelope_size bytes, there is always sufficient room.
16623            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
16624                self.target_name.as_ref().map(
16625                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
16626                ),
16627                encoder,
16628                offset + cur_offset,
16629                depth,
16630            )?;
16631
16632            _prev_end_offset = cur_offset + envelope_size;
16633            if 5 > max_ordinal {
16634                return Ok(());
16635            }
16636
16637            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16638            // are envelope_size bytes.
16639            let cur_offset: usize = (5 - 1) * envelope_size;
16640
16641            // Zero reserved fields.
16642            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16643
16644            // Safety:
16645            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16646            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16647            //   envelope_size bytes, there is always sufficient room.
16648            fidl::encoding::encode_in_envelope_optional::<DependencyType, D>(
16649                self.dependency_type
16650                    .as_ref()
16651                    .map(<DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
16652                encoder,
16653                offset + cur_offset,
16654                depth,
16655            )?;
16656
16657            _prev_end_offset = cur_offset + envelope_size;
16658            if 6 > max_ordinal {
16659                return Ok(());
16660            }
16661
16662            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16663            // are envelope_size bytes.
16664            let cur_offset: usize = (6 - 1) * envelope_size;
16665
16666            // Zero reserved fields.
16667            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16668
16669            // Safety:
16670            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16671            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16672            //   envelope_size bytes, there is always sufficient room.
16673            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
16674                self.availability
16675                    .as_ref()
16676                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
16677                encoder,
16678                offset + cur_offset,
16679                depth,
16680            )?;
16681
16682            _prev_end_offset = cur_offset + envelope_size;
16683            if 7 > max_ordinal {
16684                return Ok(());
16685            }
16686
16687            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
16688            // are envelope_size bytes.
16689            let cur_offset: usize = (7 - 1) * envelope_size;
16690
16691            // Zero reserved fields.
16692            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
16693
16694            // Safety:
16695            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
16696            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
16697            //   envelope_size bytes, there is always sufficient room.
16698            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
16699            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
16700            encoder, offset + cur_offset, depth
16701        )?;
16702
16703            _prev_end_offset = cur_offset + envelope_size;
16704
16705            Ok(())
16706        }
16707    }
16708
16709    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferProtocol {
16710        #[inline(always)]
16711        fn new_empty() -> Self {
16712            Self::default()
16713        }
16714
16715        unsafe fn decode(
16716            &mut self,
16717            decoder: &mut fidl::encoding::Decoder<'_, D>,
16718            offset: usize,
16719            mut depth: fidl::encoding::Depth,
16720        ) -> fidl::Result<()> {
16721            decoder.debug_check_bounds::<Self>(offset);
16722            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
16723                None => return Err(fidl::Error::NotNullable),
16724                Some(len) => len,
16725            };
16726            // Calling decoder.out_of_line_offset(0) is not allowed.
16727            if len == 0 {
16728                return Ok(());
16729            };
16730            depth.increment()?;
16731            let envelope_size = 8;
16732            let bytes_len = len * envelope_size;
16733            let offset = decoder.out_of_line_offset(bytes_len)?;
16734            // Decode the envelope for each type.
16735            let mut _next_ordinal_to_read = 0;
16736            let mut next_offset = offset;
16737            let end_offset = offset + bytes_len;
16738            _next_ordinal_to_read += 1;
16739            if next_offset >= end_offset {
16740                return Ok(());
16741            }
16742
16743            // Decode unknown envelopes for gaps in ordinals.
16744            while _next_ordinal_to_read < 1 {
16745                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16746                _next_ordinal_to_read += 1;
16747                next_offset += envelope_size;
16748            }
16749
16750            let next_out_of_line = decoder.next_out_of_line();
16751            let handles_before = decoder.remaining_handles();
16752            if let Some((inlined, num_bytes, num_handles)) =
16753                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16754            {
16755                let member_inline_size =
16756                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16757                if inlined != (member_inline_size <= 4) {
16758                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16759                }
16760                let inner_offset;
16761                let mut inner_depth = depth.clone();
16762                if inlined {
16763                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16764                    inner_offset = next_offset;
16765                } else {
16766                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16767                    inner_depth.increment()?;
16768                }
16769                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
16770                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
16771                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16772                {
16773                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16774                }
16775                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16776                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16777                }
16778            }
16779
16780            next_offset += envelope_size;
16781            _next_ordinal_to_read += 1;
16782            if next_offset >= end_offset {
16783                return Ok(());
16784            }
16785
16786            // Decode unknown envelopes for gaps in ordinals.
16787            while _next_ordinal_to_read < 2 {
16788                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16789                _next_ordinal_to_read += 1;
16790                next_offset += envelope_size;
16791            }
16792
16793            let next_out_of_line = decoder.next_out_of_line();
16794            let handles_before = decoder.remaining_handles();
16795            if let Some((inlined, num_bytes, num_handles)) =
16796                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16797            {
16798                let member_inline_size =
16799                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
16800                        decoder.context,
16801                    );
16802                if inlined != (member_inline_size <= 4) {
16803                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16804                }
16805                let inner_offset;
16806                let mut inner_depth = depth.clone();
16807                if inlined {
16808                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16809                    inner_offset = next_offset;
16810                } else {
16811                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16812                    inner_depth.increment()?;
16813                }
16814                let val_ref = self
16815                    .source_name
16816                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
16817                fidl::decode!(
16818                    fidl::encoding::BoundedString<100>,
16819                    D,
16820                    val_ref,
16821                    decoder,
16822                    inner_offset,
16823                    inner_depth
16824                )?;
16825                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16826                {
16827                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16828                }
16829                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16830                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16831                }
16832            }
16833
16834            next_offset += envelope_size;
16835            _next_ordinal_to_read += 1;
16836            if next_offset >= end_offset {
16837                return Ok(());
16838            }
16839
16840            // Decode unknown envelopes for gaps in ordinals.
16841            while _next_ordinal_to_read < 3 {
16842                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16843                _next_ordinal_to_read += 1;
16844                next_offset += envelope_size;
16845            }
16846
16847            let next_out_of_line = decoder.next_out_of_line();
16848            let handles_before = decoder.remaining_handles();
16849            if let Some((inlined, num_bytes, num_handles)) =
16850                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16851            {
16852                let member_inline_size =
16853                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16854                if inlined != (member_inline_size <= 4) {
16855                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16856                }
16857                let inner_offset;
16858                let mut inner_depth = depth.clone();
16859                if inlined {
16860                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16861                    inner_offset = next_offset;
16862                } else {
16863                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16864                    inner_depth.increment()?;
16865                }
16866                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
16867                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
16868                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16869                {
16870                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16871                }
16872                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16873                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16874                }
16875            }
16876
16877            next_offset += envelope_size;
16878            _next_ordinal_to_read += 1;
16879            if next_offset >= end_offset {
16880                return Ok(());
16881            }
16882
16883            // Decode unknown envelopes for gaps in ordinals.
16884            while _next_ordinal_to_read < 4 {
16885                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16886                _next_ordinal_to_read += 1;
16887                next_offset += envelope_size;
16888            }
16889
16890            let next_out_of_line = decoder.next_out_of_line();
16891            let handles_before = decoder.remaining_handles();
16892            if let Some((inlined, num_bytes, num_handles)) =
16893                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16894            {
16895                let member_inline_size =
16896                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
16897                        decoder.context,
16898                    );
16899                if inlined != (member_inline_size <= 4) {
16900                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16901                }
16902                let inner_offset;
16903                let mut inner_depth = depth.clone();
16904                if inlined {
16905                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16906                    inner_offset = next_offset;
16907                } else {
16908                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16909                    inner_depth.increment()?;
16910                }
16911                let val_ref = self
16912                    .target_name
16913                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
16914                fidl::decode!(
16915                    fidl::encoding::BoundedString<100>,
16916                    D,
16917                    val_ref,
16918                    decoder,
16919                    inner_offset,
16920                    inner_depth
16921                )?;
16922                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16923                {
16924                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16925                }
16926                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16927                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16928                }
16929            }
16930
16931            next_offset += envelope_size;
16932            _next_ordinal_to_read += 1;
16933            if next_offset >= end_offset {
16934                return Ok(());
16935            }
16936
16937            // Decode unknown envelopes for gaps in ordinals.
16938            while _next_ordinal_to_read < 5 {
16939                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16940                _next_ordinal_to_read += 1;
16941                next_offset += envelope_size;
16942            }
16943
16944            let next_out_of_line = decoder.next_out_of_line();
16945            let handles_before = decoder.remaining_handles();
16946            if let Some((inlined, num_bytes, num_handles)) =
16947                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16948            {
16949                let member_inline_size =
16950                    <DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16951                if inlined != (member_inline_size <= 4) {
16952                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16953                }
16954                let inner_offset;
16955                let mut inner_depth = depth.clone();
16956                if inlined {
16957                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16958                    inner_offset = next_offset;
16959                } else {
16960                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16961                    inner_depth.increment()?;
16962                }
16963                let val_ref =
16964                    self.dependency_type.get_or_insert_with(|| fidl::new_empty!(DependencyType, D));
16965                fidl::decode!(DependencyType, D, val_ref, decoder, inner_offset, inner_depth)?;
16966                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16967                {
16968                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16969                }
16970                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16971                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16972                }
16973            }
16974
16975            next_offset += envelope_size;
16976            _next_ordinal_to_read += 1;
16977            if next_offset >= end_offset {
16978                return Ok(());
16979            }
16980
16981            // Decode unknown envelopes for gaps in ordinals.
16982            while _next_ordinal_to_read < 6 {
16983                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16984                _next_ordinal_to_read += 1;
16985                next_offset += envelope_size;
16986            }
16987
16988            let next_out_of_line = decoder.next_out_of_line();
16989            let handles_before = decoder.remaining_handles();
16990            if let Some((inlined, num_bytes, num_handles)) =
16991                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16992            {
16993                let member_inline_size =
16994                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16995                if inlined != (member_inline_size <= 4) {
16996                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16997                }
16998                let inner_offset;
16999                let mut inner_depth = depth.clone();
17000                if inlined {
17001                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17002                    inner_offset = next_offset;
17003                } else {
17004                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17005                    inner_depth.increment()?;
17006                }
17007                let val_ref =
17008                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
17009                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
17010                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17011                {
17012                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17013                }
17014                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17015                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17016                }
17017            }
17018
17019            next_offset += envelope_size;
17020            _next_ordinal_to_read += 1;
17021            if next_offset >= end_offset {
17022                return Ok(());
17023            }
17024
17025            // Decode unknown envelopes for gaps in ordinals.
17026            while _next_ordinal_to_read < 7 {
17027                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17028                _next_ordinal_to_read += 1;
17029                next_offset += envelope_size;
17030            }
17031
17032            let next_out_of_line = decoder.next_out_of_line();
17033            let handles_before = decoder.remaining_handles();
17034            if let Some((inlined, num_bytes, num_handles)) =
17035                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17036            {
17037                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17038                if inlined != (member_inline_size <= 4) {
17039                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17040                }
17041                let inner_offset;
17042                let mut inner_depth = depth.clone();
17043                if inlined {
17044                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17045                    inner_offset = next_offset;
17046                } else {
17047                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17048                    inner_depth.increment()?;
17049                }
17050                let val_ref = self.source_dictionary.get_or_insert_with(|| {
17051                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
17052                });
17053                fidl::decode!(
17054                    fidl::encoding::BoundedString<1024>,
17055                    D,
17056                    val_ref,
17057                    decoder,
17058                    inner_offset,
17059                    inner_depth
17060                )?;
17061                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17062                {
17063                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17064                }
17065                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17066                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17067                }
17068            }
17069
17070            next_offset += envelope_size;
17071
17072            // Decode the remaining unknown envelopes.
17073            while next_offset < end_offset {
17074                _next_ordinal_to_read += 1;
17075                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17076                next_offset += envelope_size;
17077            }
17078
17079            Ok(())
17080        }
17081    }
17082
17083    impl OfferResolver {
17084        #[inline(always)]
17085        fn max_ordinal_present(&self) -> u64 {
17086            if let Some(_) = self.source_dictionary {
17087                return 5;
17088            }
17089            if let Some(_) = self.target_name {
17090                return 4;
17091            }
17092            if let Some(_) = self.target {
17093                return 3;
17094            }
17095            if let Some(_) = self.source_name {
17096                return 2;
17097            }
17098            if let Some(_) = self.source {
17099                return 1;
17100            }
17101            0
17102        }
17103    }
17104
17105    impl fidl::encoding::ValueTypeMarker for OfferResolver {
17106        type Borrowed<'a> = &'a Self;
17107        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
17108            value
17109        }
17110    }
17111
17112    unsafe impl fidl::encoding::TypeMarker for OfferResolver {
17113        type Owned = Self;
17114
17115        #[inline(always)]
17116        fn inline_align(_context: fidl::encoding::Context) -> usize {
17117            8
17118        }
17119
17120        #[inline(always)]
17121        fn inline_size(_context: fidl::encoding::Context) -> usize {
17122            16
17123        }
17124    }
17125
17126    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferResolver, D>
17127        for &OfferResolver
17128    {
17129        unsafe fn encode(
17130            self,
17131            encoder: &mut fidl::encoding::Encoder<'_, D>,
17132            offset: usize,
17133            mut depth: fidl::encoding::Depth,
17134        ) -> fidl::Result<()> {
17135            encoder.debug_check_bounds::<OfferResolver>(offset);
17136            // Vector header
17137            let max_ordinal: u64 = self.max_ordinal_present();
17138            encoder.write_num(max_ordinal, offset);
17139            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
17140            // Calling encoder.out_of_line_offset(0) is not allowed.
17141            if max_ordinal == 0 {
17142                return Ok(());
17143            }
17144            depth.increment()?;
17145            let envelope_size = 8;
17146            let bytes_len = max_ordinal as usize * envelope_size;
17147            #[allow(unused_variables)]
17148            let offset = encoder.out_of_line_offset(bytes_len);
17149            let mut _prev_end_offset: usize = 0;
17150            if 1 > max_ordinal {
17151                return Ok(());
17152            }
17153
17154            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17155            // are envelope_size bytes.
17156            let cur_offset: usize = (1 - 1) * envelope_size;
17157
17158            // Zero reserved fields.
17159            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17160
17161            // Safety:
17162            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17163            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17164            //   envelope_size bytes, there is always sufficient room.
17165            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
17166                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
17167                encoder,
17168                offset + cur_offset,
17169                depth,
17170            )?;
17171
17172            _prev_end_offset = cur_offset + envelope_size;
17173            if 2 > max_ordinal {
17174                return Ok(());
17175            }
17176
17177            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17178            // are envelope_size bytes.
17179            let cur_offset: usize = (2 - 1) * envelope_size;
17180
17181            // Zero reserved fields.
17182            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17183
17184            // Safety:
17185            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17186            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17187            //   envelope_size bytes, there is always sufficient room.
17188            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
17189                self.source_name.as_ref().map(
17190                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
17191                ),
17192                encoder,
17193                offset + cur_offset,
17194                depth,
17195            )?;
17196
17197            _prev_end_offset = cur_offset + envelope_size;
17198            if 3 > max_ordinal {
17199                return Ok(());
17200            }
17201
17202            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17203            // are envelope_size bytes.
17204            let cur_offset: usize = (3 - 1) * envelope_size;
17205
17206            // Zero reserved fields.
17207            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17208
17209            // Safety:
17210            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17211            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17212            //   envelope_size bytes, there is always sufficient room.
17213            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
17214                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
17215                encoder,
17216                offset + cur_offset,
17217                depth,
17218            )?;
17219
17220            _prev_end_offset = cur_offset + envelope_size;
17221            if 4 > max_ordinal {
17222                return Ok(());
17223            }
17224
17225            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17226            // are envelope_size bytes.
17227            let cur_offset: usize = (4 - 1) * envelope_size;
17228
17229            // Zero reserved fields.
17230            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17231
17232            // Safety:
17233            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17234            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17235            //   envelope_size bytes, there is always sufficient room.
17236            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
17237                self.target_name.as_ref().map(
17238                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
17239                ),
17240                encoder,
17241                offset + cur_offset,
17242                depth,
17243            )?;
17244
17245            _prev_end_offset = cur_offset + envelope_size;
17246            if 5 > max_ordinal {
17247                return Ok(());
17248            }
17249
17250            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17251            // are envelope_size bytes.
17252            let cur_offset: usize = (5 - 1) * envelope_size;
17253
17254            // Zero reserved fields.
17255            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17256
17257            // Safety:
17258            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17259            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17260            //   envelope_size bytes, there is always sufficient room.
17261            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
17262            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
17263            encoder, offset + cur_offset, depth
17264        )?;
17265
17266            _prev_end_offset = cur_offset + envelope_size;
17267
17268            Ok(())
17269        }
17270    }
17271
17272    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferResolver {
17273        #[inline(always)]
17274        fn new_empty() -> Self {
17275            Self::default()
17276        }
17277
17278        unsafe fn decode(
17279            &mut self,
17280            decoder: &mut fidl::encoding::Decoder<'_, D>,
17281            offset: usize,
17282            mut depth: fidl::encoding::Depth,
17283        ) -> fidl::Result<()> {
17284            decoder.debug_check_bounds::<Self>(offset);
17285            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
17286                None => return Err(fidl::Error::NotNullable),
17287                Some(len) => len,
17288            };
17289            // Calling decoder.out_of_line_offset(0) is not allowed.
17290            if len == 0 {
17291                return Ok(());
17292            };
17293            depth.increment()?;
17294            let envelope_size = 8;
17295            let bytes_len = len * envelope_size;
17296            let offset = decoder.out_of_line_offset(bytes_len)?;
17297            // Decode the envelope for each type.
17298            let mut _next_ordinal_to_read = 0;
17299            let mut next_offset = offset;
17300            let end_offset = offset + bytes_len;
17301            _next_ordinal_to_read += 1;
17302            if next_offset >= end_offset {
17303                return Ok(());
17304            }
17305
17306            // Decode unknown envelopes for gaps in ordinals.
17307            while _next_ordinal_to_read < 1 {
17308                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17309                _next_ordinal_to_read += 1;
17310                next_offset += envelope_size;
17311            }
17312
17313            let next_out_of_line = decoder.next_out_of_line();
17314            let handles_before = decoder.remaining_handles();
17315            if let Some((inlined, num_bytes, num_handles)) =
17316                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17317            {
17318                let member_inline_size =
17319                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17320                if inlined != (member_inline_size <= 4) {
17321                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17322                }
17323                let inner_offset;
17324                let mut inner_depth = depth.clone();
17325                if inlined {
17326                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17327                    inner_offset = next_offset;
17328                } else {
17329                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17330                    inner_depth.increment()?;
17331                }
17332                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
17333                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
17334                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17335                {
17336                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17337                }
17338                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17339                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17340                }
17341            }
17342
17343            next_offset += envelope_size;
17344            _next_ordinal_to_read += 1;
17345            if next_offset >= end_offset {
17346                return Ok(());
17347            }
17348
17349            // Decode unknown envelopes for gaps in ordinals.
17350            while _next_ordinal_to_read < 2 {
17351                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17352                _next_ordinal_to_read += 1;
17353                next_offset += envelope_size;
17354            }
17355
17356            let next_out_of_line = decoder.next_out_of_line();
17357            let handles_before = decoder.remaining_handles();
17358            if let Some((inlined, num_bytes, num_handles)) =
17359                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17360            {
17361                let member_inline_size =
17362                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
17363                        decoder.context,
17364                    );
17365                if inlined != (member_inline_size <= 4) {
17366                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17367                }
17368                let inner_offset;
17369                let mut inner_depth = depth.clone();
17370                if inlined {
17371                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17372                    inner_offset = next_offset;
17373                } else {
17374                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17375                    inner_depth.increment()?;
17376                }
17377                let val_ref = self
17378                    .source_name
17379                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
17380                fidl::decode!(
17381                    fidl::encoding::BoundedString<100>,
17382                    D,
17383                    val_ref,
17384                    decoder,
17385                    inner_offset,
17386                    inner_depth
17387                )?;
17388                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17389                {
17390                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17391                }
17392                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17393                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17394                }
17395            }
17396
17397            next_offset += envelope_size;
17398            _next_ordinal_to_read += 1;
17399            if next_offset >= end_offset {
17400                return Ok(());
17401            }
17402
17403            // Decode unknown envelopes for gaps in ordinals.
17404            while _next_ordinal_to_read < 3 {
17405                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17406                _next_ordinal_to_read += 1;
17407                next_offset += envelope_size;
17408            }
17409
17410            let next_out_of_line = decoder.next_out_of_line();
17411            let handles_before = decoder.remaining_handles();
17412            if let Some((inlined, num_bytes, num_handles)) =
17413                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17414            {
17415                let member_inline_size =
17416                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17417                if inlined != (member_inline_size <= 4) {
17418                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17419                }
17420                let inner_offset;
17421                let mut inner_depth = depth.clone();
17422                if inlined {
17423                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17424                    inner_offset = next_offset;
17425                } else {
17426                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17427                    inner_depth.increment()?;
17428                }
17429                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
17430                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
17431                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17432                {
17433                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17434                }
17435                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17436                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17437                }
17438            }
17439
17440            next_offset += envelope_size;
17441            _next_ordinal_to_read += 1;
17442            if next_offset >= end_offset {
17443                return Ok(());
17444            }
17445
17446            // Decode unknown envelopes for gaps in ordinals.
17447            while _next_ordinal_to_read < 4 {
17448                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17449                _next_ordinal_to_read += 1;
17450                next_offset += envelope_size;
17451            }
17452
17453            let next_out_of_line = decoder.next_out_of_line();
17454            let handles_before = decoder.remaining_handles();
17455            if let Some((inlined, num_bytes, num_handles)) =
17456                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17457            {
17458                let member_inline_size =
17459                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
17460                        decoder.context,
17461                    );
17462                if inlined != (member_inline_size <= 4) {
17463                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17464                }
17465                let inner_offset;
17466                let mut inner_depth = depth.clone();
17467                if inlined {
17468                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17469                    inner_offset = next_offset;
17470                } else {
17471                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17472                    inner_depth.increment()?;
17473                }
17474                let val_ref = self
17475                    .target_name
17476                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
17477                fidl::decode!(
17478                    fidl::encoding::BoundedString<100>,
17479                    D,
17480                    val_ref,
17481                    decoder,
17482                    inner_offset,
17483                    inner_depth
17484                )?;
17485                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17486                {
17487                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17488                }
17489                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17490                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17491                }
17492            }
17493
17494            next_offset += envelope_size;
17495            _next_ordinal_to_read += 1;
17496            if next_offset >= end_offset {
17497                return Ok(());
17498            }
17499
17500            // Decode unknown envelopes for gaps in ordinals.
17501            while _next_ordinal_to_read < 5 {
17502                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17503                _next_ordinal_to_read += 1;
17504                next_offset += envelope_size;
17505            }
17506
17507            let next_out_of_line = decoder.next_out_of_line();
17508            let handles_before = decoder.remaining_handles();
17509            if let Some((inlined, num_bytes, num_handles)) =
17510                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17511            {
17512                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17513                if inlined != (member_inline_size <= 4) {
17514                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17515                }
17516                let inner_offset;
17517                let mut inner_depth = depth.clone();
17518                if inlined {
17519                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17520                    inner_offset = next_offset;
17521                } else {
17522                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17523                    inner_depth.increment()?;
17524                }
17525                let val_ref = self.source_dictionary.get_or_insert_with(|| {
17526                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
17527                });
17528                fidl::decode!(
17529                    fidl::encoding::BoundedString<1024>,
17530                    D,
17531                    val_ref,
17532                    decoder,
17533                    inner_offset,
17534                    inner_depth
17535                )?;
17536                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17537                {
17538                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17539                }
17540                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17541                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17542                }
17543            }
17544
17545            next_offset += envelope_size;
17546
17547            // Decode the remaining unknown envelopes.
17548            while next_offset < end_offset {
17549                _next_ordinal_to_read += 1;
17550                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17551                next_offset += envelope_size;
17552            }
17553
17554            Ok(())
17555        }
17556    }
17557
17558    impl OfferRunner {
17559        #[inline(always)]
17560        fn max_ordinal_present(&self) -> u64 {
17561            if let Some(_) = self.source_dictionary {
17562                return 5;
17563            }
17564            if let Some(_) = self.target_name {
17565                return 4;
17566            }
17567            if let Some(_) = self.target {
17568                return 3;
17569            }
17570            if let Some(_) = self.source_name {
17571                return 2;
17572            }
17573            if let Some(_) = self.source {
17574                return 1;
17575            }
17576            0
17577        }
17578    }
17579
17580    impl fidl::encoding::ValueTypeMarker for OfferRunner {
17581        type Borrowed<'a> = &'a Self;
17582        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
17583            value
17584        }
17585    }
17586
17587    unsafe impl fidl::encoding::TypeMarker for OfferRunner {
17588        type Owned = Self;
17589
17590        #[inline(always)]
17591        fn inline_align(_context: fidl::encoding::Context) -> usize {
17592            8
17593        }
17594
17595        #[inline(always)]
17596        fn inline_size(_context: fidl::encoding::Context) -> usize {
17597            16
17598        }
17599    }
17600
17601    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferRunner, D>
17602        for &OfferRunner
17603    {
17604        unsafe fn encode(
17605            self,
17606            encoder: &mut fidl::encoding::Encoder<'_, D>,
17607            offset: usize,
17608            mut depth: fidl::encoding::Depth,
17609        ) -> fidl::Result<()> {
17610            encoder.debug_check_bounds::<OfferRunner>(offset);
17611            // Vector header
17612            let max_ordinal: u64 = self.max_ordinal_present();
17613            encoder.write_num(max_ordinal, offset);
17614            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
17615            // Calling encoder.out_of_line_offset(0) is not allowed.
17616            if max_ordinal == 0 {
17617                return Ok(());
17618            }
17619            depth.increment()?;
17620            let envelope_size = 8;
17621            let bytes_len = max_ordinal as usize * envelope_size;
17622            #[allow(unused_variables)]
17623            let offset = encoder.out_of_line_offset(bytes_len);
17624            let mut _prev_end_offset: usize = 0;
17625            if 1 > max_ordinal {
17626                return Ok(());
17627            }
17628
17629            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17630            // are envelope_size bytes.
17631            let cur_offset: usize = (1 - 1) * envelope_size;
17632
17633            // Zero reserved fields.
17634            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17635
17636            // Safety:
17637            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17638            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17639            //   envelope_size bytes, there is always sufficient room.
17640            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
17641                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
17642                encoder,
17643                offset + cur_offset,
17644                depth,
17645            )?;
17646
17647            _prev_end_offset = cur_offset + envelope_size;
17648            if 2 > max_ordinal {
17649                return Ok(());
17650            }
17651
17652            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17653            // are envelope_size bytes.
17654            let cur_offset: usize = (2 - 1) * envelope_size;
17655
17656            // Zero reserved fields.
17657            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17658
17659            // Safety:
17660            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17661            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17662            //   envelope_size bytes, there is always sufficient room.
17663            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
17664                self.source_name.as_ref().map(
17665                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
17666                ),
17667                encoder,
17668                offset + cur_offset,
17669                depth,
17670            )?;
17671
17672            _prev_end_offset = cur_offset + envelope_size;
17673            if 3 > max_ordinal {
17674                return Ok(());
17675            }
17676
17677            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17678            // are envelope_size bytes.
17679            let cur_offset: usize = (3 - 1) * envelope_size;
17680
17681            // Zero reserved fields.
17682            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17683
17684            // Safety:
17685            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17686            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17687            //   envelope_size bytes, there is always sufficient room.
17688            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
17689                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
17690                encoder,
17691                offset + cur_offset,
17692                depth,
17693            )?;
17694
17695            _prev_end_offset = cur_offset + envelope_size;
17696            if 4 > max_ordinal {
17697                return Ok(());
17698            }
17699
17700            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17701            // are envelope_size bytes.
17702            let cur_offset: usize = (4 - 1) * envelope_size;
17703
17704            // Zero reserved fields.
17705            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17706
17707            // Safety:
17708            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17709            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17710            //   envelope_size bytes, there is always sufficient room.
17711            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
17712                self.target_name.as_ref().map(
17713                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
17714                ),
17715                encoder,
17716                offset + cur_offset,
17717                depth,
17718            )?;
17719
17720            _prev_end_offset = cur_offset + envelope_size;
17721            if 5 > max_ordinal {
17722                return Ok(());
17723            }
17724
17725            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
17726            // are envelope_size bytes.
17727            let cur_offset: usize = (5 - 1) * envelope_size;
17728
17729            // Zero reserved fields.
17730            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
17731
17732            // Safety:
17733            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
17734            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
17735            //   envelope_size bytes, there is always sufficient room.
17736            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
17737            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
17738            encoder, offset + cur_offset, depth
17739        )?;
17740
17741            _prev_end_offset = cur_offset + envelope_size;
17742
17743            Ok(())
17744        }
17745    }
17746
17747    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferRunner {
17748        #[inline(always)]
17749        fn new_empty() -> Self {
17750            Self::default()
17751        }
17752
17753        unsafe fn decode(
17754            &mut self,
17755            decoder: &mut fidl::encoding::Decoder<'_, D>,
17756            offset: usize,
17757            mut depth: fidl::encoding::Depth,
17758        ) -> fidl::Result<()> {
17759            decoder.debug_check_bounds::<Self>(offset);
17760            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
17761                None => return Err(fidl::Error::NotNullable),
17762                Some(len) => len,
17763            };
17764            // Calling decoder.out_of_line_offset(0) is not allowed.
17765            if len == 0 {
17766                return Ok(());
17767            };
17768            depth.increment()?;
17769            let envelope_size = 8;
17770            let bytes_len = len * envelope_size;
17771            let offset = decoder.out_of_line_offset(bytes_len)?;
17772            // Decode the envelope for each type.
17773            let mut _next_ordinal_to_read = 0;
17774            let mut next_offset = offset;
17775            let end_offset = offset + bytes_len;
17776            _next_ordinal_to_read += 1;
17777            if next_offset >= end_offset {
17778                return Ok(());
17779            }
17780
17781            // Decode unknown envelopes for gaps in ordinals.
17782            while _next_ordinal_to_read < 1 {
17783                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17784                _next_ordinal_to_read += 1;
17785                next_offset += envelope_size;
17786            }
17787
17788            let next_out_of_line = decoder.next_out_of_line();
17789            let handles_before = decoder.remaining_handles();
17790            if let Some((inlined, num_bytes, num_handles)) =
17791                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17792            {
17793                let member_inline_size =
17794                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17795                if inlined != (member_inline_size <= 4) {
17796                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17797                }
17798                let inner_offset;
17799                let mut inner_depth = depth.clone();
17800                if inlined {
17801                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17802                    inner_offset = next_offset;
17803                } else {
17804                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17805                    inner_depth.increment()?;
17806                }
17807                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
17808                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
17809                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17810                {
17811                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17812                }
17813                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17814                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17815                }
17816            }
17817
17818            next_offset += envelope_size;
17819            _next_ordinal_to_read += 1;
17820            if next_offset >= end_offset {
17821                return Ok(());
17822            }
17823
17824            // Decode unknown envelopes for gaps in ordinals.
17825            while _next_ordinal_to_read < 2 {
17826                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17827                _next_ordinal_to_read += 1;
17828                next_offset += envelope_size;
17829            }
17830
17831            let next_out_of_line = decoder.next_out_of_line();
17832            let handles_before = decoder.remaining_handles();
17833            if let Some((inlined, num_bytes, num_handles)) =
17834                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17835            {
17836                let member_inline_size =
17837                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
17838                        decoder.context,
17839                    );
17840                if inlined != (member_inline_size <= 4) {
17841                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17842                }
17843                let inner_offset;
17844                let mut inner_depth = depth.clone();
17845                if inlined {
17846                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17847                    inner_offset = next_offset;
17848                } else {
17849                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17850                    inner_depth.increment()?;
17851                }
17852                let val_ref = self
17853                    .source_name
17854                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
17855                fidl::decode!(
17856                    fidl::encoding::BoundedString<100>,
17857                    D,
17858                    val_ref,
17859                    decoder,
17860                    inner_offset,
17861                    inner_depth
17862                )?;
17863                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17864                {
17865                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17866                }
17867                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17868                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17869                }
17870            }
17871
17872            next_offset += envelope_size;
17873            _next_ordinal_to_read += 1;
17874            if next_offset >= end_offset {
17875                return Ok(());
17876            }
17877
17878            // Decode unknown envelopes for gaps in ordinals.
17879            while _next_ordinal_to_read < 3 {
17880                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17881                _next_ordinal_to_read += 1;
17882                next_offset += envelope_size;
17883            }
17884
17885            let next_out_of_line = decoder.next_out_of_line();
17886            let handles_before = decoder.remaining_handles();
17887            if let Some((inlined, num_bytes, num_handles)) =
17888                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17889            {
17890                let member_inline_size =
17891                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17892                if inlined != (member_inline_size <= 4) {
17893                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17894                }
17895                let inner_offset;
17896                let mut inner_depth = depth.clone();
17897                if inlined {
17898                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17899                    inner_offset = next_offset;
17900                } else {
17901                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17902                    inner_depth.increment()?;
17903                }
17904                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
17905                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
17906                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17907                {
17908                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17909                }
17910                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17911                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17912                }
17913            }
17914
17915            next_offset += envelope_size;
17916            _next_ordinal_to_read += 1;
17917            if next_offset >= end_offset {
17918                return Ok(());
17919            }
17920
17921            // Decode unknown envelopes for gaps in ordinals.
17922            while _next_ordinal_to_read < 4 {
17923                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17924                _next_ordinal_to_read += 1;
17925                next_offset += envelope_size;
17926            }
17927
17928            let next_out_of_line = decoder.next_out_of_line();
17929            let handles_before = decoder.remaining_handles();
17930            if let Some((inlined, num_bytes, num_handles)) =
17931                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17932            {
17933                let member_inline_size =
17934                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
17935                        decoder.context,
17936                    );
17937                if inlined != (member_inline_size <= 4) {
17938                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17939                }
17940                let inner_offset;
17941                let mut inner_depth = depth.clone();
17942                if inlined {
17943                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17944                    inner_offset = next_offset;
17945                } else {
17946                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17947                    inner_depth.increment()?;
17948                }
17949                let val_ref = self
17950                    .target_name
17951                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
17952                fidl::decode!(
17953                    fidl::encoding::BoundedString<100>,
17954                    D,
17955                    val_ref,
17956                    decoder,
17957                    inner_offset,
17958                    inner_depth
17959                )?;
17960                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
17961                {
17962                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
17963                }
17964                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
17965                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
17966                }
17967            }
17968
17969            next_offset += envelope_size;
17970            _next_ordinal_to_read += 1;
17971            if next_offset >= end_offset {
17972                return Ok(());
17973            }
17974
17975            // Decode unknown envelopes for gaps in ordinals.
17976            while _next_ordinal_to_read < 5 {
17977                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
17978                _next_ordinal_to_read += 1;
17979                next_offset += envelope_size;
17980            }
17981
17982            let next_out_of_line = decoder.next_out_of_line();
17983            let handles_before = decoder.remaining_handles();
17984            if let Some((inlined, num_bytes, num_handles)) =
17985                fidl::encoding::decode_envelope_header(decoder, next_offset)?
17986            {
17987                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
17988                if inlined != (member_inline_size <= 4) {
17989                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
17990                }
17991                let inner_offset;
17992                let mut inner_depth = depth.clone();
17993                if inlined {
17994                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
17995                    inner_offset = next_offset;
17996                } else {
17997                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
17998                    inner_depth.increment()?;
17999                }
18000                let val_ref = self.source_dictionary.get_or_insert_with(|| {
18001                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
18002                });
18003                fidl::decode!(
18004                    fidl::encoding::BoundedString<1024>,
18005                    D,
18006                    val_ref,
18007                    decoder,
18008                    inner_offset,
18009                    inner_depth
18010                )?;
18011                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18012                {
18013                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18014                }
18015                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18016                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18017                }
18018            }
18019
18020            next_offset += envelope_size;
18021
18022            // Decode the remaining unknown envelopes.
18023            while next_offset < end_offset {
18024                _next_ordinal_to_read += 1;
18025                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18026                next_offset += envelope_size;
18027            }
18028
18029            Ok(())
18030        }
18031    }
18032
18033    impl OfferService {
18034        #[inline(always)]
18035        fn max_ordinal_present(&self) -> u64 {
18036            if let Some(_) = self.dependency_type {
18037                return 9;
18038            }
18039            if let Some(_) = self.source_dictionary {
18040                return 8;
18041            }
18042            if let Some(_) = self.availability {
18043                return 7;
18044            }
18045            if let Some(_) = self.renamed_instances {
18046                return 6;
18047            }
18048            if let Some(_) = self.source_instance_filter {
18049                return 5;
18050            }
18051            if let Some(_) = self.target_name {
18052                return 4;
18053            }
18054            if let Some(_) = self.target {
18055                return 3;
18056            }
18057            if let Some(_) = self.source_name {
18058                return 2;
18059            }
18060            if let Some(_) = self.source {
18061                return 1;
18062            }
18063            0
18064        }
18065    }
18066
18067    impl fidl::encoding::ValueTypeMarker for OfferService {
18068        type Borrowed<'a> = &'a Self;
18069        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18070            value
18071        }
18072    }
18073
18074    unsafe impl fidl::encoding::TypeMarker for OfferService {
18075        type Owned = Self;
18076
18077        #[inline(always)]
18078        fn inline_align(_context: fidl::encoding::Context) -> usize {
18079            8
18080        }
18081
18082        #[inline(always)]
18083        fn inline_size(_context: fidl::encoding::Context) -> usize {
18084            16
18085        }
18086    }
18087
18088    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferService, D>
18089        for &OfferService
18090    {
18091        unsafe fn encode(
18092            self,
18093            encoder: &mut fidl::encoding::Encoder<'_, D>,
18094            offset: usize,
18095            mut depth: fidl::encoding::Depth,
18096        ) -> fidl::Result<()> {
18097            encoder.debug_check_bounds::<OfferService>(offset);
18098            // Vector header
18099            let max_ordinal: u64 = self.max_ordinal_present();
18100            encoder.write_num(max_ordinal, offset);
18101            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18102            // Calling encoder.out_of_line_offset(0) is not allowed.
18103            if max_ordinal == 0 {
18104                return Ok(());
18105            }
18106            depth.increment()?;
18107            let envelope_size = 8;
18108            let bytes_len = max_ordinal as usize * envelope_size;
18109            #[allow(unused_variables)]
18110            let offset = encoder.out_of_line_offset(bytes_len);
18111            let mut _prev_end_offset: usize = 0;
18112            if 1 > max_ordinal {
18113                return Ok(());
18114            }
18115
18116            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18117            // are envelope_size bytes.
18118            let cur_offset: usize = (1 - 1) * envelope_size;
18119
18120            // Zero reserved fields.
18121            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18122
18123            // Safety:
18124            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18125            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18126            //   envelope_size bytes, there is always sufficient room.
18127            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
18128                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
18129                encoder,
18130                offset + cur_offset,
18131                depth,
18132            )?;
18133
18134            _prev_end_offset = cur_offset + envelope_size;
18135            if 2 > max_ordinal {
18136                return Ok(());
18137            }
18138
18139            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18140            // are envelope_size bytes.
18141            let cur_offset: usize = (2 - 1) * envelope_size;
18142
18143            // Zero reserved fields.
18144            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18145
18146            // Safety:
18147            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18148            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18149            //   envelope_size bytes, there is always sufficient room.
18150            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
18151                self.source_name.as_ref().map(
18152                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
18153                ),
18154                encoder,
18155                offset + cur_offset,
18156                depth,
18157            )?;
18158
18159            _prev_end_offset = cur_offset + envelope_size;
18160            if 3 > max_ordinal {
18161                return Ok(());
18162            }
18163
18164            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18165            // are envelope_size bytes.
18166            let cur_offset: usize = (3 - 1) * envelope_size;
18167
18168            // Zero reserved fields.
18169            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18170
18171            // Safety:
18172            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18173            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18174            //   envelope_size bytes, there is always sufficient room.
18175            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
18176                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
18177                encoder,
18178                offset + cur_offset,
18179                depth,
18180            )?;
18181
18182            _prev_end_offset = cur_offset + envelope_size;
18183            if 4 > max_ordinal {
18184                return Ok(());
18185            }
18186
18187            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18188            // are envelope_size bytes.
18189            let cur_offset: usize = (4 - 1) * envelope_size;
18190
18191            // Zero reserved fields.
18192            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18193
18194            // Safety:
18195            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18196            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18197            //   envelope_size bytes, there is always sufficient room.
18198            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
18199                self.target_name.as_ref().map(
18200                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
18201                ),
18202                encoder,
18203                offset + cur_offset,
18204                depth,
18205            )?;
18206
18207            _prev_end_offset = cur_offset + envelope_size;
18208            if 5 > max_ordinal {
18209                return Ok(());
18210            }
18211
18212            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18213            // are envelope_size bytes.
18214            let cur_offset: usize = (5 - 1) * envelope_size;
18215
18216            // Zero reserved fields.
18217            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18218
18219            // Safety:
18220            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18221            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18222            //   envelope_size bytes, there is always sufficient room.
18223            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<100>>, D>(
18224            self.source_instance_filter.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<100>> as fidl::encoding::ValueTypeMarker>::borrow),
18225            encoder, offset + cur_offset, depth
18226        )?;
18227
18228            _prev_end_offset = cur_offset + envelope_size;
18229            if 6 > max_ordinal {
18230                return Ok(());
18231            }
18232
18233            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18234            // are envelope_size bytes.
18235            let cur_offset: usize = (6 - 1) * envelope_size;
18236
18237            // Zero reserved fields.
18238            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18239
18240            // Safety:
18241            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18242            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18243            //   envelope_size bytes, there is always sufficient room.
18244            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<NameMapping>, D>(
18245            self.renamed_instances.as_ref().map(<fidl::encoding::UnboundedVector<NameMapping> as fidl::encoding::ValueTypeMarker>::borrow),
18246            encoder, offset + cur_offset, depth
18247        )?;
18248
18249            _prev_end_offset = cur_offset + envelope_size;
18250            if 7 > max_ordinal {
18251                return Ok(());
18252            }
18253
18254            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18255            // are envelope_size bytes.
18256            let cur_offset: usize = (7 - 1) * envelope_size;
18257
18258            // Zero reserved fields.
18259            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18260
18261            // Safety:
18262            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18263            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18264            //   envelope_size bytes, there is always sufficient room.
18265            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
18266                self.availability
18267                    .as_ref()
18268                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
18269                encoder,
18270                offset + cur_offset,
18271                depth,
18272            )?;
18273
18274            _prev_end_offset = cur_offset + envelope_size;
18275            if 8 > max_ordinal {
18276                return Ok(());
18277            }
18278
18279            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18280            // are envelope_size bytes.
18281            let cur_offset: usize = (8 - 1) * envelope_size;
18282
18283            // Zero reserved fields.
18284            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18285
18286            // Safety:
18287            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18288            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18289            //   envelope_size bytes, there is always sufficient room.
18290            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
18291            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
18292            encoder, offset + cur_offset, depth
18293        )?;
18294
18295            _prev_end_offset = cur_offset + envelope_size;
18296            if 9 > max_ordinal {
18297                return Ok(());
18298            }
18299
18300            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18301            // are envelope_size bytes.
18302            let cur_offset: usize = (9 - 1) * envelope_size;
18303
18304            // Zero reserved fields.
18305            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18306
18307            // Safety:
18308            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18309            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18310            //   envelope_size bytes, there is always sufficient room.
18311            fidl::encoding::encode_in_envelope_optional::<DependencyType, D>(
18312                self.dependency_type
18313                    .as_ref()
18314                    .map(<DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
18315                encoder,
18316                offset + cur_offset,
18317                depth,
18318            )?;
18319
18320            _prev_end_offset = cur_offset + envelope_size;
18321
18322            Ok(())
18323        }
18324    }
18325
18326    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferService {
18327        #[inline(always)]
18328        fn new_empty() -> Self {
18329            Self::default()
18330        }
18331
18332        unsafe fn decode(
18333            &mut self,
18334            decoder: &mut fidl::encoding::Decoder<'_, D>,
18335            offset: usize,
18336            mut depth: fidl::encoding::Depth,
18337        ) -> fidl::Result<()> {
18338            decoder.debug_check_bounds::<Self>(offset);
18339            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
18340                None => return Err(fidl::Error::NotNullable),
18341                Some(len) => len,
18342            };
18343            // Calling decoder.out_of_line_offset(0) is not allowed.
18344            if len == 0 {
18345                return Ok(());
18346            };
18347            depth.increment()?;
18348            let envelope_size = 8;
18349            let bytes_len = len * envelope_size;
18350            let offset = decoder.out_of_line_offset(bytes_len)?;
18351            // Decode the envelope for each type.
18352            let mut _next_ordinal_to_read = 0;
18353            let mut next_offset = offset;
18354            let end_offset = offset + bytes_len;
18355            _next_ordinal_to_read += 1;
18356            if next_offset >= end_offset {
18357                return Ok(());
18358            }
18359
18360            // Decode unknown envelopes for gaps in ordinals.
18361            while _next_ordinal_to_read < 1 {
18362                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18363                _next_ordinal_to_read += 1;
18364                next_offset += envelope_size;
18365            }
18366
18367            let next_out_of_line = decoder.next_out_of_line();
18368            let handles_before = decoder.remaining_handles();
18369            if let Some((inlined, num_bytes, num_handles)) =
18370                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18371            {
18372                let member_inline_size =
18373                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18374                if inlined != (member_inline_size <= 4) {
18375                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18376                }
18377                let inner_offset;
18378                let mut inner_depth = depth.clone();
18379                if inlined {
18380                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18381                    inner_offset = next_offset;
18382                } else {
18383                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18384                    inner_depth.increment()?;
18385                }
18386                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
18387                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
18388                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18389                {
18390                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18391                }
18392                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18393                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18394                }
18395            }
18396
18397            next_offset += envelope_size;
18398            _next_ordinal_to_read += 1;
18399            if next_offset >= end_offset {
18400                return Ok(());
18401            }
18402
18403            // Decode unknown envelopes for gaps in ordinals.
18404            while _next_ordinal_to_read < 2 {
18405                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18406                _next_ordinal_to_read += 1;
18407                next_offset += envelope_size;
18408            }
18409
18410            let next_out_of_line = decoder.next_out_of_line();
18411            let handles_before = decoder.remaining_handles();
18412            if let Some((inlined, num_bytes, num_handles)) =
18413                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18414            {
18415                let member_inline_size =
18416                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
18417                        decoder.context,
18418                    );
18419                if inlined != (member_inline_size <= 4) {
18420                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18421                }
18422                let inner_offset;
18423                let mut inner_depth = depth.clone();
18424                if inlined {
18425                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18426                    inner_offset = next_offset;
18427                } else {
18428                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18429                    inner_depth.increment()?;
18430                }
18431                let val_ref = self
18432                    .source_name
18433                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
18434                fidl::decode!(
18435                    fidl::encoding::BoundedString<100>,
18436                    D,
18437                    val_ref,
18438                    decoder,
18439                    inner_offset,
18440                    inner_depth
18441                )?;
18442                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18443                {
18444                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18445                }
18446                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18447                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18448                }
18449            }
18450
18451            next_offset += envelope_size;
18452            _next_ordinal_to_read += 1;
18453            if next_offset >= end_offset {
18454                return Ok(());
18455            }
18456
18457            // Decode unknown envelopes for gaps in ordinals.
18458            while _next_ordinal_to_read < 3 {
18459                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18460                _next_ordinal_to_read += 1;
18461                next_offset += envelope_size;
18462            }
18463
18464            let next_out_of_line = decoder.next_out_of_line();
18465            let handles_before = decoder.remaining_handles();
18466            if let Some((inlined, num_bytes, num_handles)) =
18467                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18468            {
18469                let member_inline_size =
18470                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18471                if inlined != (member_inline_size <= 4) {
18472                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18473                }
18474                let inner_offset;
18475                let mut inner_depth = depth.clone();
18476                if inlined {
18477                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18478                    inner_offset = next_offset;
18479                } else {
18480                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18481                    inner_depth.increment()?;
18482                }
18483                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
18484                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
18485                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18486                {
18487                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18488                }
18489                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18490                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18491                }
18492            }
18493
18494            next_offset += envelope_size;
18495            _next_ordinal_to_read += 1;
18496            if next_offset >= end_offset {
18497                return Ok(());
18498            }
18499
18500            // Decode unknown envelopes for gaps in ordinals.
18501            while _next_ordinal_to_read < 4 {
18502                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18503                _next_ordinal_to_read += 1;
18504                next_offset += envelope_size;
18505            }
18506
18507            let next_out_of_line = decoder.next_out_of_line();
18508            let handles_before = decoder.remaining_handles();
18509            if let Some((inlined, num_bytes, num_handles)) =
18510                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18511            {
18512                let member_inline_size =
18513                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
18514                        decoder.context,
18515                    );
18516                if inlined != (member_inline_size <= 4) {
18517                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18518                }
18519                let inner_offset;
18520                let mut inner_depth = depth.clone();
18521                if inlined {
18522                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18523                    inner_offset = next_offset;
18524                } else {
18525                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18526                    inner_depth.increment()?;
18527                }
18528                let val_ref = self
18529                    .target_name
18530                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
18531                fidl::decode!(
18532                    fidl::encoding::BoundedString<100>,
18533                    D,
18534                    val_ref,
18535                    decoder,
18536                    inner_offset,
18537                    inner_depth
18538                )?;
18539                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18540                {
18541                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18542                }
18543                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18544                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18545                }
18546            }
18547
18548            next_offset += envelope_size;
18549            _next_ordinal_to_read += 1;
18550            if next_offset >= end_offset {
18551                return Ok(());
18552            }
18553
18554            // Decode unknown envelopes for gaps in ordinals.
18555            while _next_ordinal_to_read < 5 {
18556                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18557                _next_ordinal_to_read += 1;
18558                next_offset += envelope_size;
18559            }
18560
18561            let next_out_of_line = decoder.next_out_of_line();
18562            let handles_before = decoder.remaining_handles();
18563            if let Some((inlined, num_bytes, num_handles)) =
18564                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18565            {
18566                let member_inline_size = <fidl::encoding::UnboundedVector<
18567                    fidl::encoding::BoundedString<100>,
18568                > as fidl::encoding::TypeMarker>::inline_size(
18569                    decoder.context
18570                );
18571                if inlined != (member_inline_size <= 4) {
18572                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18573                }
18574                let inner_offset;
18575                let mut inner_depth = depth.clone();
18576                if inlined {
18577                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18578                    inner_offset = next_offset;
18579                } else {
18580                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18581                    inner_depth.increment()?;
18582                }
18583                let val_ref = self.source_instance_filter.get_or_insert_with(|| {
18584                    fidl::new_empty!(
18585                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<100>>,
18586                        D
18587                    )
18588                });
18589                fidl::decode!(
18590                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<100>>,
18591                    D,
18592                    val_ref,
18593                    decoder,
18594                    inner_offset,
18595                    inner_depth
18596                )?;
18597                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18598                {
18599                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18600                }
18601                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18602                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18603                }
18604            }
18605
18606            next_offset += envelope_size;
18607            _next_ordinal_to_read += 1;
18608            if next_offset >= end_offset {
18609                return Ok(());
18610            }
18611
18612            // Decode unknown envelopes for gaps in ordinals.
18613            while _next_ordinal_to_read < 6 {
18614                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18615                _next_ordinal_to_read += 1;
18616                next_offset += envelope_size;
18617            }
18618
18619            let next_out_of_line = decoder.next_out_of_line();
18620            let handles_before = decoder.remaining_handles();
18621            if let Some((inlined, num_bytes, num_handles)) =
18622                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18623            {
18624                let member_inline_size = <fidl::encoding::UnboundedVector<NameMapping> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18625                if inlined != (member_inline_size <= 4) {
18626                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18627                }
18628                let inner_offset;
18629                let mut inner_depth = depth.clone();
18630                if inlined {
18631                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18632                    inner_offset = next_offset;
18633                } else {
18634                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18635                    inner_depth.increment()?;
18636                }
18637                let val_ref = self.renamed_instances.get_or_insert_with(|| {
18638                    fidl::new_empty!(fidl::encoding::UnboundedVector<NameMapping>, D)
18639                });
18640                fidl::decode!(
18641                    fidl::encoding::UnboundedVector<NameMapping>,
18642                    D,
18643                    val_ref,
18644                    decoder,
18645                    inner_offset,
18646                    inner_depth
18647                )?;
18648                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18649                {
18650                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18651                }
18652                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18653                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18654                }
18655            }
18656
18657            next_offset += envelope_size;
18658            _next_ordinal_to_read += 1;
18659            if next_offset >= end_offset {
18660                return Ok(());
18661            }
18662
18663            // Decode unknown envelopes for gaps in ordinals.
18664            while _next_ordinal_to_read < 7 {
18665                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18666                _next_ordinal_to_read += 1;
18667                next_offset += envelope_size;
18668            }
18669
18670            let next_out_of_line = decoder.next_out_of_line();
18671            let handles_before = decoder.remaining_handles();
18672            if let Some((inlined, num_bytes, num_handles)) =
18673                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18674            {
18675                let member_inline_size =
18676                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18677                if inlined != (member_inline_size <= 4) {
18678                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18679                }
18680                let inner_offset;
18681                let mut inner_depth = depth.clone();
18682                if inlined {
18683                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18684                    inner_offset = next_offset;
18685                } else {
18686                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18687                    inner_depth.increment()?;
18688                }
18689                let val_ref =
18690                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
18691                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
18692                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18693                {
18694                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18695                }
18696                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18697                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18698                }
18699            }
18700
18701            next_offset += envelope_size;
18702            _next_ordinal_to_read += 1;
18703            if next_offset >= end_offset {
18704                return Ok(());
18705            }
18706
18707            // Decode unknown envelopes for gaps in ordinals.
18708            while _next_ordinal_to_read < 8 {
18709                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18710                _next_ordinal_to_read += 1;
18711                next_offset += envelope_size;
18712            }
18713
18714            let next_out_of_line = decoder.next_out_of_line();
18715            let handles_before = decoder.remaining_handles();
18716            if let Some((inlined, num_bytes, num_handles)) =
18717                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18718            {
18719                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18720                if inlined != (member_inline_size <= 4) {
18721                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18722                }
18723                let inner_offset;
18724                let mut inner_depth = depth.clone();
18725                if inlined {
18726                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18727                    inner_offset = next_offset;
18728                } else {
18729                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18730                    inner_depth.increment()?;
18731                }
18732                let val_ref = self.source_dictionary.get_or_insert_with(|| {
18733                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
18734                });
18735                fidl::decode!(
18736                    fidl::encoding::BoundedString<1024>,
18737                    D,
18738                    val_ref,
18739                    decoder,
18740                    inner_offset,
18741                    inner_depth
18742                )?;
18743                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18744                {
18745                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18746                }
18747                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18748                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18749                }
18750            }
18751
18752            next_offset += envelope_size;
18753            _next_ordinal_to_read += 1;
18754            if next_offset >= end_offset {
18755                return Ok(());
18756            }
18757
18758            // Decode unknown envelopes for gaps in ordinals.
18759            while _next_ordinal_to_read < 9 {
18760                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18761                _next_ordinal_to_read += 1;
18762                next_offset += envelope_size;
18763            }
18764
18765            let next_out_of_line = decoder.next_out_of_line();
18766            let handles_before = decoder.remaining_handles();
18767            if let Some((inlined, num_bytes, num_handles)) =
18768                fidl::encoding::decode_envelope_header(decoder, next_offset)?
18769            {
18770                let member_inline_size =
18771                    <DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
18772                if inlined != (member_inline_size <= 4) {
18773                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
18774                }
18775                let inner_offset;
18776                let mut inner_depth = depth.clone();
18777                if inlined {
18778                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
18779                    inner_offset = next_offset;
18780                } else {
18781                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
18782                    inner_depth.increment()?;
18783                }
18784                let val_ref =
18785                    self.dependency_type.get_or_insert_with(|| fidl::new_empty!(DependencyType, D));
18786                fidl::decode!(DependencyType, D, val_ref, decoder, inner_offset, inner_depth)?;
18787                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
18788                {
18789                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
18790                }
18791                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
18792                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
18793                }
18794            }
18795
18796            next_offset += envelope_size;
18797
18798            // Decode the remaining unknown envelopes.
18799            while next_offset < end_offset {
18800                _next_ordinal_to_read += 1;
18801                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
18802                next_offset += envelope_size;
18803            }
18804
18805            Ok(())
18806        }
18807    }
18808
18809    impl OfferStorage {
18810        #[inline(always)]
18811        fn max_ordinal_present(&self) -> u64 {
18812            if let Some(_) = self.availability {
18813                return 5;
18814            }
18815            if let Some(_) = self.target_name {
18816                return 4;
18817            }
18818            if let Some(_) = self.target {
18819                return 3;
18820            }
18821            if let Some(_) = self.source {
18822                return 2;
18823            }
18824            if let Some(_) = self.source_name {
18825                return 1;
18826            }
18827            0
18828        }
18829    }
18830
18831    impl fidl::encoding::ValueTypeMarker for OfferStorage {
18832        type Borrowed<'a> = &'a Self;
18833        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
18834            value
18835        }
18836    }
18837
18838    unsafe impl fidl::encoding::TypeMarker for OfferStorage {
18839        type Owned = Self;
18840
18841        #[inline(always)]
18842        fn inline_align(_context: fidl::encoding::Context) -> usize {
18843            8
18844        }
18845
18846        #[inline(always)]
18847        fn inline_size(_context: fidl::encoding::Context) -> usize {
18848            16
18849        }
18850    }
18851
18852    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OfferStorage, D>
18853        for &OfferStorage
18854    {
18855        unsafe fn encode(
18856            self,
18857            encoder: &mut fidl::encoding::Encoder<'_, D>,
18858            offset: usize,
18859            mut depth: fidl::encoding::Depth,
18860        ) -> fidl::Result<()> {
18861            encoder.debug_check_bounds::<OfferStorage>(offset);
18862            // Vector header
18863            let max_ordinal: u64 = self.max_ordinal_present();
18864            encoder.write_num(max_ordinal, offset);
18865            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
18866            // Calling encoder.out_of_line_offset(0) is not allowed.
18867            if max_ordinal == 0 {
18868                return Ok(());
18869            }
18870            depth.increment()?;
18871            let envelope_size = 8;
18872            let bytes_len = max_ordinal as usize * envelope_size;
18873            #[allow(unused_variables)]
18874            let offset = encoder.out_of_line_offset(bytes_len);
18875            let mut _prev_end_offset: usize = 0;
18876            if 1 > max_ordinal {
18877                return Ok(());
18878            }
18879
18880            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18881            // are envelope_size bytes.
18882            let cur_offset: usize = (1 - 1) * envelope_size;
18883
18884            // Zero reserved fields.
18885            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18886
18887            // Safety:
18888            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18889            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18890            //   envelope_size bytes, there is always sufficient room.
18891            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
18892                self.source_name.as_ref().map(
18893                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
18894                ),
18895                encoder,
18896                offset + cur_offset,
18897                depth,
18898            )?;
18899
18900            _prev_end_offset = cur_offset + envelope_size;
18901            if 2 > max_ordinal {
18902                return Ok(());
18903            }
18904
18905            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18906            // are envelope_size bytes.
18907            let cur_offset: usize = (2 - 1) * envelope_size;
18908
18909            // Zero reserved fields.
18910            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18911
18912            // Safety:
18913            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18914            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18915            //   envelope_size bytes, there is always sufficient room.
18916            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
18917                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
18918                encoder,
18919                offset + cur_offset,
18920                depth,
18921            )?;
18922
18923            _prev_end_offset = cur_offset + envelope_size;
18924            if 3 > max_ordinal {
18925                return Ok(());
18926            }
18927
18928            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18929            // are envelope_size bytes.
18930            let cur_offset: usize = (3 - 1) * envelope_size;
18931
18932            // Zero reserved fields.
18933            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18934
18935            // Safety:
18936            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18937            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18938            //   envelope_size bytes, there is always sufficient room.
18939            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
18940                self.target.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
18941                encoder,
18942                offset + cur_offset,
18943                depth,
18944            )?;
18945
18946            _prev_end_offset = cur_offset + envelope_size;
18947            if 4 > max_ordinal {
18948                return Ok(());
18949            }
18950
18951            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18952            // are envelope_size bytes.
18953            let cur_offset: usize = (4 - 1) * envelope_size;
18954
18955            // Zero reserved fields.
18956            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18957
18958            // Safety:
18959            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18960            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18961            //   envelope_size bytes, there is always sufficient room.
18962            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
18963                self.target_name.as_ref().map(
18964                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
18965                ),
18966                encoder,
18967                offset + cur_offset,
18968                depth,
18969            )?;
18970
18971            _prev_end_offset = cur_offset + envelope_size;
18972            if 5 > max_ordinal {
18973                return Ok(());
18974            }
18975
18976            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
18977            // are envelope_size bytes.
18978            let cur_offset: usize = (5 - 1) * envelope_size;
18979
18980            // Zero reserved fields.
18981            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
18982
18983            // Safety:
18984            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
18985            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
18986            //   envelope_size bytes, there is always sufficient room.
18987            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
18988                self.availability
18989                    .as_ref()
18990                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
18991                encoder,
18992                offset + cur_offset,
18993                depth,
18994            )?;
18995
18996            _prev_end_offset = cur_offset + envelope_size;
18997
18998            Ok(())
18999        }
19000    }
19001
19002    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OfferStorage {
19003        #[inline(always)]
19004        fn new_empty() -> Self {
19005            Self::default()
19006        }
19007
19008        unsafe fn decode(
19009            &mut self,
19010            decoder: &mut fidl::encoding::Decoder<'_, D>,
19011            offset: usize,
19012            mut depth: fidl::encoding::Depth,
19013        ) -> fidl::Result<()> {
19014            decoder.debug_check_bounds::<Self>(offset);
19015            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
19016                None => return Err(fidl::Error::NotNullable),
19017                Some(len) => len,
19018            };
19019            // Calling decoder.out_of_line_offset(0) is not allowed.
19020            if len == 0 {
19021                return Ok(());
19022            };
19023            depth.increment()?;
19024            let envelope_size = 8;
19025            let bytes_len = len * envelope_size;
19026            let offset = decoder.out_of_line_offset(bytes_len)?;
19027            // Decode the envelope for each type.
19028            let mut _next_ordinal_to_read = 0;
19029            let mut next_offset = offset;
19030            let end_offset = offset + bytes_len;
19031            _next_ordinal_to_read += 1;
19032            if next_offset >= end_offset {
19033                return Ok(());
19034            }
19035
19036            // Decode unknown envelopes for gaps in ordinals.
19037            while _next_ordinal_to_read < 1 {
19038                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19039                _next_ordinal_to_read += 1;
19040                next_offset += envelope_size;
19041            }
19042
19043            let next_out_of_line = decoder.next_out_of_line();
19044            let handles_before = decoder.remaining_handles();
19045            if let Some((inlined, num_bytes, num_handles)) =
19046                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19047            {
19048                let member_inline_size =
19049                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
19050                        decoder.context,
19051                    );
19052                if inlined != (member_inline_size <= 4) {
19053                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19054                }
19055                let inner_offset;
19056                let mut inner_depth = depth.clone();
19057                if inlined {
19058                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19059                    inner_offset = next_offset;
19060                } else {
19061                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19062                    inner_depth.increment()?;
19063                }
19064                let val_ref = self
19065                    .source_name
19066                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
19067                fidl::decode!(
19068                    fidl::encoding::BoundedString<100>,
19069                    D,
19070                    val_ref,
19071                    decoder,
19072                    inner_offset,
19073                    inner_depth
19074                )?;
19075                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19076                {
19077                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19078                }
19079                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19080                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19081                }
19082            }
19083
19084            next_offset += envelope_size;
19085            _next_ordinal_to_read += 1;
19086            if next_offset >= end_offset {
19087                return Ok(());
19088            }
19089
19090            // Decode unknown envelopes for gaps in ordinals.
19091            while _next_ordinal_to_read < 2 {
19092                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19093                _next_ordinal_to_read += 1;
19094                next_offset += envelope_size;
19095            }
19096
19097            let next_out_of_line = decoder.next_out_of_line();
19098            let handles_before = decoder.remaining_handles();
19099            if let Some((inlined, num_bytes, num_handles)) =
19100                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19101            {
19102                let member_inline_size =
19103                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19104                if inlined != (member_inline_size <= 4) {
19105                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19106                }
19107                let inner_offset;
19108                let mut inner_depth = depth.clone();
19109                if inlined {
19110                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19111                    inner_offset = next_offset;
19112                } else {
19113                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19114                    inner_depth.increment()?;
19115                }
19116                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
19117                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
19118                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19119                {
19120                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19121                }
19122                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19123                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19124                }
19125            }
19126
19127            next_offset += envelope_size;
19128            _next_ordinal_to_read += 1;
19129            if next_offset >= end_offset {
19130                return Ok(());
19131            }
19132
19133            // Decode unknown envelopes for gaps in ordinals.
19134            while _next_ordinal_to_read < 3 {
19135                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19136                _next_ordinal_to_read += 1;
19137                next_offset += envelope_size;
19138            }
19139
19140            let next_out_of_line = decoder.next_out_of_line();
19141            let handles_before = decoder.remaining_handles();
19142            if let Some((inlined, num_bytes, num_handles)) =
19143                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19144            {
19145                let member_inline_size =
19146                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19147                if inlined != (member_inline_size <= 4) {
19148                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19149                }
19150                let inner_offset;
19151                let mut inner_depth = depth.clone();
19152                if inlined {
19153                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19154                    inner_offset = next_offset;
19155                } else {
19156                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19157                    inner_depth.increment()?;
19158                }
19159                let val_ref = self.target.get_or_insert_with(|| fidl::new_empty!(Ref, D));
19160                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
19161                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19162                {
19163                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19164                }
19165                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19166                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19167                }
19168            }
19169
19170            next_offset += envelope_size;
19171            _next_ordinal_to_read += 1;
19172            if next_offset >= end_offset {
19173                return Ok(());
19174            }
19175
19176            // Decode unknown envelopes for gaps in ordinals.
19177            while _next_ordinal_to_read < 4 {
19178                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19179                _next_ordinal_to_read += 1;
19180                next_offset += envelope_size;
19181            }
19182
19183            let next_out_of_line = decoder.next_out_of_line();
19184            let handles_before = decoder.remaining_handles();
19185            if let Some((inlined, num_bytes, num_handles)) =
19186                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19187            {
19188                let member_inline_size =
19189                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
19190                        decoder.context,
19191                    );
19192                if inlined != (member_inline_size <= 4) {
19193                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19194                }
19195                let inner_offset;
19196                let mut inner_depth = depth.clone();
19197                if inlined {
19198                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19199                    inner_offset = next_offset;
19200                } else {
19201                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19202                    inner_depth.increment()?;
19203                }
19204                let val_ref = self
19205                    .target_name
19206                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
19207                fidl::decode!(
19208                    fidl::encoding::BoundedString<100>,
19209                    D,
19210                    val_ref,
19211                    decoder,
19212                    inner_offset,
19213                    inner_depth
19214                )?;
19215                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19216                {
19217                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19218                }
19219                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19220                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19221                }
19222            }
19223
19224            next_offset += envelope_size;
19225            _next_ordinal_to_read += 1;
19226            if next_offset >= end_offset {
19227                return Ok(());
19228            }
19229
19230            // Decode unknown envelopes for gaps in ordinals.
19231            while _next_ordinal_to_read < 5 {
19232                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19233                _next_ordinal_to_read += 1;
19234                next_offset += envelope_size;
19235            }
19236
19237            let next_out_of_line = decoder.next_out_of_line();
19238            let handles_before = decoder.remaining_handles();
19239            if let Some((inlined, num_bytes, num_handles)) =
19240                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19241            {
19242                let member_inline_size =
19243                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19244                if inlined != (member_inline_size <= 4) {
19245                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19246                }
19247                let inner_offset;
19248                let mut inner_depth = depth.clone();
19249                if inlined {
19250                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19251                    inner_offset = next_offset;
19252                } else {
19253                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19254                    inner_depth.increment()?;
19255                }
19256                let val_ref =
19257                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
19258                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
19259                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19260                {
19261                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19262                }
19263                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19264                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19265                }
19266            }
19267
19268            next_offset += envelope_size;
19269
19270            // Decode the remaining unknown envelopes.
19271            while next_offset < end_offset {
19272                _next_ordinal_to_read += 1;
19273                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19274                next_offset += envelope_size;
19275            }
19276
19277            Ok(())
19278        }
19279    }
19280
19281    impl Program {
19282        #[inline(always)]
19283        fn max_ordinal_present(&self) -> u64 {
19284            if let Some(_) = self.info {
19285                return 2;
19286            }
19287            if let Some(_) = self.runner {
19288                return 1;
19289            }
19290            0
19291        }
19292    }
19293
19294    impl fidl::encoding::ValueTypeMarker for Program {
19295        type Borrowed<'a> = &'a Self;
19296        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
19297            value
19298        }
19299    }
19300
19301    unsafe impl fidl::encoding::TypeMarker for Program {
19302        type Owned = Self;
19303
19304        #[inline(always)]
19305        fn inline_align(_context: fidl::encoding::Context) -> usize {
19306            8
19307        }
19308
19309        #[inline(always)]
19310        fn inline_size(_context: fidl::encoding::Context) -> usize {
19311            16
19312        }
19313    }
19314
19315    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Program, D> for &Program {
19316        unsafe fn encode(
19317            self,
19318            encoder: &mut fidl::encoding::Encoder<'_, D>,
19319            offset: usize,
19320            mut depth: fidl::encoding::Depth,
19321        ) -> fidl::Result<()> {
19322            encoder.debug_check_bounds::<Program>(offset);
19323            // Vector header
19324            let max_ordinal: u64 = self.max_ordinal_present();
19325            encoder.write_num(max_ordinal, offset);
19326            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
19327            // Calling encoder.out_of_line_offset(0) is not allowed.
19328            if max_ordinal == 0 {
19329                return Ok(());
19330            }
19331            depth.increment()?;
19332            let envelope_size = 8;
19333            let bytes_len = max_ordinal as usize * envelope_size;
19334            #[allow(unused_variables)]
19335            let offset = encoder.out_of_line_offset(bytes_len);
19336            let mut _prev_end_offset: usize = 0;
19337            if 1 > max_ordinal {
19338                return Ok(());
19339            }
19340
19341            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19342            // are envelope_size bytes.
19343            let cur_offset: usize = (1 - 1) * envelope_size;
19344
19345            // Zero reserved fields.
19346            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19347
19348            // Safety:
19349            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19350            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19351            //   envelope_size bytes, there is always sufficient room.
19352            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
19353                self.runner.as_ref().map(
19354                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
19355                ),
19356                encoder,
19357                offset + cur_offset,
19358                depth,
19359            )?;
19360
19361            _prev_end_offset = cur_offset + envelope_size;
19362            if 2 > max_ordinal {
19363                return Ok(());
19364            }
19365
19366            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19367            // are envelope_size bytes.
19368            let cur_offset: usize = (2 - 1) * envelope_size;
19369
19370            // Zero reserved fields.
19371            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19372
19373            // Safety:
19374            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19375            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19376            //   envelope_size bytes, there is always sufficient room.
19377            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_data__common::Dictionary, D>(
19378            self.info.as_ref().map(<fidl_fuchsia_data__common::Dictionary as fidl::encoding::ValueTypeMarker>::borrow),
19379            encoder, offset + cur_offset, depth
19380        )?;
19381
19382            _prev_end_offset = cur_offset + envelope_size;
19383
19384            Ok(())
19385        }
19386    }
19387
19388    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Program {
19389        #[inline(always)]
19390        fn new_empty() -> Self {
19391            Self::default()
19392        }
19393
19394        unsafe fn decode(
19395            &mut self,
19396            decoder: &mut fidl::encoding::Decoder<'_, D>,
19397            offset: usize,
19398            mut depth: fidl::encoding::Depth,
19399        ) -> fidl::Result<()> {
19400            decoder.debug_check_bounds::<Self>(offset);
19401            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
19402                None => return Err(fidl::Error::NotNullable),
19403                Some(len) => len,
19404            };
19405            // Calling decoder.out_of_line_offset(0) is not allowed.
19406            if len == 0 {
19407                return Ok(());
19408            };
19409            depth.increment()?;
19410            let envelope_size = 8;
19411            let bytes_len = len * envelope_size;
19412            let offset = decoder.out_of_line_offset(bytes_len)?;
19413            // Decode the envelope for each type.
19414            let mut _next_ordinal_to_read = 0;
19415            let mut next_offset = offset;
19416            let end_offset = offset + bytes_len;
19417            _next_ordinal_to_read += 1;
19418            if next_offset >= end_offset {
19419                return Ok(());
19420            }
19421
19422            // Decode unknown envelopes for gaps in ordinals.
19423            while _next_ordinal_to_read < 1 {
19424                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19425                _next_ordinal_to_read += 1;
19426                next_offset += envelope_size;
19427            }
19428
19429            let next_out_of_line = decoder.next_out_of_line();
19430            let handles_before = decoder.remaining_handles();
19431            if let Some((inlined, num_bytes, num_handles)) =
19432                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19433            {
19434                let member_inline_size =
19435                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
19436                        decoder.context,
19437                    );
19438                if inlined != (member_inline_size <= 4) {
19439                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19440                }
19441                let inner_offset;
19442                let mut inner_depth = depth.clone();
19443                if inlined {
19444                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19445                    inner_offset = next_offset;
19446                } else {
19447                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19448                    inner_depth.increment()?;
19449                }
19450                let val_ref = self
19451                    .runner
19452                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
19453                fidl::decode!(
19454                    fidl::encoding::BoundedString<100>,
19455                    D,
19456                    val_ref,
19457                    decoder,
19458                    inner_offset,
19459                    inner_depth
19460                )?;
19461                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19462                {
19463                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19464                }
19465                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19466                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19467                }
19468            }
19469
19470            next_offset += envelope_size;
19471            _next_ordinal_to_read += 1;
19472            if next_offset >= end_offset {
19473                return Ok(());
19474            }
19475
19476            // Decode unknown envelopes for gaps in ordinals.
19477            while _next_ordinal_to_read < 2 {
19478                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19479                _next_ordinal_to_read += 1;
19480                next_offset += envelope_size;
19481            }
19482
19483            let next_out_of_line = decoder.next_out_of_line();
19484            let handles_before = decoder.remaining_handles();
19485            if let Some((inlined, num_bytes, num_handles)) =
19486                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19487            {
19488                let member_inline_size = <fidl_fuchsia_data__common::Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19489                if inlined != (member_inline_size <= 4) {
19490                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19491                }
19492                let inner_offset;
19493                let mut inner_depth = depth.clone();
19494                if inlined {
19495                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19496                    inner_offset = next_offset;
19497                } else {
19498                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19499                    inner_depth.increment()?;
19500                }
19501                let val_ref = self.info.get_or_insert_with(|| {
19502                    fidl::new_empty!(fidl_fuchsia_data__common::Dictionary, D)
19503                });
19504                fidl::decode!(
19505                    fidl_fuchsia_data__common::Dictionary,
19506                    D,
19507                    val_ref,
19508                    decoder,
19509                    inner_offset,
19510                    inner_depth
19511                )?;
19512                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19513                {
19514                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19515                }
19516                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19517                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19518                }
19519            }
19520
19521            next_offset += envelope_size;
19522
19523            // Decode the remaining unknown envelopes.
19524            while next_offset < end_offset {
19525                _next_ordinal_to_read += 1;
19526                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19527                next_offset += envelope_size;
19528            }
19529
19530            Ok(())
19531        }
19532    }
19533
19534    impl Protocol {
19535        #[inline(always)]
19536        fn max_ordinal_present(&self) -> u64 {
19537            if let Some(_) = self.delivery {
19538                return 3;
19539            }
19540            if let Some(_) = self.source_path {
19541                return 2;
19542            }
19543            if let Some(_) = self.name {
19544                return 1;
19545            }
19546            0
19547        }
19548    }
19549
19550    impl fidl::encoding::ValueTypeMarker for Protocol {
19551        type Borrowed<'a> = &'a Self;
19552        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
19553            value
19554        }
19555    }
19556
19557    unsafe impl fidl::encoding::TypeMarker for Protocol {
19558        type Owned = Self;
19559
19560        #[inline(always)]
19561        fn inline_align(_context: fidl::encoding::Context) -> usize {
19562            8
19563        }
19564
19565        #[inline(always)]
19566        fn inline_size(_context: fidl::encoding::Context) -> usize {
19567            16
19568        }
19569    }
19570
19571    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Protocol, D> for &Protocol {
19572        unsafe fn encode(
19573            self,
19574            encoder: &mut fidl::encoding::Encoder<'_, D>,
19575            offset: usize,
19576            mut depth: fidl::encoding::Depth,
19577        ) -> fidl::Result<()> {
19578            encoder.debug_check_bounds::<Protocol>(offset);
19579            // Vector header
19580            let max_ordinal: u64 = self.max_ordinal_present();
19581            encoder.write_num(max_ordinal, offset);
19582            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
19583            // Calling encoder.out_of_line_offset(0) is not allowed.
19584            if max_ordinal == 0 {
19585                return Ok(());
19586            }
19587            depth.increment()?;
19588            let envelope_size = 8;
19589            let bytes_len = max_ordinal as usize * envelope_size;
19590            #[allow(unused_variables)]
19591            let offset = encoder.out_of_line_offset(bytes_len);
19592            let mut _prev_end_offset: usize = 0;
19593            if 1 > max_ordinal {
19594                return Ok(());
19595            }
19596
19597            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19598            // are envelope_size bytes.
19599            let cur_offset: usize = (1 - 1) * envelope_size;
19600
19601            // Zero reserved fields.
19602            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19603
19604            // Safety:
19605            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19606            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19607            //   envelope_size bytes, there is always sufficient room.
19608            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
19609                self.name.as_ref().map(
19610                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
19611                ),
19612                encoder,
19613                offset + cur_offset,
19614                depth,
19615            )?;
19616
19617            _prev_end_offset = cur_offset + envelope_size;
19618            if 2 > max_ordinal {
19619                return Ok(());
19620            }
19621
19622            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19623            // are envelope_size bytes.
19624            let cur_offset: usize = (2 - 1) * envelope_size;
19625
19626            // Zero reserved fields.
19627            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19628
19629            // Safety:
19630            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19631            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19632            //   envelope_size bytes, there is always sufficient room.
19633            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
19634            self.source_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
19635            encoder, offset + cur_offset, depth
19636        )?;
19637
19638            _prev_end_offset = cur_offset + envelope_size;
19639            if 3 > max_ordinal {
19640                return Ok(());
19641            }
19642
19643            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19644            // are envelope_size bytes.
19645            let cur_offset: usize = (3 - 1) * envelope_size;
19646
19647            // Zero reserved fields.
19648            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19649
19650            // Safety:
19651            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19652            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19653            //   envelope_size bytes, there is always sufficient room.
19654            fidl::encoding::encode_in_envelope_optional::<DeliveryType, D>(
19655                self.delivery
19656                    .as_ref()
19657                    .map(<DeliveryType as fidl::encoding::ValueTypeMarker>::borrow),
19658                encoder,
19659                offset + cur_offset,
19660                depth,
19661            )?;
19662
19663            _prev_end_offset = cur_offset + envelope_size;
19664
19665            Ok(())
19666        }
19667    }
19668
19669    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Protocol {
19670        #[inline(always)]
19671        fn new_empty() -> Self {
19672            Self::default()
19673        }
19674
19675        unsafe fn decode(
19676            &mut self,
19677            decoder: &mut fidl::encoding::Decoder<'_, D>,
19678            offset: usize,
19679            mut depth: fidl::encoding::Depth,
19680        ) -> fidl::Result<()> {
19681            decoder.debug_check_bounds::<Self>(offset);
19682            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
19683                None => return Err(fidl::Error::NotNullable),
19684                Some(len) => len,
19685            };
19686            // Calling decoder.out_of_line_offset(0) is not allowed.
19687            if len == 0 {
19688                return Ok(());
19689            };
19690            depth.increment()?;
19691            let envelope_size = 8;
19692            let bytes_len = len * envelope_size;
19693            let offset = decoder.out_of_line_offset(bytes_len)?;
19694            // Decode the envelope for each type.
19695            let mut _next_ordinal_to_read = 0;
19696            let mut next_offset = offset;
19697            let end_offset = offset + bytes_len;
19698            _next_ordinal_to_read += 1;
19699            if next_offset >= end_offset {
19700                return Ok(());
19701            }
19702
19703            // Decode unknown envelopes for gaps in ordinals.
19704            while _next_ordinal_to_read < 1 {
19705                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19706                _next_ordinal_to_read += 1;
19707                next_offset += envelope_size;
19708            }
19709
19710            let next_out_of_line = decoder.next_out_of_line();
19711            let handles_before = decoder.remaining_handles();
19712            if let Some((inlined, num_bytes, num_handles)) =
19713                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19714            {
19715                let member_inline_size =
19716                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
19717                        decoder.context,
19718                    );
19719                if inlined != (member_inline_size <= 4) {
19720                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19721                }
19722                let inner_offset;
19723                let mut inner_depth = depth.clone();
19724                if inlined {
19725                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19726                    inner_offset = next_offset;
19727                } else {
19728                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19729                    inner_depth.increment()?;
19730                }
19731                let val_ref = self
19732                    .name
19733                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
19734                fidl::decode!(
19735                    fidl::encoding::BoundedString<100>,
19736                    D,
19737                    val_ref,
19738                    decoder,
19739                    inner_offset,
19740                    inner_depth
19741                )?;
19742                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19743                {
19744                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19745                }
19746                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19747                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19748                }
19749            }
19750
19751            next_offset += envelope_size;
19752            _next_ordinal_to_read += 1;
19753            if next_offset >= end_offset {
19754                return Ok(());
19755            }
19756
19757            // Decode unknown envelopes for gaps in ordinals.
19758            while _next_ordinal_to_read < 2 {
19759                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19760                _next_ordinal_to_read += 1;
19761                next_offset += envelope_size;
19762            }
19763
19764            let next_out_of_line = decoder.next_out_of_line();
19765            let handles_before = decoder.remaining_handles();
19766            if let Some((inlined, num_bytes, num_handles)) =
19767                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19768            {
19769                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19770                if inlined != (member_inline_size <= 4) {
19771                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19772                }
19773                let inner_offset;
19774                let mut inner_depth = depth.clone();
19775                if inlined {
19776                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19777                    inner_offset = next_offset;
19778                } else {
19779                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19780                    inner_depth.increment()?;
19781                }
19782                let val_ref = self.source_path.get_or_insert_with(|| {
19783                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
19784                });
19785                fidl::decode!(
19786                    fidl::encoding::BoundedString<1024>,
19787                    D,
19788                    val_ref,
19789                    decoder,
19790                    inner_offset,
19791                    inner_depth
19792                )?;
19793                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19794                {
19795                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19796                }
19797                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19798                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19799                }
19800            }
19801
19802            next_offset += envelope_size;
19803            _next_ordinal_to_read += 1;
19804            if next_offset >= end_offset {
19805                return Ok(());
19806            }
19807
19808            // Decode unknown envelopes for gaps in ordinals.
19809            while _next_ordinal_to_read < 3 {
19810                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19811                _next_ordinal_to_read += 1;
19812                next_offset += envelope_size;
19813            }
19814
19815            let next_out_of_line = decoder.next_out_of_line();
19816            let handles_before = decoder.remaining_handles();
19817            if let Some((inlined, num_bytes, num_handles)) =
19818                fidl::encoding::decode_envelope_header(decoder, next_offset)?
19819            {
19820                let member_inline_size =
19821                    <DeliveryType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
19822                if inlined != (member_inline_size <= 4) {
19823                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
19824                }
19825                let inner_offset;
19826                let mut inner_depth = depth.clone();
19827                if inlined {
19828                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
19829                    inner_offset = next_offset;
19830                } else {
19831                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
19832                    inner_depth.increment()?;
19833                }
19834                let val_ref =
19835                    self.delivery.get_or_insert_with(|| fidl::new_empty!(DeliveryType, D));
19836                fidl::decode!(DeliveryType, D, val_ref, decoder, inner_offset, inner_depth)?;
19837                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
19838                {
19839                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
19840                }
19841                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
19842                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
19843                }
19844            }
19845
19846            next_offset += envelope_size;
19847
19848            // Decode the remaining unknown envelopes.
19849            while next_offset < end_offset {
19850                _next_ordinal_to_read += 1;
19851                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
19852                next_offset += envelope_size;
19853            }
19854
19855            Ok(())
19856        }
19857    }
19858
19859    impl Resolver {
19860        #[inline(always)]
19861        fn max_ordinal_present(&self) -> u64 {
19862            if let Some(_) = self.source_path {
19863                return 2;
19864            }
19865            if let Some(_) = self.name {
19866                return 1;
19867            }
19868            0
19869        }
19870    }
19871
19872    impl fidl::encoding::ValueTypeMarker for Resolver {
19873        type Borrowed<'a> = &'a Self;
19874        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
19875            value
19876        }
19877    }
19878
19879    unsafe impl fidl::encoding::TypeMarker for Resolver {
19880        type Owned = Self;
19881
19882        #[inline(always)]
19883        fn inline_align(_context: fidl::encoding::Context) -> usize {
19884            8
19885        }
19886
19887        #[inline(always)]
19888        fn inline_size(_context: fidl::encoding::Context) -> usize {
19889            16
19890        }
19891    }
19892
19893    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Resolver, D> for &Resolver {
19894        unsafe fn encode(
19895            self,
19896            encoder: &mut fidl::encoding::Encoder<'_, D>,
19897            offset: usize,
19898            mut depth: fidl::encoding::Depth,
19899        ) -> fidl::Result<()> {
19900            encoder.debug_check_bounds::<Resolver>(offset);
19901            // Vector header
19902            let max_ordinal: u64 = self.max_ordinal_present();
19903            encoder.write_num(max_ordinal, offset);
19904            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
19905            // Calling encoder.out_of_line_offset(0) is not allowed.
19906            if max_ordinal == 0 {
19907                return Ok(());
19908            }
19909            depth.increment()?;
19910            let envelope_size = 8;
19911            let bytes_len = max_ordinal as usize * envelope_size;
19912            #[allow(unused_variables)]
19913            let offset = encoder.out_of_line_offset(bytes_len);
19914            let mut _prev_end_offset: usize = 0;
19915            if 1 > max_ordinal {
19916                return Ok(());
19917            }
19918
19919            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19920            // are envelope_size bytes.
19921            let cur_offset: usize = (1 - 1) * envelope_size;
19922
19923            // Zero reserved fields.
19924            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19925
19926            // Safety:
19927            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19928            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19929            //   envelope_size bytes, there is always sufficient room.
19930            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
19931                self.name.as_ref().map(
19932                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
19933                ),
19934                encoder,
19935                offset + cur_offset,
19936                depth,
19937            )?;
19938
19939            _prev_end_offset = cur_offset + envelope_size;
19940            if 2 > max_ordinal {
19941                return Ok(());
19942            }
19943
19944            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
19945            // are envelope_size bytes.
19946            let cur_offset: usize = (2 - 1) * envelope_size;
19947
19948            // Zero reserved fields.
19949            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
19950
19951            // Safety:
19952            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
19953            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
19954            //   envelope_size bytes, there is always sufficient room.
19955            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
19956            self.source_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
19957            encoder, offset + cur_offset, depth
19958        )?;
19959
19960            _prev_end_offset = cur_offset + envelope_size;
19961
19962            Ok(())
19963        }
19964    }
19965
19966    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Resolver {
19967        #[inline(always)]
19968        fn new_empty() -> Self {
19969            Self::default()
19970        }
19971
19972        unsafe fn decode(
19973            &mut self,
19974            decoder: &mut fidl::encoding::Decoder<'_, D>,
19975            offset: usize,
19976            mut depth: fidl::encoding::Depth,
19977        ) -> fidl::Result<()> {
19978            decoder.debug_check_bounds::<Self>(offset);
19979            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
19980                None => return Err(fidl::Error::NotNullable),
19981                Some(len) => len,
19982            };
19983            // Calling decoder.out_of_line_offset(0) is not allowed.
19984            if len == 0 {
19985                return Ok(());
19986            };
19987            depth.increment()?;
19988            let envelope_size = 8;
19989            let bytes_len = len * envelope_size;
19990            let offset = decoder.out_of_line_offset(bytes_len)?;
19991            // Decode the envelope for each type.
19992            let mut _next_ordinal_to_read = 0;
19993            let mut next_offset = offset;
19994            let end_offset = offset + bytes_len;
19995            _next_ordinal_to_read += 1;
19996            if next_offset >= end_offset {
19997                return Ok(());
19998            }
19999
20000            // Decode unknown envelopes for gaps in ordinals.
20001            while _next_ordinal_to_read < 1 {
20002                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20003                _next_ordinal_to_read += 1;
20004                next_offset += envelope_size;
20005            }
20006
20007            let next_out_of_line = decoder.next_out_of_line();
20008            let handles_before = decoder.remaining_handles();
20009            if let Some((inlined, num_bytes, num_handles)) =
20010                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20011            {
20012                let member_inline_size =
20013                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
20014                        decoder.context,
20015                    );
20016                if inlined != (member_inline_size <= 4) {
20017                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20018                }
20019                let inner_offset;
20020                let mut inner_depth = depth.clone();
20021                if inlined {
20022                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20023                    inner_offset = next_offset;
20024                } else {
20025                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20026                    inner_depth.increment()?;
20027                }
20028                let val_ref = self
20029                    .name
20030                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
20031                fidl::decode!(
20032                    fidl::encoding::BoundedString<100>,
20033                    D,
20034                    val_ref,
20035                    decoder,
20036                    inner_offset,
20037                    inner_depth
20038                )?;
20039                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20040                {
20041                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20042                }
20043                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20044                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20045                }
20046            }
20047
20048            next_offset += envelope_size;
20049            _next_ordinal_to_read += 1;
20050            if next_offset >= end_offset {
20051                return Ok(());
20052            }
20053
20054            // Decode unknown envelopes for gaps in ordinals.
20055            while _next_ordinal_to_read < 2 {
20056                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20057                _next_ordinal_to_read += 1;
20058                next_offset += envelope_size;
20059            }
20060
20061            let next_out_of_line = decoder.next_out_of_line();
20062            let handles_before = decoder.remaining_handles();
20063            if let Some((inlined, num_bytes, num_handles)) =
20064                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20065            {
20066                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20067                if inlined != (member_inline_size <= 4) {
20068                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20069                }
20070                let inner_offset;
20071                let mut inner_depth = depth.clone();
20072                if inlined {
20073                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20074                    inner_offset = next_offset;
20075                } else {
20076                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20077                    inner_depth.increment()?;
20078                }
20079                let val_ref = self.source_path.get_or_insert_with(|| {
20080                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
20081                });
20082                fidl::decode!(
20083                    fidl::encoding::BoundedString<1024>,
20084                    D,
20085                    val_ref,
20086                    decoder,
20087                    inner_offset,
20088                    inner_depth
20089                )?;
20090                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20091                {
20092                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20093                }
20094                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20095                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20096                }
20097            }
20098
20099            next_offset += envelope_size;
20100
20101            // Decode the remaining unknown envelopes.
20102            while next_offset < end_offset {
20103                _next_ordinal_to_read += 1;
20104                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20105                next_offset += envelope_size;
20106            }
20107
20108            Ok(())
20109        }
20110    }
20111
20112    impl ResolverRegistration {
20113        #[inline(always)]
20114        fn max_ordinal_present(&self) -> u64 {
20115            if let Some(_) = self.scheme {
20116                return 3;
20117            }
20118            if let Some(_) = self.source {
20119                return 2;
20120            }
20121            if let Some(_) = self.resolver {
20122                return 1;
20123            }
20124            0
20125        }
20126    }
20127
20128    impl fidl::encoding::ValueTypeMarker for ResolverRegistration {
20129        type Borrowed<'a> = &'a Self;
20130        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
20131            value
20132        }
20133    }
20134
20135    unsafe impl fidl::encoding::TypeMarker for ResolverRegistration {
20136        type Owned = Self;
20137
20138        #[inline(always)]
20139        fn inline_align(_context: fidl::encoding::Context) -> usize {
20140            8
20141        }
20142
20143        #[inline(always)]
20144        fn inline_size(_context: fidl::encoding::Context) -> usize {
20145            16
20146        }
20147    }
20148
20149    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ResolverRegistration, D>
20150        for &ResolverRegistration
20151    {
20152        unsafe fn encode(
20153            self,
20154            encoder: &mut fidl::encoding::Encoder<'_, D>,
20155            offset: usize,
20156            mut depth: fidl::encoding::Depth,
20157        ) -> fidl::Result<()> {
20158            encoder.debug_check_bounds::<ResolverRegistration>(offset);
20159            // Vector header
20160            let max_ordinal: u64 = self.max_ordinal_present();
20161            encoder.write_num(max_ordinal, offset);
20162            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
20163            // Calling encoder.out_of_line_offset(0) is not allowed.
20164            if max_ordinal == 0 {
20165                return Ok(());
20166            }
20167            depth.increment()?;
20168            let envelope_size = 8;
20169            let bytes_len = max_ordinal as usize * envelope_size;
20170            #[allow(unused_variables)]
20171            let offset = encoder.out_of_line_offset(bytes_len);
20172            let mut _prev_end_offset: usize = 0;
20173            if 1 > max_ordinal {
20174                return Ok(());
20175            }
20176
20177            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20178            // are envelope_size bytes.
20179            let cur_offset: usize = (1 - 1) * envelope_size;
20180
20181            // Zero reserved fields.
20182            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20183
20184            // Safety:
20185            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20186            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20187            //   envelope_size bytes, there is always sufficient room.
20188            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
20189                self.resolver.as_ref().map(
20190                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
20191                ),
20192                encoder,
20193                offset + cur_offset,
20194                depth,
20195            )?;
20196
20197            _prev_end_offset = cur_offset + envelope_size;
20198            if 2 > max_ordinal {
20199                return Ok(());
20200            }
20201
20202            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20203            // are envelope_size bytes.
20204            let cur_offset: usize = (2 - 1) * envelope_size;
20205
20206            // Zero reserved fields.
20207            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20208
20209            // Safety:
20210            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20211            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20212            //   envelope_size bytes, there is always sufficient room.
20213            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
20214                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
20215                encoder,
20216                offset + cur_offset,
20217                depth,
20218            )?;
20219
20220            _prev_end_offset = cur_offset + envelope_size;
20221            if 3 > max_ordinal {
20222                return Ok(());
20223            }
20224
20225            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20226            // are envelope_size bytes.
20227            let cur_offset: usize = (3 - 1) * envelope_size;
20228
20229            // Zero reserved fields.
20230            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20231
20232            // Safety:
20233            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20234            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20235            //   envelope_size bytes, there is always sufficient room.
20236            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
20237                self.scheme.as_ref().map(
20238                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
20239                ),
20240                encoder,
20241                offset + cur_offset,
20242                depth,
20243            )?;
20244
20245            _prev_end_offset = cur_offset + envelope_size;
20246
20247            Ok(())
20248        }
20249    }
20250
20251    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolverRegistration {
20252        #[inline(always)]
20253        fn new_empty() -> Self {
20254            Self::default()
20255        }
20256
20257        unsafe fn decode(
20258            &mut self,
20259            decoder: &mut fidl::encoding::Decoder<'_, D>,
20260            offset: usize,
20261            mut depth: fidl::encoding::Depth,
20262        ) -> fidl::Result<()> {
20263            decoder.debug_check_bounds::<Self>(offset);
20264            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
20265                None => return Err(fidl::Error::NotNullable),
20266                Some(len) => len,
20267            };
20268            // Calling decoder.out_of_line_offset(0) is not allowed.
20269            if len == 0 {
20270                return Ok(());
20271            };
20272            depth.increment()?;
20273            let envelope_size = 8;
20274            let bytes_len = len * envelope_size;
20275            let offset = decoder.out_of_line_offset(bytes_len)?;
20276            // Decode the envelope for each type.
20277            let mut _next_ordinal_to_read = 0;
20278            let mut next_offset = offset;
20279            let end_offset = offset + bytes_len;
20280            _next_ordinal_to_read += 1;
20281            if next_offset >= end_offset {
20282                return Ok(());
20283            }
20284
20285            // Decode unknown envelopes for gaps in ordinals.
20286            while _next_ordinal_to_read < 1 {
20287                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20288                _next_ordinal_to_read += 1;
20289                next_offset += envelope_size;
20290            }
20291
20292            let next_out_of_line = decoder.next_out_of_line();
20293            let handles_before = decoder.remaining_handles();
20294            if let Some((inlined, num_bytes, num_handles)) =
20295                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20296            {
20297                let member_inline_size =
20298                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
20299                        decoder.context,
20300                    );
20301                if inlined != (member_inline_size <= 4) {
20302                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20303                }
20304                let inner_offset;
20305                let mut inner_depth = depth.clone();
20306                if inlined {
20307                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20308                    inner_offset = next_offset;
20309                } else {
20310                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20311                    inner_depth.increment()?;
20312                }
20313                let val_ref = self
20314                    .resolver
20315                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
20316                fidl::decode!(
20317                    fidl::encoding::BoundedString<100>,
20318                    D,
20319                    val_ref,
20320                    decoder,
20321                    inner_offset,
20322                    inner_depth
20323                )?;
20324                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20325                {
20326                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20327                }
20328                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20329                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20330                }
20331            }
20332
20333            next_offset += envelope_size;
20334            _next_ordinal_to_read += 1;
20335            if next_offset >= end_offset {
20336                return Ok(());
20337            }
20338
20339            // Decode unknown envelopes for gaps in ordinals.
20340            while _next_ordinal_to_read < 2 {
20341                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20342                _next_ordinal_to_read += 1;
20343                next_offset += envelope_size;
20344            }
20345
20346            let next_out_of_line = decoder.next_out_of_line();
20347            let handles_before = decoder.remaining_handles();
20348            if let Some((inlined, num_bytes, num_handles)) =
20349                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20350            {
20351                let member_inline_size =
20352                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20353                if inlined != (member_inline_size <= 4) {
20354                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20355                }
20356                let inner_offset;
20357                let mut inner_depth = depth.clone();
20358                if inlined {
20359                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20360                    inner_offset = next_offset;
20361                } else {
20362                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20363                    inner_depth.increment()?;
20364                }
20365                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
20366                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
20367                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20368                {
20369                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20370                }
20371                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20372                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20373                }
20374            }
20375
20376            next_offset += envelope_size;
20377            _next_ordinal_to_read += 1;
20378            if next_offset >= end_offset {
20379                return Ok(());
20380            }
20381
20382            // Decode unknown envelopes for gaps in ordinals.
20383            while _next_ordinal_to_read < 3 {
20384                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20385                _next_ordinal_to_read += 1;
20386                next_offset += envelope_size;
20387            }
20388
20389            let next_out_of_line = decoder.next_out_of_line();
20390            let handles_before = decoder.remaining_handles();
20391            if let Some((inlined, num_bytes, num_handles)) =
20392                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20393            {
20394                let member_inline_size =
20395                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
20396                        decoder.context,
20397                    );
20398                if inlined != (member_inline_size <= 4) {
20399                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20400                }
20401                let inner_offset;
20402                let mut inner_depth = depth.clone();
20403                if inlined {
20404                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20405                    inner_offset = next_offset;
20406                } else {
20407                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20408                    inner_depth.increment()?;
20409                }
20410                let val_ref = self
20411                    .scheme
20412                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
20413                fidl::decode!(
20414                    fidl::encoding::BoundedString<100>,
20415                    D,
20416                    val_ref,
20417                    decoder,
20418                    inner_offset,
20419                    inner_depth
20420                )?;
20421                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20422                {
20423                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20424                }
20425                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20426                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20427                }
20428            }
20429
20430            next_offset += envelope_size;
20431
20432            // Decode the remaining unknown envelopes.
20433            while next_offset < end_offset {
20434                _next_ordinal_to_read += 1;
20435                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20436                next_offset += envelope_size;
20437            }
20438
20439            Ok(())
20440        }
20441    }
20442
20443    impl Runner {
20444        #[inline(always)]
20445        fn max_ordinal_present(&self) -> u64 {
20446            if let Some(_) = self.source_path {
20447                return 2;
20448            }
20449            if let Some(_) = self.name {
20450                return 1;
20451            }
20452            0
20453        }
20454    }
20455
20456    impl fidl::encoding::ValueTypeMarker for Runner {
20457        type Borrowed<'a> = &'a Self;
20458        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
20459            value
20460        }
20461    }
20462
20463    unsafe impl fidl::encoding::TypeMarker for Runner {
20464        type Owned = Self;
20465
20466        #[inline(always)]
20467        fn inline_align(_context: fidl::encoding::Context) -> usize {
20468            8
20469        }
20470
20471        #[inline(always)]
20472        fn inline_size(_context: fidl::encoding::Context) -> usize {
20473            16
20474        }
20475    }
20476
20477    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Runner, D> for &Runner {
20478        unsafe fn encode(
20479            self,
20480            encoder: &mut fidl::encoding::Encoder<'_, D>,
20481            offset: usize,
20482            mut depth: fidl::encoding::Depth,
20483        ) -> fidl::Result<()> {
20484            encoder.debug_check_bounds::<Runner>(offset);
20485            // Vector header
20486            let max_ordinal: u64 = self.max_ordinal_present();
20487            encoder.write_num(max_ordinal, offset);
20488            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
20489            // Calling encoder.out_of_line_offset(0) is not allowed.
20490            if max_ordinal == 0 {
20491                return Ok(());
20492            }
20493            depth.increment()?;
20494            let envelope_size = 8;
20495            let bytes_len = max_ordinal as usize * envelope_size;
20496            #[allow(unused_variables)]
20497            let offset = encoder.out_of_line_offset(bytes_len);
20498            let mut _prev_end_offset: usize = 0;
20499            if 1 > max_ordinal {
20500                return Ok(());
20501            }
20502
20503            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20504            // are envelope_size bytes.
20505            let cur_offset: usize = (1 - 1) * envelope_size;
20506
20507            // Zero reserved fields.
20508            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20509
20510            // Safety:
20511            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20512            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20513            //   envelope_size bytes, there is always sufficient room.
20514            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
20515                self.name.as_ref().map(
20516                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
20517                ),
20518                encoder,
20519                offset + cur_offset,
20520                depth,
20521            )?;
20522
20523            _prev_end_offset = cur_offset + envelope_size;
20524            if 2 > max_ordinal {
20525                return Ok(());
20526            }
20527
20528            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20529            // are envelope_size bytes.
20530            let cur_offset: usize = (2 - 1) * envelope_size;
20531
20532            // Zero reserved fields.
20533            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20534
20535            // Safety:
20536            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20537            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20538            //   envelope_size bytes, there is always sufficient room.
20539            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
20540            self.source_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
20541            encoder, offset + cur_offset, depth
20542        )?;
20543
20544            _prev_end_offset = cur_offset + envelope_size;
20545
20546            Ok(())
20547        }
20548    }
20549
20550    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Runner {
20551        #[inline(always)]
20552        fn new_empty() -> Self {
20553            Self::default()
20554        }
20555
20556        unsafe fn decode(
20557            &mut self,
20558            decoder: &mut fidl::encoding::Decoder<'_, D>,
20559            offset: usize,
20560            mut depth: fidl::encoding::Depth,
20561        ) -> fidl::Result<()> {
20562            decoder.debug_check_bounds::<Self>(offset);
20563            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
20564                None => return Err(fidl::Error::NotNullable),
20565                Some(len) => len,
20566            };
20567            // Calling decoder.out_of_line_offset(0) is not allowed.
20568            if len == 0 {
20569                return Ok(());
20570            };
20571            depth.increment()?;
20572            let envelope_size = 8;
20573            let bytes_len = len * envelope_size;
20574            let offset = decoder.out_of_line_offset(bytes_len)?;
20575            // Decode the envelope for each type.
20576            let mut _next_ordinal_to_read = 0;
20577            let mut next_offset = offset;
20578            let end_offset = offset + bytes_len;
20579            _next_ordinal_to_read += 1;
20580            if next_offset >= end_offset {
20581                return Ok(());
20582            }
20583
20584            // Decode unknown envelopes for gaps in ordinals.
20585            while _next_ordinal_to_read < 1 {
20586                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20587                _next_ordinal_to_read += 1;
20588                next_offset += envelope_size;
20589            }
20590
20591            let next_out_of_line = decoder.next_out_of_line();
20592            let handles_before = decoder.remaining_handles();
20593            if let Some((inlined, num_bytes, num_handles)) =
20594                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20595            {
20596                let member_inline_size =
20597                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
20598                        decoder.context,
20599                    );
20600                if inlined != (member_inline_size <= 4) {
20601                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20602                }
20603                let inner_offset;
20604                let mut inner_depth = depth.clone();
20605                if inlined {
20606                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20607                    inner_offset = next_offset;
20608                } else {
20609                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20610                    inner_depth.increment()?;
20611                }
20612                let val_ref = self
20613                    .name
20614                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
20615                fidl::decode!(
20616                    fidl::encoding::BoundedString<100>,
20617                    D,
20618                    val_ref,
20619                    decoder,
20620                    inner_offset,
20621                    inner_depth
20622                )?;
20623                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20624                {
20625                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20626                }
20627                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20628                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20629                }
20630            }
20631
20632            next_offset += envelope_size;
20633            _next_ordinal_to_read += 1;
20634            if next_offset >= end_offset {
20635                return Ok(());
20636            }
20637
20638            // Decode unknown envelopes for gaps in ordinals.
20639            while _next_ordinal_to_read < 2 {
20640                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20641                _next_ordinal_to_read += 1;
20642                next_offset += envelope_size;
20643            }
20644
20645            let next_out_of_line = decoder.next_out_of_line();
20646            let handles_before = decoder.remaining_handles();
20647            if let Some((inlined, num_bytes, num_handles)) =
20648                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20649            {
20650                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20651                if inlined != (member_inline_size <= 4) {
20652                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20653                }
20654                let inner_offset;
20655                let mut inner_depth = depth.clone();
20656                if inlined {
20657                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20658                    inner_offset = next_offset;
20659                } else {
20660                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20661                    inner_depth.increment()?;
20662                }
20663                let val_ref = self.source_path.get_or_insert_with(|| {
20664                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
20665                });
20666                fidl::decode!(
20667                    fidl::encoding::BoundedString<1024>,
20668                    D,
20669                    val_ref,
20670                    decoder,
20671                    inner_offset,
20672                    inner_depth
20673                )?;
20674                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20675                {
20676                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20677                }
20678                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20679                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20680                }
20681            }
20682
20683            next_offset += envelope_size;
20684
20685            // Decode the remaining unknown envelopes.
20686            while next_offset < end_offset {
20687                _next_ordinal_to_read += 1;
20688                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20689                next_offset += envelope_size;
20690            }
20691
20692            Ok(())
20693        }
20694    }
20695
20696    impl RunnerRegistration {
20697        #[inline(always)]
20698        fn max_ordinal_present(&self) -> u64 {
20699            if let Some(_) = self.target_name {
20700                return 3;
20701            }
20702            if let Some(_) = self.source {
20703                return 2;
20704            }
20705            if let Some(_) = self.source_name {
20706                return 1;
20707            }
20708            0
20709        }
20710    }
20711
20712    impl fidl::encoding::ValueTypeMarker for RunnerRegistration {
20713        type Borrowed<'a> = &'a Self;
20714        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
20715            value
20716        }
20717    }
20718
20719    unsafe impl fidl::encoding::TypeMarker for RunnerRegistration {
20720        type Owned = Self;
20721
20722        #[inline(always)]
20723        fn inline_align(_context: fidl::encoding::Context) -> usize {
20724            8
20725        }
20726
20727        #[inline(always)]
20728        fn inline_size(_context: fidl::encoding::Context) -> usize {
20729            16
20730        }
20731    }
20732
20733    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RunnerRegistration, D>
20734        for &RunnerRegistration
20735    {
20736        unsafe fn encode(
20737            self,
20738            encoder: &mut fidl::encoding::Encoder<'_, D>,
20739            offset: usize,
20740            mut depth: fidl::encoding::Depth,
20741        ) -> fidl::Result<()> {
20742            encoder.debug_check_bounds::<RunnerRegistration>(offset);
20743            // Vector header
20744            let max_ordinal: u64 = self.max_ordinal_present();
20745            encoder.write_num(max_ordinal, offset);
20746            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
20747            // Calling encoder.out_of_line_offset(0) is not allowed.
20748            if max_ordinal == 0 {
20749                return Ok(());
20750            }
20751            depth.increment()?;
20752            let envelope_size = 8;
20753            let bytes_len = max_ordinal as usize * envelope_size;
20754            #[allow(unused_variables)]
20755            let offset = encoder.out_of_line_offset(bytes_len);
20756            let mut _prev_end_offset: usize = 0;
20757            if 1 > max_ordinal {
20758                return Ok(());
20759            }
20760
20761            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20762            // are envelope_size bytes.
20763            let cur_offset: usize = (1 - 1) * envelope_size;
20764
20765            // Zero reserved fields.
20766            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20767
20768            // Safety:
20769            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20770            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20771            //   envelope_size bytes, there is always sufficient room.
20772            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
20773                self.source_name.as_ref().map(
20774                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
20775                ),
20776                encoder,
20777                offset + cur_offset,
20778                depth,
20779            )?;
20780
20781            _prev_end_offset = cur_offset + envelope_size;
20782            if 2 > max_ordinal {
20783                return Ok(());
20784            }
20785
20786            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20787            // are envelope_size bytes.
20788            let cur_offset: usize = (2 - 1) * envelope_size;
20789
20790            // Zero reserved fields.
20791            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20792
20793            // Safety:
20794            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20795            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20796            //   envelope_size bytes, there is always sufficient room.
20797            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
20798                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
20799                encoder,
20800                offset + cur_offset,
20801                depth,
20802            )?;
20803
20804            _prev_end_offset = cur_offset + envelope_size;
20805            if 3 > max_ordinal {
20806                return Ok(());
20807            }
20808
20809            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
20810            // are envelope_size bytes.
20811            let cur_offset: usize = (3 - 1) * envelope_size;
20812
20813            // Zero reserved fields.
20814            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
20815
20816            // Safety:
20817            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
20818            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
20819            //   envelope_size bytes, there is always sufficient room.
20820            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
20821                self.target_name.as_ref().map(
20822                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
20823                ),
20824                encoder,
20825                offset + cur_offset,
20826                depth,
20827            )?;
20828
20829            _prev_end_offset = cur_offset + envelope_size;
20830
20831            Ok(())
20832        }
20833    }
20834
20835    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RunnerRegistration {
20836        #[inline(always)]
20837        fn new_empty() -> Self {
20838            Self::default()
20839        }
20840
20841        unsafe fn decode(
20842            &mut self,
20843            decoder: &mut fidl::encoding::Decoder<'_, D>,
20844            offset: usize,
20845            mut depth: fidl::encoding::Depth,
20846        ) -> fidl::Result<()> {
20847            decoder.debug_check_bounds::<Self>(offset);
20848            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
20849                None => return Err(fidl::Error::NotNullable),
20850                Some(len) => len,
20851            };
20852            // Calling decoder.out_of_line_offset(0) is not allowed.
20853            if len == 0 {
20854                return Ok(());
20855            };
20856            depth.increment()?;
20857            let envelope_size = 8;
20858            let bytes_len = len * envelope_size;
20859            let offset = decoder.out_of_line_offset(bytes_len)?;
20860            // Decode the envelope for each type.
20861            let mut _next_ordinal_to_read = 0;
20862            let mut next_offset = offset;
20863            let end_offset = offset + bytes_len;
20864            _next_ordinal_to_read += 1;
20865            if next_offset >= end_offset {
20866                return Ok(());
20867            }
20868
20869            // Decode unknown envelopes for gaps in ordinals.
20870            while _next_ordinal_to_read < 1 {
20871                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20872                _next_ordinal_to_read += 1;
20873                next_offset += envelope_size;
20874            }
20875
20876            let next_out_of_line = decoder.next_out_of_line();
20877            let handles_before = decoder.remaining_handles();
20878            if let Some((inlined, num_bytes, num_handles)) =
20879                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20880            {
20881                let member_inline_size =
20882                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
20883                        decoder.context,
20884                    );
20885                if inlined != (member_inline_size <= 4) {
20886                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20887                }
20888                let inner_offset;
20889                let mut inner_depth = depth.clone();
20890                if inlined {
20891                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20892                    inner_offset = next_offset;
20893                } else {
20894                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20895                    inner_depth.increment()?;
20896                }
20897                let val_ref = self
20898                    .source_name
20899                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
20900                fidl::decode!(
20901                    fidl::encoding::BoundedString<100>,
20902                    D,
20903                    val_ref,
20904                    decoder,
20905                    inner_offset,
20906                    inner_depth
20907                )?;
20908                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20909                {
20910                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20911                }
20912                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20913                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20914                }
20915            }
20916
20917            next_offset += envelope_size;
20918            _next_ordinal_to_read += 1;
20919            if next_offset >= end_offset {
20920                return Ok(());
20921            }
20922
20923            // Decode unknown envelopes for gaps in ordinals.
20924            while _next_ordinal_to_read < 2 {
20925                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20926                _next_ordinal_to_read += 1;
20927                next_offset += envelope_size;
20928            }
20929
20930            let next_out_of_line = decoder.next_out_of_line();
20931            let handles_before = decoder.remaining_handles();
20932            if let Some((inlined, num_bytes, num_handles)) =
20933                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20934            {
20935                let member_inline_size =
20936                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
20937                if inlined != (member_inline_size <= 4) {
20938                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20939                }
20940                let inner_offset;
20941                let mut inner_depth = depth.clone();
20942                if inlined {
20943                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20944                    inner_offset = next_offset;
20945                } else {
20946                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20947                    inner_depth.increment()?;
20948                }
20949                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
20950                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
20951                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
20952                {
20953                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
20954                }
20955                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
20956                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
20957                }
20958            }
20959
20960            next_offset += envelope_size;
20961            _next_ordinal_to_read += 1;
20962            if next_offset >= end_offset {
20963                return Ok(());
20964            }
20965
20966            // Decode unknown envelopes for gaps in ordinals.
20967            while _next_ordinal_to_read < 3 {
20968                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
20969                _next_ordinal_to_read += 1;
20970                next_offset += envelope_size;
20971            }
20972
20973            let next_out_of_line = decoder.next_out_of_line();
20974            let handles_before = decoder.remaining_handles();
20975            if let Some((inlined, num_bytes, num_handles)) =
20976                fidl::encoding::decode_envelope_header(decoder, next_offset)?
20977            {
20978                let member_inline_size =
20979                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
20980                        decoder.context,
20981                    );
20982                if inlined != (member_inline_size <= 4) {
20983                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
20984                }
20985                let inner_offset;
20986                let mut inner_depth = depth.clone();
20987                if inlined {
20988                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
20989                    inner_offset = next_offset;
20990                } else {
20991                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
20992                    inner_depth.increment()?;
20993                }
20994                let val_ref = self
20995                    .target_name
20996                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
20997                fidl::decode!(
20998                    fidl::encoding::BoundedString<100>,
20999                    D,
21000                    val_ref,
21001                    decoder,
21002                    inner_offset,
21003                    inner_depth
21004                )?;
21005                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21006                {
21007                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21008                }
21009                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21010                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21011                }
21012            }
21013
21014            next_offset += envelope_size;
21015
21016            // Decode the remaining unknown envelopes.
21017            while next_offset < end_offset {
21018                _next_ordinal_to_read += 1;
21019                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21020                next_offset += envelope_size;
21021            }
21022
21023            Ok(())
21024        }
21025    }
21026
21027    impl Service {
21028        #[inline(always)]
21029        fn max_ordinal_present(&self) -> u64 {
21030            if let Some(_) = self.source_path {
21031                return 2;
21032            }
21033            if let Some(_) = self.name {
21034                return 1;
21035            }
21036            0
21037        }
21038    }
21039
21040    impl fidl::encoding::ValueTypeMarker for Service {
21041        type Borrowed<'a> = &'a Self;
21042        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21043            value
21044        }
21045    }
21046
21047    unsafe impl fidl::encoding::TypeMarker for Service {
21048        type Owned = Self;
21049
21050        #[inline(always)]
21051        fn inline_align(_context: fidl::encoding::Context) -> usize {
21052            8
21053        }
21054
21055        #[inline(always)]
21056        fn inline_size(_context: fidl::encoding::Context) -> usize {
21057            16
21058        }
21059    }
21060
21061    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Service, D> for &Service {
21062        unsafe fn encode(
21063            self,
21064            encoder: &mut fidl::encoding::Encoder<'_, D>,
21065            offset: usize,
21066            mut depth: fidl::encoding::Depth,
21067        ) -> fidl::Result<()> {
21068            encoder.debug_check_bounds::<Service>(offset);
21069            // Vector header
21070            let max_ordinal: u64 = self.max_ordinal_present();
21071            encoder.write_num(max_ordinal, offset);
21072            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21073            // Calling encoder.out_of_line_offset(0) is not allowed.
21074            if max_ordinal == 0 {
21075                return Ok(());
21076            }
21077            depth.increment()?;
21078            let envelope_size = 8;
21079            let bytes_len = max_ordinal as usize * envelope_size;
21080            #[allow(unused_variables)]
21081            let offset = encoder.out_of_line_offset(bytes_len);
21082            let mut _prev_end_offset: usize = 0;
21083            if 1 > max_ordinal {
21084                return Ok(());
21085            }
21086
21087            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21088            // are envelope_size bytes.
21089            let cur_offset: usize = (1 - 1) * envelope_size;
21090
21091            // Zero reserved fields.
21092            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21093
21094            // Safety:
21095            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21096            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21097            //   envelope_size bytes, there is always sufficient room.
21098            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
21099                self.name.as_ref().map(
21100                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
21101                ),
21102                encoder,
21103                offset + cur_offset,
21104                depth,
21105            )?;
21106
21107            _prev_end_offset = cur_offset + envelope_size;
21108            if 2 > max_ordinal {
21109                return Ok(());
21110            }
21111
21112            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21113            // are envelope_size bytes.
21114            let cur_offset: usize = (2 - 1) * envelope_size;
21115
21116            // Zero reserved fields.
21117            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21118
21119            // Safety:
21120            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21121            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21122            //   envelope_size bytes, there is always sufficient room.
21123            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
21124            self.source_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
21125            encoder, offset + cur_offset, depth
21126        )?;
21127
21128            _prev_end_offset = cur_offset + envelope_size;
21129
21130            Ok(())
21131        }
21132    }
21133
21134    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Service {
21135        #[inline(always)]
21136        fn new_empty() -> Self {
21137            Self::default()
21138        }
21139
21140        unsafe fn decode(
21141            &mut self,
21142            decoder: &mut fidl::encoding::Decoder<'_, D>,
21143            offset: usize,
21144            mut depth: fidl::encoding::Depth,
21145        ) -> fidl::Result<()> {
21146            decoder.debug_check_bounds::<Self>(offset);
21147            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
21148                None => return Err(fidl::Error::NotNullable),
21149                Some(len) => len,
21150            };
21151            // Calling decoder.out_of_line_offset(0) is not allowed.
21152            if len == 0 {
21153                return Ok(());
21154            };
21155            depth.increment()?;
21156            let envelope_size = 8;
21157            let bytes_len = len * envelope_size;
21158            let offset = decoder.out_of_line_offset(bytes_len)?;
21159            // Decode the envelope for each type.
21160            let mut _next_ordinal_to_read = 0;
21161            let mut next_offset = offset;
21162            let end_offset = offset + bytes_len;
21163            _next_ordinal_to_read += 1;
21164            if next_offset >= end_offset {
21165                return Ok(());
21166            }
21167
21168            // Decode unknown envelopes for gaps in ordinals.
21169            while _next_ordinal_to_read < 1 {
21170                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21171                _next_ordinal_to_read += 1;
21172                next_offset += envelope_size;
21173            }
21174
21175            let next_out_of_line = decoder.next_out_of_line();
21176            let handles_before = decoder.remaining_handles();
21177            if let Some((inlined, num_bytes, num_handles)) =
21178                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21179            {
21180                let member_inline_size =
21181                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
21182                        decoder.context,
21183                    );
21184                if inlined != (member_inline_size <= 4) {
21185                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21186                }
21187                let inner_offset;
21188                let mut inner_depth = depth.clone();
21189                if inlined {
21190                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21191                    inner_offset = next_offset;
21192                } else {
21193                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21194                    inner_depth.increment()?;
21195                }
21196                let val_ref = self
21197                    .name
21198                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
21199                fidl::decode!(
21200                    fidl::encoding::BoundedString<100>,
21201                    D,
21202                    val_ref,
21203                    decoder,
21204                    inner_offset,
21205                    inner_depth
21206                )?;
21207                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21208                {
21209                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21210                }
21211                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21212                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21213                }
21214            }
21215
21216            next_offset += envelope_size;
21217            _next_ordinal_to_read += 1;
21218            if next_offset >= end_offset {
21219                return Ok(());
21220            }
21221
21222            // Decode unknown envelopes for gaps in ordinals.
21223            while _next_ordinal_to_read < 2 {
21224                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21225                _next_ordinal_to_read += 1;
21226                next_offset += envelope_size;
21227            }
21228
21229            let next_out_of_line = decoder.next_out_of_line();
21230            let handles_before = decoder.remaining_handles();
21231            if let Some((inlined, num_bytes, num_handles)) =
21232                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21233            {
21234                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21235                if inlined != (member_inline_size <= 4) {
21236                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21237                }
21238                let inner_offset;
21239                let mut inner_depth = depth.clone();
21240                if inlined {
21241                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21242                    inner_offset = next_offset;
21243                } else {
21244                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21245                    inner_depth.increment()?;
21246                }
21247                let val_ref = self.source_path.get_or_insert_with(|| {
21248                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
21249                });
21250                fidl::decode!(
21251                    fidl::encoding::BoundedString<1024>,
21252                    D,
21253                    val_ref,
21254                    decoder,
21255                    inner_offset,
21256                    inner_depth
21257                )?;
21258                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21259                {
21260                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21261                }
21262                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21263                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21264                }
21265            }
21266
21267            next_offset += envelope_size;
21268
21269            // Decode the remaining unknown envelopes.
21270            while next_offset < end_offset {
21271                _next_ordinal_to_read += 1;
21272                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21273                next_offset += envelope_size;
21274            }
21275
21276            Ok(())
21277        }
21278    }
21279
21280    impl Storage {
21281        #[inline(always)]
21282        fn max_ordinal_present(&self) -> u64 {
21283            if let Some(_) = self.storage_id {
21284                return 5;
21285            }
21286            if let Some(_) = self.subdir {
21287                return 4;
21288            }
21289            if let Some(_) = self.backing_dir {
21290                return 3;
21291            }
21292            if let Some(_) = self.source {
21293                return 2;
21294            }
21295            if let Some(_) = self.name {
21296                return 1;
21297            }
21298            0
21299        }
21300    }
21301
21302    impl fidl::encoding::ValueTypeMarker for Storage {
21303        type Borrowed<'a> = &'a Self;
21304        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21305            value
21306        }
21307    }
21308
21309    unsafe impl fidl::encoding::TypeMarker for Storage {
21310        type Owned = Self;
21311
21312        #[inline(always)]
21313        fn inline_align(_context: fidl::encoding::Context) -> usize {
21314            8
21315        }
21316
21317        #[inline(always)]
21318        fn inline_size(_context: fidl::encoding::Context) -> usize {
21319            16
21320        }
21321    }
21322
21323    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Storage, D> for &Storage {
21324        unsafe fn encode(
21325            self,
21326            encoder: &mut fidl::encoding::Encoder<'_, D>,
21327            offset: usize,
21328            mut depth: fidl::encoding::Depth,
21329        ) -> fidl::Result<()> {
21330            encoder.debug_check_bounds::<Storage>(offset);
21331            // Vector header
21332            let max_ordinal: u64 = self.max_ordinal_present();
21333            encoder.write_num(max_ordinal, offset);
21334            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21335            // Calling encoder.out_of_line_offset(0) is not allowed.
21336            if max_ordinal == 0 {
21337                return Ok(());
21338            }
21339            depth.increment()?;
21340            let envelope_size = 8;
21341            let bytes_len = max_ordinal as usize * envelope_size;
21342            #[allow(unused_variables)]
21343            let offset = encoder.out_of_line_offset(bytes_len);
21344            let mut _prev_end_offset: usize = 0;
21345            if 1 > max_ordinal {
21346                return Ok(());
21347            }
21348
21349            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21350            // are envelope_size bytes.
21351            let cur_offset: usize = (1 - 1) * envelope_size;
21352
21353            // Zero reserved fields.
21354            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21355
21356            // Safety:
21357            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21358            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21359            //   envelope_size bytes, there is always sufficient room.
21360            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
21361                self.name.as_ref().map(
21362                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
21363                ),
21364                encoder,
21365                offset + cur_offset,
21366                depth,
21367            )?;
21368
21369            _prev_end_offset = cur_offset + envelope_size;
21370            if 2 > max_ordinal {
21371                return Ok(());
21372            }
21373
21374            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21375            // are envelope_size bytes.
21376            let cur_offset: usize = (2 - 1) * envelope_size;
21377
21378            // Zero reserved fields.
21379            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21380
21381            // Safety:
21382            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21383            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21384            //   envelope_size bytes, there is always sufficient room.
21385            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
21386                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
21387                encoder,
21388                offset + cur_offset,
21389                depth,
21390            )?;
21391
21392            _prev_end_offset = cur_offset + envelope_size;
21393            if 3 > max_ordinal {
21394                return Ok(());
21395            }
21396
21397            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21398            // are envelope_size bytes.
21399            let cur_offset: usize = (3 - 1) * envelope_size;
21400
21401            // Zero reserved fields.
21402            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21403
21404            // Safety:
21405            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21406            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21407            //   envelope_size bytes, there is always sufficient room.
21408            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
21409                self.backing_dir.as_ref().map(
21410                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
21411                ),
21412                encoder,
21413                offset + cur_offset,
21414                depth,
21415            )?;
21416
21417            _prev_end_offset = cur_offset + envelope_size;
21418            if 4 > max_ordinal {
21419                return Ok(());
21420            }
21421
21422            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21423            // are envelope_size bytes.
21424            let cur_offset: usize = (4 - 1) * envelope_size;
21425
21426            // Zero reserved fields.
21427            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21428
21429            // Safety:
21430            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21431            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21432            //   envelope_size bytes, there is always sufficient room.
21433            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
21434            self.subdir.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
21435            encoder, offset + cur_offset, depth
21436        )?;
21437
21438            _prev_end_offset = cur_offset + envelope_size;
21439            if 5 > max_ordinal {
21440                return Ok(());
21441            }
21442
21443            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21444            // are envelope_size bytes.
21445            let cur_offset: usize = (5 - 1) * envelope_size;
21446
21447            // Zero reserved fields.
21448            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21449
21450            // Safety:
21451            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21452            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21453            //   envelope_size bytes, there is always sufficient room.
21454            fidl::encoding::encode_in_envelope_optional::<StorageId, D>(
21455                self.storage_id
21456                    .as_ref()
21457                    .map(<StorageId as fidl::encoding::ValueTypeMarker>::borrow),
21458                encoder,
21459                offset + cur_offset,
21460                depth,
21461            )?;
21462
21463            _prev_end_offset = cur_offset + envelope_size;
21464
21465            Ok(())
21466        }
21467    }
21468
21469    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Storage {
21470        #[inline(always)]
21471        fn new_empty() -> Self {
21472            Self::default()
21473        }
21474
21475        unsafe fn decode(
21476            &mut self,
21477            decoder: &mut fidl::encoding::Decoder<'_, D>,
21478            offset: usize,
21479            mut depth: fidl::encoding::Depth,
21480        ) -> fidl::Result<()> {
21481            decoder.debug_check_bounds::<Self>(offset);
21482            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
21483                None => return Err(fidl::Error::NotNullable),
21484                Some(len) => len,
21485            };
21486            // Calling decoder.out_of_line_offset(0) is not allowed.
21487            if len == 0 {
21488                return Ok(());
21489            };
21490            depth.increment()?;
21491            let envelope_size = 8;
21492            let bytes_len = len * envelope_size;
21493            let offset = decoder.out_of_line_offset(bytes_len)?;
21494            // Decode the envelope for each type.
21495            let mut _next_ordinal_to_read = 0;
21496            let mut next_offset = offset;
21497            let end_offset = offset + bytes_len;
21498            _next_ordinal_to_read += 1;
21499            if next_offset >= end_offset {
21500                return Ok(());
21501            }
21502
21503            // Decode unknown envelopes for gaps in ordinals.
21504            while _next_ordinal_to_read < 1 {
21505                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21506                _next_ordinal_to_read += 1;
21507                next_offset += envelope_size;
21508            }
21509
21510            let next_out_of_line = decoder.next_out_of_line();
21511            let handles_before = decoder.remaining_handles();
21512            if let Some((inlined, num_bytes, num_handles)) =
21513                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21514            {
21515                let member_inline_size =
21516                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
21517                        decoder.context,
21518                    );
21519                if inlined != (member_inline_size <= 4) {
21520                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21521                }
21522                let inner_offset;
21523                let mut inner_depth = depth.clone();
21524                if inlined {
21525                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21526                    inner_offset = next_offset;
21527                } else {
21528                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21529                    inner_depth.increment()?;
21530                }
21531                let val_ref = self
21532                    .name
21533                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
21534                fidl::decode!(
21535                    fidl::encoding::BoundedString<100>,
21536                    D,
21537                    val_ref,
21538                    decoder,
21539                    inner_offset,
21540                    inner_depth
21541                )?;
21542                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21543                {
21544                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21545                }
21546                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21547                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21548                }
21549            }
21550
21551            next_offset += envelope_size;
21552            _next_ordinal_to_read += 1;
21553            if next_offset >= end_offset {
21554                return Ok(());
21555            }
21556
21557            // Decode unknown envelopes for gaps in ordinals.
21558            while _next_ordinal_to_read < 2 {
21559                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21560                _next_ordinal_to_read += 1;
21561                next_offset += envelope_size;
21562            }
21563
21564            let next_out_of_line = decoder.next_out_of_line();
21565            let handles_before = decoder.remaining_handles();
21566            if let Some((inlined, num_bytes, num_handles)) =
21567                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21568            {
21569                let member_inline_size =
21570                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21571                if inlined != (member_inline_size <= 4) {
21572                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21573                }
21574                let inner_offset;
21575                let mut inner_depth = depth.clone();
21576                if inlined {
21577                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21578                    inner_offset = next_offset;
21579                } else {
21580                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21581                    inner_depth.increment()?;
21582                }
21583                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
21584                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
21585                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21586                {
21587                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21588                }
21589                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21590                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21591                }
21592            }
21593
21594            next_offset += envelope_size;
21595            _next_ordinal_to_read += 1;
21596            if next_offset >= end_offset {
21597                return Ok(());
21598            }
21599
21600            // Decode unknown envelopes for gaps in ordinals.
21601            while _next_ordinal_to_read < 3 {
21602                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21603                _next_ordinal_to_read += 1;
21604                next_offset += envelope_size;
21605            }
21606
21607            let next_out_of_line = decoder.next_out_of_line();
21608            let handles_before = decoder.remaining_handles();
21609            if let Some((inlined, num_bytes, num_handles)) =
21610                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21611            {
21612                let member_inline_size =
21613                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
21614                        decoder.context,
21615                    );
21616                if inlined != (member_inline_size <= 4) {
21617                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21618                }
21619                let inner_offset;
21620                let mut inner_depth = depth.clone();
21621                if inlined {
21622                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21623                    inner_offset = next_offset;
21624                } else {
21625                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21626                    inner_depth.increment()?;
21627                }
21628                let val_ref = self
21629                    .backing_dir
21630                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
21631                fidl::decode!(
21632                    fidl::encoding::BoundedString<100>,
21633                    D,
21634                    val_ref,
21635                    decoder,
21636                    inner_offset,
21637                    inner_depth
21638                )?;
21639                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21640                {
21641                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21642                }
21643                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21644                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21645                }
21646            }
21647
21648            next_offset += envelope_size;
21649            _next_ordinal_to_read += 1;
21650            if next_offset >= end_offset {
21651                return Ok(());
21652            }
21653
21654            // Decode unknown envelopes for gaps in ordinals.
21655            while _next_ordinal_to_read < 4 {
21656                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21657                _next_ordinal_to_read += 1;
21658                next_offset += envelope_size;
21659            }
21660
21661            let next_out_of_line = decoder.next_out_of_line();
21662            let handles_before = decoder.remaining_handles();
21663            if let Some((inlined, num_bytes, num_handles)) =
21664                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21665            {
21666                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21667                if inlined != (member_inline_size <= 4) {
21668                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21669                }
21670                let inner_offset;
21671                let mut inner_depth = depth.clone();
21672                if inlined {
21673                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21674                    inner_offset = next_offset;
21675                } else {
21676                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21677                    inner_depth.increment()?;
21678                }
21679                let val_ref = self.subdir.get_or_insert_with(|| {
21680                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
21681                });
21682                fidl::decode!(
21683                    fidl::encoding::BoundedString<1024>,
21684                    D,
21685                    val_ref,
21686                    decoder,
21687                    inner_offset,
21688                    inner_depth
21689                )?;
21690                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21691                {
21692                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21693                }
21694                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21695                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21696                }
21697            }
21698
21699            next_offset += envelope_size;
21700            _next_ordinal_to_read += 1;
21701            if next_offset >= end_offset {
21702                return Ok(());
21703            }
21704
21705            // Decode unknown envelopes for gaps in ordinals.
21706            while _next_ordinal_to_read < 5 {
21707                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21708                _next_ordinal_to_read += 1;
21709                next_offset += envelope_size;
21710            }
21711
21712            let next_out_of_line = decoder.next_out_of_line();
21713            let handles_before = decoder.remaining_handles();
21714            if let Some((inlined, num_bytes, num_handles)) =
21715                fidl::encoding::decode_envelope_header(decoder, next_offset)?
21716            {
21717                let member_inline_size =
21718                    <StorageId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
21719                if inlined != (member_inline_size <= 4) {
21720                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
21721                }
21722                let inner_offset;
21723                let mut inner_depth = depth.clone();
21724                if inlined {
21725                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
21726                    inner_offset = next_offset;
21727                } else {
21728                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
21729                    inner_depth.increment()?;
21730                }
21731                let val_ref = self.storage_id.get_or_insert_with(|| fidl::new_empty!(StorageId, D));
21732                fidl::decode!(StorageId, D, val_ref, decoder, inner_offset, inner_depth)?;
21733                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
21734                {
21735                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
21736                }
21737                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
21738                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
21739                }
21740            }
21741
21742            next_offset += envelope_size;
21743
21744            // Decode the remaining unknown envelopes.
21745            while next_offset < end_offset {
21746                _next_ordinal_to_read += 1;
21747                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
21748                next_offset += envelope_size;
21749            }
21750
21751            Ok(())
21752        }
21753    }
21754
21755    impl UseConfiguration {
21756        #[inline(always)]
21757        fn max_ordinal_present(&self) -> u64 {
21758            if let Some(_) = self.source_dictionary {
21759                return 7;
21760            }
21761            if let Some(_) = self.default {
21762                return 6;
21763            }
21764            if let Some(_) = self.type_ {
21765                return 5;
21766            }
21767            if let Some(_) = self.availability {
21768                return 4;
21769            }
21770            if let Some(_) = self.target_name {
21771                return 3;
21772            }
21773            if let Some(_) = self.source_name {
21774                return 2;
21775            }
21776            if let Some(_) = self.source {
21777                return 1;
21778            }
21779            0
21780        }
21781    }
21782
21783    impl fidl::encoding::ValueTypeMarker for UseConfiguration {
21784        type Borrowed<'a> = &'a Self;
21785        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
21786            value
21787        }
21788    }
21789
21790    unsafe impl fidl::encoding::TypeMarker for UseConfiguration {
21791        type Owned = Self;
21792
21793        #[inline(always)]
21794        fn inline_align(_context: fidl::encoding::Context) -> usize {
21795            8
21796        }
21797
21798        #[inline(always)]
21799        fn inline_size(_context: fidl::encoding::Context) -> usize {
21800            16
21801        }
21802    }
21803
21804    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UseConfiguration, D>
21805        for &UseConfiguration
21806    {
21807        unsafe fn encode(
21808            self,
21809            encoder: &mut fidl::encoding::Encoder<'_, D>,
21810            offset: usize,
21811            mut depth: fidl::encoding::Depth,
21812        ) -> fidl::Result<()> {
21813            encoder.debug_check_bounds::<UseConfiguration>(offset);
21814            // Vector header
21815            let max_ordinal: u64 = self.max_ordinal_present();
21816            encoder.write_num(max_ordinal, offset);
21817            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
21818            // Calling encoder.out_of_line_offset(0) is not allowed.
21819            if max_ordinal == 0 {
21820                return Ok(());
21821            }
21822            depth.increment()?;
21823            let envelope_size = 8;
21824            let bytes_len = max_ordinal as usize * envelope_size;
21825            #[allow(unused_variables)]
21826            let offset = encoder.out_of_line_offset(bytes_len);
21827            let mut _prev_end_offset: usize = 0;
21828            if 1 > max_ordinal {
21829                return Ok(());
21830            }
21831
21832            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21833            // are envelope_size bytes.
21834            let cur_offset: usize = (1 - 1) * envelope_size;
21835
21836            // Zero reserved fields.
21837            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21838
21839            // Safety:
21840            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21841            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21842            //   envelope_size bytes, there is always sufficient room.
21843            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
21844                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
21845                encoder,
21846                offset + cur_offset,
21847                depth,
21848            )?;
21849
21850            _prev_end_offset = cur_offset + envelope_size;
21851            if 2 > max_ordinal {
21852                return Ok(());
21853            }
21854
21855            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21856            // are envelope_size bytes.
21857            let cur_offset: usize = (2 - 1) * envelope_size;
21858
21859            // Zero reserved fields.
21860            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21861
21862            // Safety:
21863            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21864            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21865            //   envelope_size bytes, there is always sufficient room.
21866            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
21867                self.source_name.as_ref().map(
21868                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
21869                ),
21870                encoder,
21871                offset + cur_offset,
21872                depth,
21873            )?;
21874
21875            _prev_end_offset = cur_offset + envelope_size;
21876            if 3 > max_ordinal {
21877                return Ok(());
21878            }
21879
21880            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21881            // are envelope_size bytes.
21882            let cur_offset: usize = (3 - 1) * envelope_size;
21883
21884            // Zero reserved fields.
21885            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21886
21887            // Safety:
21888            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21889            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21890            //   envelope_size bytes, there is always sufficient room.
21891            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
21892                self.target_name.as_ref().map(
21893                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
21894                ),
21895                encoder,
21896                offset + cur_offset,
21897                depth,
21898            )?;
21899
21900            _prev_end_offset = cur_offset + envelope_size;
21901            if 4 > max_ordinal {
21902                return Ok(());
21903            }
21904
21905            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21906            // are envelope_size bytes.
21907            let cur_offset: usize = (4 - 1) * envelope_size;
21908
21909            // Zero reserved fields.
21910            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21911
21912            // Safety:
21913            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21914            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21915            //   envelope_size bytes, there is always sufficient room.
21916            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
21917                self.availability
21918                    .as_ref()
21919                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
21920                encoder,
21921                offset + cur_offset,
21922                depth,
21923            )?;
21924
21925            _prev_end_offset = cur_offset + envelope_size;
21926            if 5 > max_ordinal {
21927                return Ok(());
21928            }
21929
21930            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21931            // are envelope_size bytes.
21932            let cur_offset: usize = (5 - 1) * envelope_size;
21933
21934            // Zero reserved fields.
21935            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21936
21937            // Safety:
21938            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21939            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21940            //   envelope_size bytes, there is always sufficient room.
21941            fidl::encoding::encode_in_envelope_optional::<ConfigType, D>(
21942                self.type_.as_ref().map(<ConfigType as fidl::encoding::ValueTypeMarker>::borrow),
21943                encoder,
21944                offset + cur_offset,
21945                depth,
21946            )?;
21947
21948            _prev_end_offset = cur_offset + envelope_size;
21949            if 6 > max_ordinal {
21950                return Ok(());
21951            }
21952
21953            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21954            // are envelope_size bytes.
21955            let cur_offset: usize = (6 - 1) * envelope_size;
21956
21957            // Zero reserved fields.
21958            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21959
21960            // Safety:
21961            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21962            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21963            //   envelope_size bytes, there is always sufficient room.
21964            fidl::encoding::encode_in_envelope_optional::<ConfigValue, D>(
21965                self.default.as_ref().map(<ConfigValue as fidl::encoding::ValueTypeMarker>::borrow),
21966                encoder,
21967                offset + cur_offset,
21968                depth,
21969            )?;
21970
21971            _prev_end_offset = cur_offset + envelope_size;
21972            if 7 > max_ordinal {
21973                return Ok(());
21974            }
21975
21976            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
21977            // are envelope_size bytes.
21978            let cur_offset: usize = (7 - 1) * envelope_size;
21979
21980            // Zero reserved fields.
21981            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
21982
21983            // Safety:
21984            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
21985            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
21986            //   envelope_size bytes, there is always sufficient room.
21987            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
21988            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
21989            encoder, offset + cur_offset, depth
21990        )?;
21991
21992            _prev_end_offset = cur_offset + envelope_size;
21993
21994            Ok(())
21995        }
21996    }
21997
21998    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UseConfiguration {
21999        #[inline(always)]
22000        fn new_empty() -> Self {
22001            Self::default()
22002        }
22003
22004        unsafe fn decode(
22005            &mut self,
22006            decoder: &mut fidl::encoding::Decoder<'_, D>,
22007            offset: usize,
22008            mut depth: fidl::encoding::Depth,
22009        ) -> fidl::Result<()> {
22010            decoder.debug_check_bounds::<Self>(offset);
22011            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22012                None => return Err(fidl::Error::NotNullable),
22013                Some(len) => len,
22014            };
22015            // Calling decoder.out_of_line_offset(0) is not allowed.
22016            if len == 0 {
22017                return Ok(());
22018            };
22019            depth.increment()?;
22020            let envelope_size = 8;
22021            let bytes_len = len * envelope_size;
22022            let offset = decoder.out_of_line_offset(bytes_len)?;
22023            // Decode the envelope for each type.
22024            let mut _next_ordinal_to_read = 0;
22025            let mut next_offset = offset;
22026            let end_offset = offset + bytes_len;
22027            _next_ordinal_to_read += 1;
22028            if next_offset >= end_offset {
22029                return Ok(());
22030            }
22031
22032            // Decode unknown envelopes for gaps in ordinals.
22033            while _next_ordinal_to_read < 1 {
22034                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22035                _next_ordinal_to_read += 1;
22036                next_offset += envelope_size;
22037            }
22038
22039            let next_out_of_line = decoder.next_out_of_line();
22040            let handles_before = decoder.remaining_handles();
22041            if let Some((inlined, num_bytes, num_handles)) =
22042                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22043            {
22044                let member_inline_size =
22045                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22046                if inlined != (member_inline_size <= 4) {
22047                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22048                }
22049                let inner_offset;
22050                let mut inner_depth = depth.clone();
22051                if inlined {
22052                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22053                    inner_offset = next_offset;
22054                } else {
22055                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22056                    inner_depth.increment()?;
22057                }
22058                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
22059                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
22060                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22061                {
22062                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22063                }
22064                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22065                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22066                }
22067            }
22068
22069            next_offset += envelope_size;
22070            _next_ordinal_to_read += 1;
22071            if next_offset >= end_offset {
22072                return Ok(());
22073            }
22074
22075            // Decode unknown envelopes for gaps in ordinals.
22076            while _next_ordinal_to_read < 2 {
22077                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22078                _next_ordinal_to_read += 1;
22079                next_offset += envelope_size;
22080            }
22081
22082            let next_out_of_line = decoder.next_out_of_line();
22083            let handles_before = decoder.remaining_handles();
22084            if let Some((inlined, num_bytes, num_handles)) =
22085                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22086            {
22087                let member_inline_size =
22088                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
22089                        decoder.context,
22090                    );
22091                if inlined != (member_inline_size <= 4) {
22092                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22093                }
22094                let inner_offset;
22095                let mut inner_depth = depth.clone();
22096                if inlined {
22097                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22098                    inner_offset = next_offset;
22099                } else {
22100                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22101                    inner_depth.increment()?;
22102                }
22103                let val_ref = self
22104                    .source_name
22105                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
22106                fidl::decode!(
22107                    fidl::encoding::BoundedString<100>,
22108                    D,
22109                    val_ref,
22110                    decoder,
22111                    inner_offset,
22112                    inner_depth
22113                )?;
22114                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22115                {
22116                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22117                }
22118                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22119                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22120                }
22121            }
22122
22123            next_offset += envelope_size;
22124            _next_ordinal_to_read += 1;
22125            if next_offset >= end_offset {
22126                return Ok(());
22127            }
22128
22129            // Decode unknown envelopes for gaps in ordinals.
22130            while _next_ordinal_to_read < 3 {
22131                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22132                _next_ordinal_to_read += 1;
22133                next_offset += envelope_size;
22134            }
22135
22136            let next_out_of_line = decoder.next_out_of_line();
22137            let handles_before = decoder.remaining_handles();
22138            if let Some((inlined, num_bytes, num_handles)) =
22139                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22140            {
22141                let member_inline_size =
22142                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
22143                        decoder.context,
22144                    );
22145                if inlined != (member_inline_size <= 4) {
22146                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22147                }
22148                let inner_offset;
22149                let mut inner_depth = depth.clone();
22150                if inlined {
22151                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22152                    inner_offset = next_offset;
22153                } else {
22154                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22155                    inner_depth.increment()?;
22156                }
22157                let val_ref = self
22158                    .target_name
22159                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
22160                fidl::decode!(
22161                    fidl::encoding::BoundedString<100>,
22162                    D,
22163                    val_ref,
22164                    decoder,
22165                    inner_offset,
22166                    inner_depth
22167                )?;
22168                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22169                {
22170                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22171                }
22172                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22173                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22174                }
22175            }
22176
22177            next_offset += envelope_size;
22178            _next_ordinal_to_read += 1;
22179            if next_offset >= end_offset {
22180                return Ok(());
22181            }
22182
22183            // Decode unknown envelopes for gaps in ordinals.
22184            while _next_ordinal_to_read < 4 {
22185                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22186                _next_ordinal_to_read += 1;
22187                next_offset += envelope_size;
22188            }
22189
22190            let next_out_of_line = decoder.next_out_of_line();
22191            let handles_before = decoder.remaining_handles();
22192            if let Some((inlined, num_bytes, num_handles)) =
22193                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22194            {
22195                let member_inline_size =
22196                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22197                if inlined != (member_inline_size <= 4) {
22198                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22199                }
22200                let inner_offset;
22201                let mut inner_depth = depth.clone();
22202                if inlined {
22203                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22204                    inner_offset = next_offset;
22205                } else {
22206                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22207                    inner_depth.increment()?;
22208                }
22209                let val_ref =
22210                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
22211                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
22212                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22213                {
22214                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22215                }
22216                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22217                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22218                }
22219            }
22220
22221            next_offset += envelope_size;
22222            _next_ordinal_to_read += 1;
22223            if next_offset >= end_offset {
22224                return Ok(());
22225            }
22226
22227            // Decode unknown envelopes for gaps in ordinals.
22228            while _next_ordinal_to_read < 5 {
22229                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22230                _next_ordinal_to_read += 1;
22231                next_offset += envelope_size;
22232            }
22233
22234            let next_out_of_line = decoder.next_out_of_line();
22235            let handles_before = decoder.remaining_handles();
22236            if let Some((inlined, num_bytes, num_handles)) =
22237                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22238            {
22239                let member_inline_size =
22240                    <ConfigType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22241                if inlined != (member_inline_size <= 4) {
22242                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22243                }
22244                let inner_offset;
22245                let mut inner_depth = depth.clone();
22246                if inlined {
22247                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22248                    inner_offset = next_offset;
22249                } else {
22250                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22251                    inner_depth.increment()?;
22252                }
22253                let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(ConfigType, D));
22254                fidl::decode!(ConfigType, D, val_ref, decoder, inner_offset, inner_depth)?;
22255                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22256                {
22257                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22258                }
22259                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22260                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22261                }
22262            }
22263
22264            next_offset += envelope_size;
22265            _next_ordinal_to_read += 1;
22266            if next_offset >= end_offset {
22267                return Ok(());
22268            }
22269
22270            // Decode unknown envelopes for gaps in ordinals.
22271            while _next_ordinal_to_read < 6 {
22272                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22273                _next_ordinal_to_read += 1;
22274                next_offset += envelope_size;
22275            }
22276
22277            let next_out_of_line = decoder.next_out_of_line();
22278            let handles_before = decoder.remaining_handles();
22279            if let Some((inlined, num_bytes, num_handles)) =
22280                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22281            {
22282                let member_inline_size =
22283                    <ConfigValue as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22284                if inlined != (member_inline_size <= 4) {
22285                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22286                }
22287                let inner_offset;
22288                let mut inner_depth = depth.clone();
22289                if inlined {
22290                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22291                    inner_offset = next_offset;
22292                } else {
22293                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22294                    inner_depth.increment()?;
22295                }
22296                let val_ref = self.default.get_or_insert_with(|| fidl::new_empty!(ConfigValue, D));
22297                fidl::decode!(ConfigValue, D, val_ref, decoder, inner_offset, inner_depth)?;
22298                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22299                {
22300                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22301                }
22302                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22303                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22304                }
22305            }
22306
22307            next_offset += envelope_size;
22308            _next_ordinal_to_read += 1;
22309            if next_offset >= end_offset {
22310                return Ok(());
22311            }
22312
22313            // Decode unknown envelopes for gaps in ordinals.
22314            while _next_ordinal_to_read < 7 {
22315                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22316                _next_ordinal_to_read += 1;
22317                next_offset += envelope_size;
22318            }
22319
22320            let next_out_of_line = decoder.next_out_of_line();
22321            let handles_before = decoder.remaining_handles();
22322            if let Some((inlined, num_bytes, num_handles)) =
22323                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22324            {
22325                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22326                if inlined != (member_inline_size <= 4) {
22327                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22328                }
22329                let inner_offset;
22330                let mut inner_depth = depth.clone();
22331                if inlined {
22332                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22333                    inner_offset = next_offset;
22334                } else {
22335                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22336                    inner_depth.increment()?;
22337                }
22338                let val_ref = self.source_dictionary.get_or_insert_with(|| {
22339                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
22340                });
22341                fidl::decode!(
22342                    fidl::encoding::BoundedString<1024>,
22343                    D,
22344                    val_ref,
22345                    decoder,
22346                    inner_offset,
22347                    inner_depth
22348                )?;
22349                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22350                {
22351                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22352                }
22353                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22354                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22355                }
22356            }
22357
22358            next_offset += envelope_size;
22359
22360            // Decode the remaining unknown envelopes.
22361            while next_offset < end_offset {
22362                _next_ordinal_to_read += 1;
22363                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22364                next_offset += envelope_size;
22365            }
22366
22367            Ok(())
22368        }
22369    }
22370
22371    impl UseDirectory {
22372        #[inline(always)]
22373        fn max_ordinal_present(&self) -> u64 {
22374            if let Some(_) = self.source_dictionary {
22375                return 8;
22376            }
22377            if let Some(_) = self.availability {
22378                return 7;
22379            }
22380            if let Some(_) = self.dependency_type {
22381                return 6;
22382            }
22383            if let Some(_) = self.subdir {
22384                return 5;
22385            }
22386            if let Some(_) = self.rights {
22387                return 4;
22388            }
22389            if let Some(_) = self.target_path {
22390                return 3;
22391            }
22392            if let Some(_) = self.source_name {
22393                return 2;
22394            }
22395            if let Some(_) = self.source {
22396                return 1;
22397            }
22398            0
22399        }
22400    }
22401
22402    impl fidl::encoding::ValueTypeMarker for UseDirectory {
22403        type Borrowed<'a> = &'a Self;
22404        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
22405            value
22406        }
22407    }
22408
22409    unsafe impl fidl::encoding::TypeMarker for UseDirectory {
22410        type Owned = Self;
22411
22412        #[inline(always)]
22413        fn inline_align(_context: fidl::encoding::Context) -> usize {
22414            8
22415        }
22416
22417        #[inline(always)]
22418        fn inline_size(_context: fidl::encoding::Context) -> usize {
22419            16
22420        }
22421    }
22422
22423    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UseDirectory, D>
22424        for &UseDirectory
22425    {
22426        unsafe fn encode(
22427            self,
22428            encoder: &mut fidl::encoding::Encoder<'_, D>,
22429            offset: usize,
22430            mut depth: fidl::encoding::Depth,
22431        ) -> fidl::Result<()> {
22432            encoder.debug_check_bounds::<UseDirectory>(offset);
22433            // Vector header
22434            let max_ordinal: u64 = self.max_ordinal_present();
22435            encoder.write_num(max_ordinal, offset);
22436            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
22437            // Calling encoder.out_of_line_offset(0) is not allowed.
22438            if max_ordinal == 0 {
22439                return Ok(());
22440            }
22441            depth.increment()?;
22442            let envelope_size = 8;
22443            let bytes_len = max_ordinal as usize * envelope_size;
22444            #[allow(unused_variables)]
22445            let offset = encoder.out_of_line_offset(bytes_len);
22446            let mut _prev_end_offset: usize = 0;
22447            if 1 > max_ordinal {
22448                return Ok(());
22449            }
22450
22451            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
22452            // are envelope_size bytes.
22453            let cur_offset: usize = (1 - 1) * envelope_size;
22454
22455            // Zero reserved fields.
22456            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22457
22458            // Safety:
22459            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
22460            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
22461            //   envelope_size bytes, there is always sufficient room.
22462            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
22463                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
22464                encoder,
22465                offset + cur_offset,
22466                depth,
22467            )?;
22468
22469            _prev_end_offset = cur_offset + envelope_size;
22470            if 2 > max_ordinal {
22471                return Ok(());
22472            }
22473
22474            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
22475            // are envelope_size bytes.
22476            let cur_offset: usize = (2 - 1) * envelope_size;
22477
22478            // Zero reserved fields.
22479            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22480
22481            // Safety:
22482            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
22483            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
22484            //   envelope_size bytes, there is always sufficient room.
22485            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
22486                self.source_name.as_ref().map(
22487                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
22488                ),
22489                encoder,
22490                offset + cur_offset,
22491                depth,
22492            )?;
22493
22494            _prev_end_offset = cur_offset + envelope_size;
22495            if 3 > max_ordinal {
22496                return Ok(());
22497            }
22498
22499            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
22500            // are envelope_size bytes.
22501            let cur_offset: usize = (3 - 1) * envelope_size;
22502
22503            // Zero reserved fields.
22504            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22505
22506            // Safety:
22507            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
22508            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
22509            //   envelope_size bytes, there is always sufficient room.
22510            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
22511            self.target_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
22512            encoder, offset + cur_offset, depth
22513        )?;
22514
22515            _prev_end_offset = cur_offset + envelope_size;
22516            if 4 > max_ordinal {
22517                return Ok(());
22518            }
22519
22520            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
22521            // are envelope_size bytes.
22522            let cur_offset: usize = (4 - 1) * envelope_size;
22523
22524            // Zero reserved fields.
22525            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22526
22527            // Safety:
22528            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
22529            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
22530            //   envelope_size bytes, there is always sufficient room.
22531            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_io__common::Operations, D>(
22532            self.rights.as_ref().map(<fidl_fuchsia_io__common::Operations as fidl::encoding::ValueTypeMarker>::borrow),
22533            encoder, offset + cur_offset, depth
22534        )?;
22535
22536            _prev_end_offset = cur_offset + envelope_size;
22537            if 5 > max_ordinal {
22538                return Ok(());
22539            }
22540
22541            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
22542            // are envelope_size bytes.
22543            let cur_offset: usize = (5 - 1) * envelope_size;
22544
22545            // Zero reserved fields.
22546            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22547
22548            // Safety:
22549            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
22550            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
22551            //   envelope_size bytes, there is always sufficient room.
22552            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
22553            self.subdir.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
22554            encoder, offset + cur_offset, depth
22555        )?;
22556
22557            _prev_end_offset = cur_offset + envelope_size;
22558            if 6 > max_ordinal {
22559                return Ok(());
22560            }
22561
22562            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
22563            // are envelope_size bytes.
22564            let cur_offset: usize = (6 - 1) * envelope_size;
22565
22566            // Zero reserved fields.
22567            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22568
22569            // Safety:
22570            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
22571            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
22572            //   envelope_size bytes, there is always sufficient room.
22573            fidl::encoding::encode_in_envelope_optional::<DependencyType, D>(
22574                self.dependency_type
22575                    .as_ref()
22576                    .map(<DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
22577                encoder,
22578                offset + cur_offset,
22579                depth,
22580            )?;
22581
22582            _prev_end_offset = cur_offset + envelope_size;
22583            if 7 > max_ordinal {
22584                return Ok(());
22585            }
22586
22587            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
22588            // are envelope_size bytes.
22589            let cur_offset: usize = (7 - 1) * envelope_size;
22590
22591            // Zero reserved fields.
22592            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22593
22594            // Safety:
22595            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
22596            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
22597            //   envelope_size bytes, there is always sufficient room.
22598            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
22599                self.availability
22600                    .as_ref()
22601                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
22602                encoder,
22603                offset + cur_offset,
22604                depth,
22605            )?;
22606
22607            _prev_end_offset = cur_offset + envelope_size;
22608            if 8 > max_ordinal {
22609                return Ok(());
22610            }
22611
22612            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
22613            // are envelope_size bytes.
22614            let cur_offset: usize = (8 - 1) * envelope_size;
22615
22616            // Zero reserved fields.
22617            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
22618
22619            // Safety:
22620            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
22621            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
22622            //   envelope_size bytes, there is always sufficient room.
22623            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
22624            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
22625            encoder, offset + cur_offset, depth
22626        )?;
22627
22628            _prev_end_offset = cur_offset + envelope_size;
22629
22630            Ok(())
22631        }
22632    }
22633
22634    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UseDirectory {
22635        #[inline(always)]
22636        fn new_empty() -> Self {
22637            Self::default()
22638        }
22639
22640        unsafe fn decode(
22641            &mut self,
22642            decoder: &mut fidl::encoding::Decoder<'_, D>,
22643            offset: usize,
22644            mut depth: fidl::encoding::Depth,
22645        ) -> fidl::Result<()> {
22646            decoder.debug_check_bounds::<Self>(offset);
22647            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
22648                None => return Err(fidl::Error::NotNullable),
22649                Some(len) => len,
22650            };
22651            // Calling decoder.out_of_line_offset(0) is not allowed.
22652            if len == 0 {
22653                return Ok(());
22654            };
22655            depth.increment()?;
22656            let envelope_size = 8;
22657            let bytes_len = len * envelope_size;
22658            let offset = decoder.out_of_line_offset(bytes_len)?;
22659            // Decode the envelope for each type.
22660            let mut _next_ordinal_to_read = 0;
22661            let mut next_offset = offset;
22662            let end_offset = offset + bytes_len;
22663            _next_ordinal_to_read += 1;
22664            if next_offset >= end_offset {
22665                return Ok(());
22666            }
22667
22668            // Decode unknown envelopes for gaps in ordinals.
22669            while _next_ordinal_to_read < 1 {
22670                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22671                _next_ordinal_to_read += 1;
22672                next_offset += envelope_size;
22673            }
22674
22675            let next_out_of_line = decoder.next_out_of_line();
22676            let handles_before = decoder.remaining_handles();
22677            if let Some((inlined, num_bytes, num_handles)) =
22678                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22679            {
22680                let member_inline_size =
22681                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22682                if inlined != (member_inline_size <= 4) {
22683                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22684                }
22685                let inner_offset;
22686                let mut inner_depth = depth.clone();
22687                if inlined {
22688                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22689                    inner_offset = next_offset;
22690                } else {
22691                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22692                    inner_depth.increment()?;
22693                }
22694                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
22695                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
22696                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22697                {
22698                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22699                }
22700                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22701                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22702                }
22703            }
22704
22705            next_offset += envelope_size;
22706            _next_ordinal_to_read += 1;
22707            if next_offset >= end_offset {
22708                return Ok(());
22709            }
22710
22711            // Decode unknown envelopes for gaps in ordinals.
22712            while _next_ordinal_to_read < 2 {
22713                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22714                _next_ordinal_to_read += 1;
22715                next_offset += envelope_size;
22716            }
22717
22718            let next_out_of_line = decoder.next_out_of_line();
22719            let handles_before = decoder.remaining_handles();
22720            if let Some((inlined, num_bytes, num_handles)) =
22721                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22722            {
22723                let member_inline_size =
22724                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
22725                        decoder.context,
22726                    );
22727                if inlined != (member_inline_size <= 4) {
22728                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22729                }
22730                let inner_offset;
22731                let mut inner_depth = depth.clone();
22732                if inlined {
22733                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22734                    inner_offset = next_offset;
22735                } else {
22736                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22737                    inner_depth.increment()?;
22738                }
22739                let val_ref = self
22740                    .source_name
22741                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
22742                fidl::decode!(
22743                    fidl::encoding::BoundedString<100>,
22744                    D,
22745                    val_ref,
22746                    decoder,
22747                    inner_offset,
22748                    inner_depth
22749                )?;
22750                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22751                {
22752                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22753                }
22754                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22755                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22756                }
22757            }
22758
22759            next_offset += envelope_size;
22760            _next_ordinal_to_read += 1;
22761            if next_offset >= end_offset {
22762                return Ok(());
22763            }
22764
22765            // Decode unknown envelopes for gaps in ordinals.
22766            while _next_ordinal_to_read < 3 {
22767                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22768                _next_ordinal_to_read += 1;
22769                next_offset += envelope_size;
22770            }
22771
22772            let next_out_of_line = decoder.next_out_of_line();
22773            let handles_before = decoder.remaining_handles();
22774            if let Some((inlined, num_bytes, num_handles)) =
22775                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22776            {
22777                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22778                if inlined != (member_inline_size <= 4) {
22779                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22780                }
22781                let inner_offset;
22782                let mut inner_depth = depth.clone();
22783                if inlined {
22784                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22785                    inner_offset = next_offset;
22786                } else {
22787                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22788                    inner_depth.increment()?;
22789                }
22790                let val_ref = self.target_path.get_or_insert_with(|| {
22791                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
22792                });
22793                fidl::decode!(
22794                    fidl::encoding::BoundedString<1024>,
22795                    D,
22796                    val_ref,
22797                    decoder,
22798                    inner_offset,
22799                    inner_depth
22800                )?;
22801                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22802                {
22803                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22804                }
22805                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22806                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22807                }
22808            }
22809
22810            next_offset += envelope_size;
22811            _next_ordinal_to_read += 1;
22812            if next_offset >= end_offset {
22813                return Ok(());
22814            }
22815
22816            // Decode unknown envelopes for gaps in ordinals.
22817            while _next_ordinal_to_read < 4 {
22818                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22819                _next_ordinal_to_read += 1;
22820                next_offset += envelope_size;
22821            }
22822
22823            let next_out_of_line = decoder.next_out_of_line();
22824            let handles_before = decoder.remaining_handles();
22825            if let Some((inlined, num_bytes, num_handles)) =
22826                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22827            {
22828                let member_inline_size = <fidl_fuchsia_io__common::Operations as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22829                if inlined != (member_inline_size <= 4) {
22830                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22831                }
22832                let inner_offset;
22833                let mut inner_depth = depth.clone();
22834                if inlined {
22835                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22836                    inner_offset = next_offset;
22837                } else {
22838                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22839                    inner_depth.increment()?;
22840                }
22841                let val_ref = self.rights.get_or_insert_with(|| {
22842                    fidl::new_empty!(fidl_fuchsia_io__common::Operations, D)
22843                });
22844                fidl::decode!(
22845                    fidl_fuchsia_io__common::Operations,
22846                    D,
22847                    val_ref,
22848                    decoder,
22849                    inner_offset,
22850                    inner_depth
22851                )?;
22852                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22853                {
22854                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22855                }
22856                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22857                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22858                }
22859            }
22860
22861            next_offset += envelope_size;
22862            _next_ordinal_to_read += 1;
22863            if next_offset >= end_offset {
22864                return Ok(());
22865            }
22866
22867            // Decode unknown envelopes for gaps in ordinals.
22868            while _next_ordinal_to_read < 5 {
22869                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22870                _next_ordinal_to_read += 1;
22871                next_offset += envelope_size;
22872            }
22873
22874            let next_out_of_line = decoder.next_out_of_line();
22875            let handles_before = decoder.remaining_handles();
22876            if let Some((inlined, num_bytes, num_handles)) =
22877                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22878            {
22879                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22880                if inlined != (member_inline_size <= 4) {
22881                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22882                }
22883                let inner_offset;
22884                let mut inner_depth = depth.clone();
22885                if inlined {
22886                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22887                    inner_offset = next_offset;
22888                } else {
22889                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22890                    inner_depth.increment()?;
22891                }
22892                let val_ref = self.subdir.get_or_insert_with(|| {
22893                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
22894                });
22895                fidl::decode!(
22896                    fidl::encoding::BoundedString<1024>,
22897                    D,
22898                    val_ref,
22899                    decoder,
22900                    inner_offset,
22901                    inner_depth
22902                )?;
22903                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22904                {
22905                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22906                }
22907                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22908                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22909                }
22910            }
22911
22912            next_offset += envelope_size;
22913            _next_ordinal_to_read += 1;
22914            if next_offset >= end_offset {
22915                return Ok(());
22916            }
22917
22918            // Decode unknown envelopes for gaps in ordinals.
22919            while _next_ordinal_to_read < 6 {
22920                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22921                _next_ordinal_to_read += 1;
22922                next_offset += envelope_size;
22923            }
22924
22925            let next_out_of_line = decoder.next_out_of_line();
22926            let handles_before = decoder.remaining_handles();
22927            if let Some((inlined, num_bytes, num_handles)) =
22928                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22929            {
22930                let member_inline_size =
22931                    <DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22932                if inlined != (member_inline_size <= 4) {
22933                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22934                }
22935                let inner_offset;
22936                let mut inner_depth = depth.clone();
22937                if inlined {
22938                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22939                    inner_offset = next_offset;
22940                } else {
22941                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22942                    inner_depth.increment()?;
22943                }
22944                let val_ref =
22945                    self.dependency_type.get_or_insert_with(|| fidl::new_empty!(DependencyType, D));
22946                fidl::decode!(DependencyType, D, val_ref, decoder, inner_offset, inner_depth)?;
22947                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22948                {
22949                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22950                }
22951                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22952                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22953                }
22954            }
22955
22956            next_offset += envelope_size;
22957            _next_ordinal_to_read += 1;
22958            if next_offset >= end_offset {
22959                return Ok(());
22960            }
22961
22962            // Decode unknown envelopes for gaps in ordinals.
22963            while _next_ordinal_to_read < 7 {
22964                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
22965                _next_ordinal_to_read += 1;
22966                next_offset += envelope_size;
22967            }
22968
22969            let next_out_of_line = decoder.next_out_of_line();
22970            let handles_before = decoder.remaining_handles();
22971            if let Some((inlined, num_bytes, num_handles)) =
22972                fidl::encoding::decode_envelope_header(decoder, next_offset)?
22973            {
22974                let member_inline_size =
22975                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
22976                if inlined != (member_inline_size <= 4) {
22977                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
22978                }
22979                let inner_offset;
22980                let mut inner_depth = depth.clone();
22981                if inlined {
22982                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
22983                    inner_offset = next_offset;
22984                } else {
22985                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
22986                    inner_depth.increment()?;
22987                }
22988                let val_ref =
22989                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
22990                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
22991                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
22992                {
22993                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
22994                }
22995                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
22996                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
22997                }
22998            }
22999
23000            next_offset += envelope_size;
23001            _next_ordinal_to_read += 1;
23002            if next_offset >= end_offset {
23003                return Ok(());
23004            }
23005
23006            // Decode unknown envelopes for gaps in ordinals.
23007            while _next_ordinal_to_read < 8 {
23008                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23009                _next_ordinal_to_read += 1;
23010                next_offset += envelope_size;
23011            }
23012
23013            let next_out_of_line = decoder.next_out_of_line();
23014            let handles_before = decoder.remaining_handles();
23015            if let Some((inlined, num_bytes, num_handles)) =
23016                fidl::encoding::decode_envelope_header(decoder, next_offset)?
23017            {
23018                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
23019                if inlined != (member_inline_size <= 4) {
23020                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
23021                }
23022                let inner_offset;
23023                let mut inner_depth = depth.clone();
23024                if inlined {
23025                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23026                    inner_offset = next_offset;
23027                } else {
23028                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23029                    inner_depth.increment()?;
23030                }
23031                let val_ref = self.source_dictionary.get_or_insert_with(|| {
23032                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
23033                });
23034                fidl::decode!(
23035                    fidl::encoding::BoundedString<1024>,
23036                    D,
23037                    val_ref,
23038                    decoder,
23039                    inner_offset,
23040                    inner_depth
23041                )?;
23042                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23043                {
23044                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
23045                }
23046                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23047                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23048                }
23049            }
23050
23051            next_offset += envelope_size;
23052
23053            // Decode the remaining unknown envelopes.
23054            while next_offset < end_offset {
23055                _next_ordinal_to_read += 1;
23056                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23057                next_offset += envelope_size;
23058            }
23059
23060            Ok(())
23061        }
23062    }
23063
23064    impl UseEventStream {
23065        #[inline(always)]
23066        fn max_ordinal_present(&self) -> u64 {
23067            if let Some(_) = self.filter {
23068                return 6;
23069            }
23070            if let Some(_) = self.availability {
23071                return 5;
23072            }
23073            if let Some(_) = self.target_path {
23074                return 4;
23075            }
23076            if let Some(_) = self.scope {
23077                return 3;
23078            }
23079            if let Some(_) = self.source {
23080                return 2;
23081            }
23082            if let Some(_) = self.source_name {
23083                return 1;
23084            }
23085            0
23086        }
23087    }
23088
23089    impl fidl::encoding::ValueTypeMarker for UseEventStream {
23090        type Borrowed<'a> = &'a Self;
23091        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23092            value
23093        }
23094    }
23095
23096    unsafe impl fidl::encoding::TypeMarker for UseEventStream {
23097        type Owned = Self;
23098
23099        #[inline(always)]
23100        fn inline_align(_context: fidl::encoding::Context) -> usize {
23101            8
23102        }
23103
23104        #[inline(always)]
23105        fn inline_size(_context: fidl::encoding::Context) -> usize {
23106            16
23107        }
23108    }
23109
23110    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UseEventStream, D>
23111        for &UseEventStream
23112    {
23113        unsafe fn encode(
23114            self,
23115            encoder: &mut fidl::encoding::Encoder<'_, D>,
23116            offset: usize,
23117            mut depth: fidl::encoding::Depth,
23118        ) -> fidl::Result<()> {
23119            encoder.debug_check_bounds::<UseEventStream>(offset);
23120            // Vector header
23121            let max_ordinal: u64 = self.max_ordinal_present();
23122            encoder.write_num(max_ordinal, offset);
23123            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
23124            // Calling encoder.out_of_line_offset(0) is not allowed.
23125            if max_ordinal == 0 {
23126                return Ok(());
23127            }
23128            depth.increment()?;
23129            let envelope_size = 8;
23130            let bytes_len = max_ordinal as usize * envelope_size;
23131            #[allow(unused_variables)]
23132            let offset = encoder.out_of_line_offset(bytes_len);
23133            let mut _prev_end_offset: usize = 0;
23134            if 1 > max_ordinal {
23135                return Ok(());
23136            }
23137
23138            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
23139            // are envelope_size bytes.
23140            let cur_offset: usize = (1 - 1) * envelope_size;
23141
23142            // Zero reserved fields.
23143            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23144
23145            // Safety:
23146            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
23147            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
23148            //   envelope_size bytes, there is always sufficient room.
23149            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
23150                self.source_name.as_ref().map(
23151                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
23152                ),
23153                encoder,
23154                offset + cur_offset,
23155                depth,
23156            )?;
23157
23158            _prev_end_offset = cur_offset + envelope_size;
23159            if 2 > max_ordinal {
23160                return Ok(());
23161            }
23162
23163            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
23164            // are envelope_size bytes.
23165            let cur_offset: usize = (2 - 1) * envelope_size;
23166
23167            // Zero reserved fields.
23168            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23169
23170            // Safety:
23171            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
23172            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
23173            //   envelope_size bytes, there is always sufficient room.
23174            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
23175                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
23176                encoder,
23177                offset + cur_offset,
23178                depth,
23179            )?;
23180
23181            _prev_end_offset = cur_offset + envelope_size;
23182            if 3 > max_ordinal {
23183                return Ok(());
23184            }
23185
23186            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
23187            // are envelope_size bytes.
23188            let cur_offset: usize = (3 - 1) * envelope_size;
23189
23190            // Zero reserved fields.
23191            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23192
23193            // Safety:
23194            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
23195            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
23196            //   envelope_size bytes, there is always sufficient room.
23197            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Ref>, D>(
23198            self.scope.as_ref().map(<fidl::encoding::UnboundedVector<Ref> as fidl::encoding::ValueTypeMarker>::borrow),
23199            encoder, offset + cur_offset, depth
23200        )?;
23201
23202            _prev_end_offset = cur_offset + envelope_size;
23203            if 4 > max_ordinal {
23204                return Ok(());
23205            }
23206
23207            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
23208            // are envelope_size bytes.
23209            let cur_offset: usize = (4 - 1) * envelope_size;
23210
23211            // Zero reserved fields.
23212            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23213
23214            // Safety:
23215            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
23216            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
23217            //   envelope_size bytes, there is always sufficient room.
23218            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
23219                self.target_path.as_ref().map(
23220                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
23221                ),
23222                encoder,
23223                offset + cur_offset,
23224                depth,
23225            )?;
23226
23227            _prev_end_offset = cur_offset + envelope_size;
23228            if 5 > max_ordinal {
23229                return Ok(());
23230            }
23231
23232            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
23233            // are envelope_size bytes.
23234            let cur_offset: usize = (5 - 1) * envelope_size;
23235
23236            // Zero reserved fields.
23237            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23238
23239            // Safety:
23240            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
23241            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
23242            //   envelope_size bytes, there is always sufficient room.
23243            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
23244                self.availability
23245                    .as_ref()
23246                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
23247                encoder,
23248                offset + cur_offset,
23249                depth,
23250            )?;
23251
23252            _prev_end_offset = cur_offset + envelope_size;
23253            if 6 > max_ordinal {
23254                return Ok(());
23255            }
23256
23257            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
23258            // are envelope_size bytes.
23259            let cur_offset: usize = (6 - 1) * envelope_size;
23260
23261            // Zero reserved fields.
23262            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23263
23264            // Safety:
23265            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
23266            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
23267            //   envelope_size bytes, there is always sufficient room.
23268            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_data__common::Dictionary, D>(
23269            self.filter.as_ref().map(<fidl_fuchsia_data__common::Dictionary as fidl::encoding::ValueTypeMarker>::borrow),
23270            encoder, offset + cur_offset, depth
23271        )?;
23272
23273            _prev_end_offset = cur_offset + envelope_size;
23274
23275            Ok(())
23276        }
23277    }
23278
23279    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UseEventStream {
23280        #[inline(always)]
23281        fn new_empty() -> Self {
23282            Self::default()
23283        }
23284
23285        unsafe fn decode(
23286            &mut self,
23287            decoder: &mut fidl::encoding::Decoder<'_, D>,
23288            offset: usize,
23289            mut depth: fidl::encoding::Depth,
23290        ) -> fidl::Result<()> {
23291            decoder.debug_check_bounds::<Self>(offset);
23292            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
23293                None => return Err(fidl::Error::NotNullable),
23294                Some(len) => len,
23295            };
23296            // Calling decoder.out_of_line_offset(0) is not allowed.
23297            if len == 0 {
23298                return Ok(());
23299            };
23300            depth.increment()?;
23301            let envelope_size = 8;
23302            let bytes_len = len * envelope_size;
23303            let offset = decoder.out_of_line_offset(bytes_len)?;
23304            // Decode the envelope for each type.
23305            let mut _next_ordinal_to_read = 0;
23306            let mut next_offset = offset;
23307            let end_offset = offset + bytes_len;
23308            _next_ordinal_to_read += 1;
23309            if next_offset >= end_offset {
23310                return Ok(());
23311            }
23312
23313            // Decode unknown envelopes for gaps in ordinals.
23314            while _next_ordinal_to_read < 1 {
23315                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23316                _next_ordinal_to_read += 1;
23317                next_offset += envelope_size;
23318            }
23319
23320            let next_out_of_line = decoder.next_out_of_line();
23321            let handles_before = decoder.remaining_handles();
23322            if let Some((inlined, num_bytes, num_handles)) =
23323                fidl::encoding::decode_envelope_header(decoder, next_offset)?
23324            {
23325                let member_inline_size =
23326                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
23327                        decoder.context,
23328                    );
23329                if inlined != (member_inline_size <= 4) {
23330                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
23331                }
23332                let inner_offset;
23333                let mut inner_depth = depth.clone();
23334                if inlined {
23335                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23336                    inner_offset = next_offset;
23337                } else {
23338                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23339                    inner_depth.increment()?;
23340                }
23341                let val_ref = self
23342                    .source_name
23343                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
23344                fidl::decode!(
23345                    fidl::encoding::BoundedString<100>,
23346                    D,
23347                    val_ref,
23348                    decoder,
23349                    inner_offset,
23350                    inner_depth
23351                )?;
23352                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23353                {
23354                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
23355                }
23356                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23357                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23358                }
23359            }
23360
23361            next_offset += envelope_size;
23362            _next_ordinal_to_read += 1;
23363            if next_offset >= end_offset {
23364                return Ok(());
23365            }
23366
23367            // Decode unknown envelopes for gaps in ordinals.
23368            while _next_ordinal_to_read < 2 {
23369                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23370                _next_ordinal_to_read += 1;
23371                next_offset += envelope_size;
23372            }
23373
23374            let next_out_of_line = decoder.next_out_of_line();
23375            let handles_before = decoder.remaining_handles();
23376            if let Some((inlined, num_bytes, num_handles)) =
23377                fidl::encoding::decode_envelope_header(decoder, next_offset)?
23378            {
23379                let member_inline_size =
23380                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
23381                if inlined != (member_inline_size <= 4) {
23382                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
23383                }
23384                let inner_offset;
23385                let mut inner_depth = depth.clone();
23386                if inlined {
23387                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23388                    inner_offset = next_offset;
23389                } else {
23390                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23391                    inner_depth.increment()?;
23392                }
23393                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
23394                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
23395                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23396                {
23397                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
23398                }
23399                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23400                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23401                }
23402            }
23403
23404            next_offset += envelope_size;
23405            _next_ordinal_to_read += 1;
23406            if next_offset >= end_offset {
23407                return Ok(());
23408            }
23409
23410            // Decode unknown envelopes for gaps in ordinals.
23411            while _next_ordinal_to_read < 3 {
23412                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23413                _next_ordinal_to_read += 1;
23414                next_offset += envelope_size;
23415            }
23416
23417            let next_out_of_line = decoder.next_out_of_line();
23418            let handles_before = decoder.remaining_handles();
23419            if let Some((inlined, num_bytes, num_handles)) =
23420                fidl::encoding::decode_envelope_header(decoder, next_offset)?
23421            {
23422                let member_inline_size = <fidl::encoding::UnboundedVector<Ref> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
23423                if inlined != (member_inline_size <= 4) {
23424                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
23425                }
23426                let inner_offset;
23427                let mut inner_depth = depth.clone();
23428                if inlined {
23429                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23430                    inner_offset = next_offset;
23431                } else {
23432                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23433                    inner_depth.increment()?;
23434                }
23435                let val_ref = self.scope.get_or_insert_with(|| {
23436                    fidl::new_empty!(fidl::encoding::UnboundedVector<Ref>, D)
23437                });
23438                fidl::decode!(
23439                    fidl::encoding::UnboundedVector<Ref>,
23440                    D,
23441                    val_ref,
23442                    decoder,
23443                    inner_offset,
23444                    inner_depth
23445                )?;
23446                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23447                {
23448                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
23449                }
23450                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23451                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23452                }
23453            }
23454
23455            next_offset += envelope_size;
23456            _next_ordinal_to_read += 1;
23457            if next_offset >= end_offset {
23458                return Ok(());
23459            }
23460
23461            // Decode unknown envelopes for gaps in ordinals.
23462            while _next_ordinal_to_read < 4 {
23463                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23464                _next_ordinal_to_read += 1;
23465                next_offset += envelope_size;
23466            }
23467
23468            let next_out_of_line = decoder.next_out_of_line();
23469            let handles_before = decoder.remaining_handles();
23470            if let Some((inlined, num_bytes, num_handles)) =
23471                fidl::encoding::decode_envelope_header(decoder, next_offset)?
23472            {
23473                let member_inline_size =
23474                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
23475                        decoder.context,
23476                    );
23477                if inlined != (member_inline_size <= 4) {
23478                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
23479                }
23480                let inner_offset;
23481                let mut inner_depth = depth.clone();
23482                if inlined {
23483                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23484                    inner_offset = next_offset;
23485                } else {
23486                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23487                    inner_depth.increment()?;
23488                }
23489                let val_ref = self
23490                    .target_path
23491                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
23492                fidl::decode!(
23493                    fidl::encoding::BoundedString<100>,
23494                    D,
23495                    val_ref,
23496                    decoder,
23497                    inner_offset,
23498                    inner_depth
23499                )?;
23500                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23501                {
23502                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
23503                }
23504                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23505                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23506                }
23507            }
23508
23509            next_offset += envelope_size;
23510            _next_ordinal_to_read += 1;
23511            if next_offset >= end_offset {
23512                return Ok(());
23513            }
23514
23515            // Decode unknown envelopes for gaps in ordinals.
23516            while _next_ordinal_to_read < 5 {
23517                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23518                _next_ordinal_to_read += 1;
23519                next_offset += envelope_size;
23520            }
23521
23522            let next_out_of_line = decoder.next_out_of_line();
23523            let handles_before = decoder.remaining_handles();
23524            if let Some((inlined, num_bytes, num_handles)) =
23525                fidl::encoding::decode_envelope_header(decoder, next_offset)?
23526            {
23527                let member_inline_size =
23528                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
23529                if inlined != (member_inline_size <= 4) {
23530                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
23531                }
23532                let inner_offset;
23533                let mut inner_depth = depth.clone();
23534                if inlined {
23535                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23536                    inner_offset = next_offset;
23537                } else {
23538                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23539                    inner_depth.increment()?;
23540                }
23541                let val_ref =
23542                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
23543                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
23544                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23545                {
23546                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
23547                }
23548                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23549                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23550                }
23551            }
23552
23553            next_offset += envelope_size;
23554            _next_ordinal_to_read += 1;
23555            if next_offset >= end_offset {
23556                return Ok(());
23557            }
23558
23559            // Decode unknown envelopes for gaps in ordinals.
23560            while _next_ordinal_to_read < 6 {
23561                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23562                _next_ordinal_to_read += 1;
23563                next_offset += envelope_size;
23564            }
23565
23566            let next_out_of_line = decoder.next_out_of_line();
23567            let handles_before = decoder.remaining_handles();
23568            if let Some((inlined, num_bytes, num_handles)) =
23569                fidl::encoding::decode_envelope_header(decoder, next_offset)?
23570            {
23571                let member_inline_size = <fidl_fuchsia_data__common::Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context);
23572                if inlined != (member_inline_size <= 4) {
23573                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
23574                }
23575                let inner_offset;
23576                let mut inner_depth = depth.clone();
23577                if inlined {
23578                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23579                    inner_offset = next_offset;
23580                } else {
23581                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23582                    inner_depth.increment()?;
23583                }
23584                let val_ref = self.filter.get_or_insert_with(|| {
23585                    fidl::new_empty!(fidl_fuchsia_data__common::Dictionary, D)
23586                });
23587                fidl::decode!(
23588                    fidl_fuchsia_data__common::Dictionary,
23589                    D,
23590                    val_ref,
23591                    decoder,
23592                    inner_offset,
23593                    inner_depth
23594                )?;
23595                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23596                {
23597                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
23598                }
23599                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23600                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23601                }
23602            }
23603
23604            next_offset += envelope_size;
23605
23606            // Decode the remaining unknown envelopes.
23607            while next_offset < end_offset {
23608                _next_ordinal_to_read += 1;
23609                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23610                next_offset += envelope_size;
23611            }
23612
23613            Ok(())
23614        }
23615    }
23616
23617    impl UseProtocol {
23618        #[inline(always)]
23619        fn max_ordinal_present(&self) -> u64 {
23620            if let Some(_) = self.source_dictionary {
23621                return 6;
23622            }
23623            if let Some(_) = self.availability {
23624                return 5;
23625            }
23626            if let Some(_) = self.dependency_type {
23627                return 4;
23628            }
23629            if let Some(_) = self.target_path {
23630                return 3;
23631            }
23632            if let Some(_) = self.source_name {
23633                return 2;
23634            }
23635            if let Some(_) = self.source {
23636                return 1;
23637            }
23638            0
23639        }
23640    }
23641
23642    impl fidl::encoding::ValueTypeMarker for UseProtocol {
23643        type Borrowed<'a> = &'a Self;
23644        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
23645            value
23646        }
23647    }
23648
23649    unsafe impl fidl::encoding::TypeMarker for UseProtocol {
23650        type Owned = Self;
23651
23652        #[inline(always)]
23653        fn inline_align(_context: fidl::encoding::Context) -> usize {
23654            8
23655        }
23656
23657        #[inline(always)]
23658        fn inline_size(_context: fidl::encoding::Context) -> usize {
23659            16
23660        }
23661    }
23662
23663    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UseProtocol, D>
23664        for &UseProtocol
23665    {
23666        unsafe fn encode(
23667            self,
23668            encoder: &mut fidl::encoding::Encoder<'_, D>,
23669            offset: usize,
23670            mut depth: fidl::encoding::Depth,
23671        ) -> fidl::Result<()> {
23672            encoder.debug_check_bounds::<UseProtocol>(offset);
23673            // Vector header
23674            let max_ordinal: u64 = self.max_ordinal_present();
23675            encoder.write_num(max_ordinal, offset);
23676            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
23677            // Calling encoder.out_of_line_offset(0) is not allowed.
23678            if max_ordinal == 0 {
23679                return Ok(());
23680            }
23681            depth.increment()?;
23682            let envelope_size = 8;
23683            let bytes_len = max_ordinal as usize * envelope_size;
23684            #[allow(unused_variables)]
23685            let offset = encoder.out_of_line_offset(bytes_len);
23686            let mut _prev_end_offset: usize = 0;
23687            if 1 > max_ordinal {
23688                return Ok(());
23689            }
23690
23691            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
23692            // are envelope_size bytes.
23693            let cur_offset: usize = (1 - 1) * envelope_size;
23694
23695            // Zero reserved fields.
23696            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23697
23698            // Safety:
23699            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
23700            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
23701            //   envelope_size bytes, there is always sufficient room.
23702            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
23703                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
23704                encoder,
23705                offset + cur_offset,
23706                depth,
23707            )?;
23708
23709            _prev_end_offset = cur_offset + envelope_size;
23710            if 2 > max_ordinal {
23711                return Ok(());
23712            }
23713
23714            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
23715            // are envelope_size bytes.
23716            let cur_offset: usize = (2 - 1) * envelope_size;
23717
23718            // Zero reserved fields.
23719            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23720
23721            // Safety:
23722            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
23723            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
23724            //   envelope_size bytes, there is always sufficient room.
23725            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
23726                self.source_name.as_ref().map(
23727                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
23728                ),
23729                encoder,
23730                offset + cur_offset,
23731                depth,
23732            )?;
23733
23734            _prev_end_offset = cur_offset + envelope_size;
23735            if 3 > max_ordinal {
23736                return Ok(());
23737            }
23738
23739            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
23740            // are envelope_size bytes.
23741            let cur_offset: usize = (3 - 1) * envelope_size;
23742
23743            // Zero reserved fields.
23744            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23745
23746            // Safety:
23747            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
23748            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
23749            //   envelope_size bytes, there is always sufficient room.
23750            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
23751            self.target_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
23752            encoder, offset + cur_offset, depth
23753        )?;
23754
23755            _prev_end_offset = cur_offset + envelope_size;
23756            if 4 > max_ordinal {
23757                return Ok(());
23758            }
23759
23760            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
23761            // are envelope_size bytes.
23762            let cur_offset: usize = (4 - 1) * envelope_size;
23763
23764            // Zero reserved fields.
23765            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23766
23767            // Safety:
23768            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
23769            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
23770            //   envelope_size bytes, there is always sufficient room.
23771            fidl::encoding::encode_in_envelope_optional::<DependencyType, D>(
23772                self.dependency_type
23773                    .as_ref()
23774                    .map(<DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
23775                encoder,
23776                offset + cur_offset,
23777                depth,
23778            )?;
23779
23780            _prev_end_offset = cur_offset + envelope_size;
23781            if 5 > max_ordinal {
23782                return Ok(());
23783            }
23784
23785            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
23786            // are envelope_size bytes.
23787            let cur_offset: usize = (5 - 1) * envelope_size;
23788
23789            // Zero reserved fields.
23790            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23791
23792            // Safety:
23793            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
23794            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
23795            //   envelope_size bytes, there is always sufficient room.
23796            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
23797                self.availability
23798                    .as_ref()
23799                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
23800                encoder,
23801                offset + cur_offset,
23802                depth,
23803            )?;
23804
23805            _prev_end_offset = cur_offset + envelope_size;
23806            if 6 > max_ordinal {
23807                return Ok(());
23808            }
23809
23810            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
23811            // are envelope_size bytes.
23812            let cur_offset: usize = (6 - 1) * envelope_size;
23813
23814            // Zero reserved fields.
23815            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
23816
23817            // Safety:
23818            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
23819            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
23820            //   envelope_size bytes, there is always sufficient room.
23821            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
23822            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
23823            encoder, offset + cur_offset, depth
23824        )?;
23825
23826            _prev_end_offset = cur_offset + envelope_size;
23827
23828            Ok(())
23829        }
23830    }
23831
23832    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UseProtocol {
23833        #[inline(always)]
23834        fn new_empty() -> Self {
23835            Self::default()
23836        }
23837
23838        unsafe fn decode(
23839            &mut self,
23840            decoder: &mut fidl::encoding::Decoder<'_, D>,
23841            offset: usize,
23842            mut depth: fidl::encoding::Depth,
23843        ) -> fidl::Result<()> {
23844            decoder.debug_check_bounds::<Self>(offset);
23845            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
23846                None => return Err(fidl::Error::NotNullable),
23847                Some(len) => len,
23848            };
23849            // Calling decoder.out_of_line_offset(0) is not allowed.
23850            if len == 0 {
23851                return Ok(());
23852            };
23853            depth.increment()?;
23854            let envelope_size = 8;
23855            let bytes_len = len * envelope_size;
23856            let offset = decoder.out_of_line_offset(bytes_len)?;
23857            // Decode the envelope for each type.
23858            let mut _next_ordinal_to_read = 0;
23859            let mut next_offset = offset;
23860            let end_offset = offset + bytes_len;
23861            _next_ordinal_to_read += 1;
23862            if next_offset >= end_offset {
23863                return Ok(());
23864            }
23865
23866            // Decode unknown envelopes for gaps in ordinals.
23867            while _next_ordinal_to_read < 1 {
23868                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23869                _next_ordinal_to_read += 1;
23870                next_offset += envelope_size;
23871            }
23872
23873            let next_out_of_line = decoder.next_out_of_line();
23874            let handles_before = decoder.remaining_handles();
23875            if let Some((inlined, num_bytes, num_handles)) =
23876                fidl::encoding::decode_envelope_header(decoder, next_offset)?
23877            {
23878                let member_inline_size =
23879                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
23880                if inlined != (member_inline_size <= 4) {
23881                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
23882                }
23883                let inner_offset;
23884                let mut inner_depth = depth.clone();
23885                if inlined {
23886                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23887                    inner_offset = next_offset;
23888                } else {
23889                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23890                    inner_depth.increment()?;
23891                }
23892                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
23893                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
23894                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23895                {
23896                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
23897                }
23898                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23899                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23900                }
23901            }
23902
23903            next_offset += envelope_size;
23904            _next_ordinal_to_read += 1;
23905            if next_offset >= end_offset {
23906                return Ok(());
23907            }
23908
23909            // Decode unknown envelopes for gaps in ordinals.
23910            while _next_ordinal_to_read < 2 {
23911                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23912                _next_ordinal_to_read += 1;
23913                next_offset += envelope_size;
23914            }
23915
23916            let next_out_of_line = decoder.next_out_of_line();
23917            let handles_before = decoder.remaining_handles();
23918            if let Some((inlined, num_bytes, num_handles)) =
23919                fidl::encoding::decode_envelope_header(decoder, next_offset)?
23920            {
23921                let member_inline_size =
23922                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
23923                        decoder.context,
23924                    );
23925                if inlined != (member_inline_size <= 4) {
23926                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
23927                }
23928                let inner_offset;
23929                let mut inner_depth = depth.clone();
23930                if inlined {
23931                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23932                    inner_offset = next_offset;
23933                } else {
23934                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23935                    inner_depth.increment()?;
23936                }
23937                let val_ref = self
23938                    .source_name
23939                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
23940                fidl::decode!(
23941                    fidl::encoding::BoundedString<100>,
23942                    D,
23943                    val_ref,
23944                    decoder,
23945                    inner_offset,
23946                    inner_depth
23947                )?;
23948                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
23949                {
23950                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
23951                }
23952                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
23953                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
23954                }
23955            }
23956
23957            next_offset += envelope_size;
23958            _next_ordinal_to_read += 1;
23959            if next_offset >= end_offset {
23960                return Ok(());
23961            }
23962
23963            // Decode unknown envelopes for gaps in ordinals.
23964            while _next_ordinal_to_read < 3 {
23965                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
23966                _next_ordinal_to_read += 1;
23967                next_offset += envelope_size;
23968            }
23969
23970            let next_out_of_line = decoder.next_out_of_line();
23971            let handles_before = decoder.remaining_handles();
23972            if let Some((inlined, num_bytes, num_handles)) =
23973                fidl::encoding::decode_envelope_header(decoder, next_offset)?
23974            {
23975                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
23976                if inlined != (member_inline_size <= 4) {
23977                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
23978                }
23979                let inner_offset;
23980                let mut inner_depth = depth.clone();
23981                if inlined {
23982                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
23983                    inner_offset = next_offset;
23984                } else {
23985                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
23986                    inner_depth.increment()?;
23987                }
23988                let val_ref = self.target_path.get_or_insert_with(|| {
23989                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
23990                });
23991                fidl::decode!(
23992                    fidl::encoding::BoundedString<1024>,
23993                    D,
23994                    val_ref,
23995                    decoder,
23996                    inner_offset,
23997                    inner_depth
23998                )?;
23999                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24000                {
24001                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
24002                }
24003                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24004                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24005                }
24006            }
24007
24008            next_offset += envelope_size;
24009            _next_ordinal_to_read += 1;
24010            if next_offset >= end_offset {
24011                return Ok(());
24012            }
24013
24014            // Decode unknown envelopes for gaps in ordinals.
24015            while _next_ordinal_to_read < 4 {
24016                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24017                _next_ordinal_to_read += 1;
24018                next_offset += envelope_size;
24019            }
24020
24021            let next_out_of_line = decoder.next_out_of_line();
24022            let handles_before = decoder.remaining_handles();
24023            if let Some((inlined, num_bytes, num_handles)) =
24024                fidl::encoding::decode_envelope_header(decoder, next_offset)?
24025            {
24026                let member_inline_size =
24027                    <DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24028                if inlined != (member_inline_size <= 4) {
24029                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
24030                }
24031                let inner_offset;
24032                let mut inner_depth = depth.clone();
24033                if inlined {
24034                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24035                    inner_offset = next_offset;
24036                } else {
24037                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24038                    inner_depth.increment()?;
24039                }
24040                let val_ref =
24041                    self.dependency_type.get_or_insert_with(|| fidl::new_empty!(DependencyType, D));
24042                fidl::decode!(DependencyType, D, val_ref, decoder, inner_offset, inner_depth)?;
24043                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24044                {
24045                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
24046                }
24047                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24048                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24049                }
24050            }
24051
24052            next_offset += envelope_size;
24053            _next_ordinal_to_read += 1;
24054            if next_offset >= end_offset {
24055                return Ok(());
24056            }
24057
24058            // Decode unknown envelopes for gaps in ordinals.
24059            while _next_ordinal_to_read < 5 {
24060                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24061                _next_ordinal_to_read += 1;
24062                next_offset += envelope_size;
24063            }
24064
24065            let next_out_of_line = decoder.next_out_of_line();
24066            let handles_before = decoder.remaining_handles();
24067            if let Some((inlined, num_bytes, num_handles)) =
24068                fidl::encoding::decode_envelope_header(decoder, next_offset)?
24069            {
24070                let member_inline_size =
24071                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24072                if inlined != (member_inline_size <= 4) {
24073                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
24074                }
24075                let inner_offset;
24076                let mut inner_depth = depth.clone();
24077                if inlined {
24078                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24079                    inner_offset = next_offset;
24080                } else {
24081                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24082                    inner_depth.increment()?;
24083                }
24084                let val_ref =
24085                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
24086                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
24087                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24088                {
24089                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
24090                }
24091                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24092                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24093                }
24094            }
24095
24096            next_offset += envelope_size;
24097            _next_ordinal_to_read += 1;
24098            if next_offset >= end_offset {
24099                return Ok(());
24100            }
24101
24102            // Decode unknown envelopes for gaps in ordinals.
24103            while _next_ordinal_to_read < 6 {
24104                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24105                _next_ordinal_to_read += 1;
24106                next_offset += envelope_size;
24107            }
24108
24109            let next_out_of_line = decoder.next_out_of_line();
24110            let handles_before = decoder.remaining_handles();
24111            if let Some((inlined, num_bytes, num_handles)) =
24112                fidl::encoding::decode_envelope_header(decoder, next_offset)?
24113            {
24114                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24115                if inlined != (member_inline_size <= 4) {
24116                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
24117                }
24118                let inner_offset;
24119                let mut inner_depth = depth.clone();
24120                if inlined {
24121                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24122                    inner_offset = next_offset;
24123                } else {
24124                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24125                    inner_depth.increment()?;
24126                }
24127                let val_ref = self.source_dictionary.get_or_insert_with(|| {
24128                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
24129                });
24130                fidl::decode!(
24131                    fidl::encoding::BoundedString<1024>,
24132                    D,
24133                    val_ref,
24134                    decoder,
24135                    inner_offset,
24136                    inner_depth
24137                )?;
24138                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24139                {
24140                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
24141                }
24142                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24143                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24144                }
24145            }
24146
24147            next_offset += envelope_size;
24148
24149            // Decode the remaining unknown envelopes.
24150            while next_offset < end_offset {
24151                _next_ordinal_to_read += 1;
24152                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24153                next_offset += envelope_size;
24154            }
24155
24156            Ok(())
24157        }
24158    }
24159
24160    impl UseRunner {
24161        #[inline(always)]
24162        fn max_ordinal_present(&self) -> u64 {
24163            if let Some(_) = self.source_dictionary {
24164                return 3;
24165            }
24166            if let Some(_) = self.source_name {
24167                return 2;
24168            }
24169            if let Some(_) = self.source {
24170                return 1;
24171            }
24172            0
24173        }
24174    }
24175
24176    impl fidl::encoding::ValueTypeMarker for UseRunner {
24177        type Borrowed<'a> = &'a Self;
24178        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24179            value
24180        }
24181    }
24182
24183    unsafe impl fidl::encoding::TypeMarker for UseRunner {
24184        type Owned = Self;
24185
24186        #[inline(always)]
24187        fn inline_align(_context: fidl::encoding::Context) -> usize {
24188            8
24189        }
24190
24191        #[inline(always)]
24192        fn inline_size(_context: fidl::encoding::Context) -> usize {
24193            16
24194        }
24195    }
24196
24197    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UseRunner, D>
24198        for &UseRunner
24199    {
24200        unsafe fn encode(
24201            self,
24202            encoder: &mut fidl::encoding::Encoder<'_, D>,
24203            offset: usize,
24204            mut depth: fidl::encoding::Depth,
24205        ) -> fidl::Result<()> {
24206            encoder.debug_check_bounds::<UseRunner>(offset);
24207            // Vector header
24208            let max_ordinal: u64 = self.max_ordinal_present();
24209            encoder.write_num(max_ordinal, offset);
24210            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
24211            // Calling encoder.out_of_line_offset(0) is not allowed.
24212            if max_ordinal == 0 {
24213                return Ok(());
24214            }
24215            depth.increment()?;
24216            let envelope_size = 8;
24217            let bytes_len = max_ordinal as usize * envelope_size;
24218            #[allow(unused_variables)]
24219            let offset = encoder.out_of_line_offset(bytes_len);
24220            let mut _prev_end_offset: usize = 0;
24221            if 1 > max_ordinal {
24222                return Ok(());
24223            }
24224
24225            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
24226            // are envelope_size bytes.
24227            let cur_offset: usize = (1 - 1) * envelope_size;
24228
24229            // Zero reserved fields.
24230            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24231
24232            // Safety:
24233            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
24234            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
24235            //   envelope_size bytes, there is always sufficient room.
24236            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
24237                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
24238                encoder,
24239                offset + cur_offset,
24240                depth,
24241            )?;
24242
24243            _prev_end_offset = cur_offset + envelope_size;
24244            if 2 > max_ordinal {
24245                return Ok(());
24246            }
24247
24248            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
24249            // are envelope_size bytes.
24250            let cur_offset: usize = (2 - 1) * envelope_size;
24251
24252            // Zero reserved fields.
24253            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24254
24255            // Safety:
24256            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
24257            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
24258            //   envelope_size bytes, there is always sufficient room.
24259            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
24260                self.source_name.as_ref().map(
24261                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
24262                ),
24263                encoder,
24264                offset + cur_offset,
24265                depth,
24266            )?;
24267
24268            _prev_end_offset = cur_offset + envelope_size;
24269            if 3 > max_ordinal {
24270                return Ok(());
24271            }
24272
24273            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
24274            // are envelope_size bytes.
24275            let cur_offset: usize = (3 - 1) * envelope_size;
24276
24277            // Zero reserved fields.
24278            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24279
24280            // Safety:
24281            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
24282            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
24283            //   envelope_size bytes, there is always sufficient room.
24284            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
24285            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
24286            encoder, offset + cur_offset, depth
24287        )?;
24288
24289            _prev_end_offset = cur_offset + envelope_size;
24290
24291            Ok(())
24292        }
24293    }
24294
24295    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UseRunner {
24296        #[inline(always)]
24297        fn new_empty() -> Self {
24298            Self::default()
24299        }
24300
24301        unsafe fn decode(
24302            &mut self,
24303            decoder: &mut fidl::encoding::Decoder<'_, D>,
24304            offset: usize,
24305            mut depth: fidl::encoding::Depth,
24306        ) -> fidl::Result<()> {
24307            decoder.debug_check_bounds::<Self>(offset);
24308            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
24309                None => return Err(fidl::Error::NotNullable),
24310                Some(len) => len,
24311            };
24312            // Calling decoder.out_of_line_offset(0) is not allowed.
24313            if len == 0 {
24314                return Ok(());
24315            };
24316            depth.increment()?;
24317            let envelope_size = 8;
24318            let bytes_len = len * envelope_size;
24319            let offset = decoder.out_of_line_offset(bytes_len)?;
24320            // Decode the envelope for each type.
24321            let mut _next_ordinal_to_read = 0;
24322            let mut next_offset = offset;
24323            let end_offset = offset + bytes_len;
24324            _next_ordinal_to_read += 1;
24325            if next_offset >= end_offset {
24326                return Ok(());
24327            }
24328
24329            // Decode unknown envelopes for gaps in ordinals.
24330            while _next_ordinal_to_read < 1 {
24331                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24332                _next_ordinal_to_read += 1;
24333                next_offset += envelope_size;
24334            }
24335
24336            let next_out_of_line = decoder.next_out_of_line();
24337            let handles_before = decoder.remaining_handles();
24338            if let Some((inlined, num_bytes, num_handles)) =
24339                fidl::encoding::decode_envelope_header(decoder, next_offset)?
24340            {
24341                let member_inline_size =
24342                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24343                if inlined != (member_inline_size <= 4) {
24344                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
24345                }
24346                let inner_offset;
24347                let mut inner_depth = depth.clone();
24348                if inlined {
24349                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24350                    inner_offset = next_offset;
24351                } else {
24352                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24353                    inner_depth.increment()?;
24354                }
24355                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
24356                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
24357                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24358                {
24359                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
24360                }
24361                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24362                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24363                }
24364            }
24365
24366            next_offset += envelope_size;
24367            _next_ordinal_to_read += 1;
24368            if next_offset >= end_offset {
24369                return Ok(());
24370            }
24371
24372            // Decode unknown envelopes for gaps in ordinals.
24373            while _next_ordinal_to_read < 2 {
24374                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24375                _next_ordinal_to_read += 1;
24376                next_offset += envelope_size;
24377            }
24378
24379            let next_out_of_line = decoder.next_out_of_line();
24380            let handles_before = decoder.remaining_handles();
24381            if let Some((inlined, num_bytes, num_handles)) =
24382                fidl::encoding::decode_envelope_header(decoder, next_offset)?
24383            {
24384                let member_inline_size =
24385                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
24386                        decoder.context,
24387                    );
24388                if inlined != (member_inline_size <= 4) {
24389                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
24390                }
24391                let inner_offset;
24392                let mut inner_depth = depth.clone();
24393                if inlined {
24394                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24395                    inner_offset = next_offset;
24396                } else {
24397                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24398                    inner_depth.increment()?;
24399                }
24400                let val_ref = self
24401                    .source_name
24402                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
24403                fidl::decode!(
24404                    fidl::encoding::BoundedString<100>,
24405                    D,
24406                    val_ref,
24407                    decoder,
24408                    inner_offset,
24409                    inner_depth
24410                )?;
24411                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24412                {
24413                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
24414                }
24415                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24416                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24417                }
24418            }
24419
24420            next_offset += envelope_size;
24421            _next_ordinal_to_read += 1;
24422            if next_offset >= end_offset {
24423                return Ok(());
24424            }
24425
24426            // Decode unknown envelopes for gaps in ordinals.
24427            while _next_ordinal_to_read < 3 {
24428                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24429                _next_ordinal_to_read += 1;
24430                next_offset += envelope_size;
24431            }
24432
24433            let next_out_of_line = decoder.next_out_of_line();
24434            let handles_before = decoder.remaining_handles();
24435            if let Some((inlined, num_bytes, num_handles)) =
24436                fidl::encoding::decode_envelope_header(decoder, next_offset)?
24437            {
24438                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24439                if inlined != (member_inline_size <= 4) {
24440                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
24441                }
24442                let inner_offset;
24443                let mut inner_depth = depth.clone();
24444                if inlined {
24445                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24446                    inner_offset = next_offset;
24447                } else {
24448                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24449                    inner_depth.increment()?;
24450                }
24451                let val_ref = self.source_dictionary.get_or_insert_with(|| {
24452                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
24453                });
24454                fidl::decode!(
24455                    fidl::encoding::BoundedString<1024>,
24456                    D,
24457                    val_ref,
24458                    decoder,
24459                    inner_offset,
24460                    inner_depth
24461                )?;
24462                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24463                {
24464                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
24465                }
24466                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24467                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24468                }
24469            }
24470
24471            next_offset += envelope_size;
24472
24473            // Decode the remaining unknown envelopes.
24474            while next_offset < end_offset {
24475                _next_ordinal_to_read += 1;
24476                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24477                next_offset += envelope_size;
24478            }
24479
24480            Ok(())
24481        }
24482    }
24483
24484    impl UseService {
24485        #[inline(always)]
24486        fn max_ordinal_present(&self) -> u64 {
24487            if let Some(_) = self.source_dictionary {
24488                return 6;
24489            }
24490            if let Some(_) = self.availability {
24491                return 5;
24492            }
24493            if let Some(_) = self.dependency_type {
24494                return 4;
24495            }
24496            if let Some(_) = self.target_path {
24497                return 3;
24498            }
24499            if let Some(_) = self.source_name {
24500                return 2;
24501            }
24502            if let Some(_) = self.source {
24503                return 1;
24504            }
24505            0
24506        }
24507    }
24508
24509    impl fidl::encoding::ValueTypeMarker for UseService {
24510        type Borrowed<'a> = &'a Self;
24511        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
24512            value
24513        }
24514    }
24515
24516    unsafe impl fidl::encoding::TypeMarker for UseService {
24517        type Owned = Self;
24518
24519        #[inline(always)]
24520        fn inline_align(_context: fidl::encoding::Context) -> usize {
24521            8
24522        }
24523
24524        #[inline(always)]
24525        fn inline_size(_context: fidl::encoding::Context) -> usize {
24526            16
24527        }
24528    }
24529
24530    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UseService, D>
24531        for &UseService
24532    {
24533        unsafe fn encode(
24534            self,
24535            encoder: &mut fidl::encoding::Encoder<'_, D>,
24536            offset: usize,
24537            mut depth: fidl::encoding::Depth,
24538        ) -> fidl::Result<()> {
24539            encoder.debug_check_bounds::<UseService>(offset);
24540            // Vector header
24541            let max_ordinal: u64 = self.max_ordinal_present();
24542            encoder.write_num(max_ordinal, offset);
24543            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
24544            // Calling encoder.out_of_line_offset(0) is not allowed.
24545            if max_ordinal == 0 {
24546                return Ok(());
24547            }
24548            depth.increment()?;
24549            let envelope_size = 8;
24550            let bytes_len = max_ordinal as usize * envelope_size;
24551            #[allow(unused_variables)]
24552            let offset = encoder.out_of_line_offset(bytes_len);
24553            let mut _prev_end_offset: usize = 0;
24554            if 1 > max_ordinal {
24555                return Ok(());
24556            }
24557
24558            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
24559            // are envelope_size bytes.
24560            let cur_offset: usize = (1 - 1) * envelope_size;
24561
24562            // Zero reserved fields.
24563            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24564
24565            // Safety:
24566            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
24567            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
24568            //   envelope_size bytes, there is always sufficient room.
24569            fidl::encoding::encode_in_envelope_optional::<Ref, D>(
24570                self.source.as_ref().map(<Ref as fidl::encoding::ValueTypeMarker>::borrow),
24571                encoder,
24572                offset + cur_offset,
24573                depth,
24574            )?;
24575
24576            _prev_end_offset = cur_offset + envelope_size;
24577            if 2 > max_ordinal {
24578                return Ok(());
24579            }
24580
24581            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
24582            // are envelope_size bytes.
24583            let cur_offset: usize = (2 - 1) * envelope_size;
24584
24585            // Zero reserved fields.
24586            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24587
24588            // Safety:
24589            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
24590            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
24591            //   envelope_size bytes, there is always sufficient room.
24592            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
24593                self.source_name.as_ref().map(
24594                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
24595                ),
24596                encoder,
24597                offset + cur_offset,
24598                depth,
24599            )?;
24600
24601            _prev_end_offset = cur_offset + envelope_size;
24602            if 3 > max_ordinal {
24603                return Ok(());
24604            }
24605
24606            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
24607            // are envelope_size bytes.
24608            let cur_offset: usize = (3 - 1) * envelope_size;
24609
24610            // Zero reserved fields.
24611            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24612
24613            // Safety:
24614            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
24615            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
24616            //   envelope_size bytes, there is always sufficient room.
24617            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
24618            self.target_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
24619            encoder, offset + cur_offset, depth
24620        )?;
24621
24622            _prev_end_offset = cur_offset + envelope_size;
24623            if 4 > max_ordinal {
24624                return Ok(());
24625            }
24626
24627            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
24628            // are envelope_size bytes.
24629            let cur_offset: usize = (4 - 1) * envelope_size;
24630
24631            // Zero reserved fields.
24632            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24633
24634            // Safety:
24635            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
24636            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
24637            //   envelope_size bytes, there is always sufficient room.
24638            fidl::encoding::encode_in_envelope_optional::<DependencyType, D>(
24639                self.dependency_type
24640                    .as_ref()
24641                    .map(<DependencyType as fidl::encoding::ValueTypeMarker>::borrow),
24642                encoder,
24643                offset + cur_offset,
24644                depth,
24645            )?;
24646
24647            _prev_end_offset = cur_offset + envelope_size;
24648            if 5 > max_ordinal {
24649                return Ok(());
24650            }
24651
24652            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
24653            // are envelope_size bytes.
24654            let cur_offset: usize = (5 - 1) * envelope_size;
24655
24656            // Zero reserved fields.
24657            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24658
24659            // Safety:
24660            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
24661            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
24662            //   envelope_size bytes, there is always sufficient room.
24663            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
24664                self.availability
24665                    .as_ref()
24666                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
24667                encoder,
24668                offset + cur_offset,
24669                depth,
24670            )?;
24671
24672            _prev_end_offset = cur_offset + envelope_size;
24673            if 6 > max_ordinal {
24674                return Ok(());
24675            }
24676
24677            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
24678            // are envelope_size bytes.
24679            let cur_offset: usize = (6 - 1) * envelope_size;
24680
24681            // Zero reserved fields.
24682            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
24683
24684            // Safety:
24685            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
24686            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
24687            //   envelope_size bytes, there is always sufficient room.
24688            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
24689            self.source_dictionary.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
24690            encoder, offset + cur_offset, depth
24691        )?;
24692
24693            _prev_end_offset = cur_offset + envelope_size;
24694
24695            Ok(())
24696        }
24697    }
24698
24699    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UseService {
24700        #[inline(always)]
24701        fn new_empty() -> Self {
24702            Self::default()
24703        }
24704
24705        unsafe fn decode(
24706            &mut self,
24707            decoder: &mut fidl::encoding::Decoder<'_, D>,
24708            offset: usize,
24709            mut depth: fidl::encoding::Depth,
24710        ) -> fidl::Result<()> {
24711            decoder.debug_check_bounds::<Self>(offset);
24712            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
24713                None => return Err(fidl::Error::NotNullable),
24714                Some(len) => len,
24715            };
24716            // Calling decoder.out_of_line_offset(0) is not allowed.
24717            if len == 0 {
24718                return Ok(());
24719            };
24720            depth.increment()?;
24721            let envelope_size = 8;
24722            let bytes_len = len * envelope_size;
24723            let offset = decoder.out_of_line_offset(bytes_len)?;
24724            // Decode the envelope for each type.
24725            let mut _next_ordinal_to_read = 0;
24726            let mut next_offset = offset;
24727            let end_offset = offset + bytes_len;
24728            _next_ordinal_to_read += 1;
24729            if next_offset >= end_offset {
24730                return Ok(());
24731            }
24732
24733            // Decode unknown envelopes for gaps in ordinals.
24734            while _next_ordinal_to_read < 1 {
24735                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24736                _next_ordinal_to_read += 1;
24737                next_offset += envelope_size;
24738            }
24739
24740            let next_out_of_line = decoder.next_out_of_line();
24741            let handles_before = decoder.remaining_handles();
24742            if let Some((inlined, num_bytes, num_handles)) =
24743                fidl::encoding::decode_envelope_header(decoder, next_offset)?
24744            {
24745                let member_inline_size =
24746                    <Ref as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24747                if inlined != (member_inline_size <= 4) {
24748                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
24749                }
24750                let inner_offset;
24751                let mut inner_depth = depth.clone();
24752                if inlined {
24753                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24754                    inner_offset = next_offset;
24755                } else {
24756                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24757                    inner_depth.increment()?;
24758                }
24759                let val_ref = self.source.get_or_insert_with(|| fidl::new_empty!(Ref, D));
24760                fidl::decode!(Ref, D, val_ref, decoder, inner_offset, inner_depth)?;
24761                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24762                {
24763                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
24764                }
24765                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24766                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24767                }
24768            }
24769
24770            next_offset += envelope_size;
24771            _next_ordinal_to_read += 1;
24772            if next_offset >= end_offset {
24773                return Ok(());
24774            }
24775
24776            // Decode unknown envelopes for gaps in ordinals.
24777            while _next_ordinal_to_read < 2 {
24778                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24779                _next_ordinal_to_read += 1;
24780                next_offset += envelope_size;
24781            }
24782
24783            let next_out_of_line = decoder.next_out_of_line();
24784            let handles_before = decoder.remaining_handles();
24785            if let Some((inlined, num_bytes, num_handles)) =
24786                fidl::encoding::decode_envelope_header(decoder, next_offset)?
24787            {
24788                let member_inline_size =
24789                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
24790                        decoder.context,
24791                    );
24792                if inlined != (member_inline_size <= 4) {
24793                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
24794                }
24795                let inner_offset;
24796                let mut inner_depth = depth.clone();
24797                if inlined {
24798                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24799                    inner_offset = next_offset;
24800                } else {
24801                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24802                    inner_depth.increment()?;
24803                }
24804                let val_ref = self
24805                    .source_name
24806                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
24807                fidl::decode!(
24808                    fidl::encoding::BoundedString<100>,
24809                    D,
24810                    val_ref,
24811                    decoder,
24812                    inner_offset,
24813                    inner_depth
24814                )?;
24815                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24816                {
24817                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
24818                }
24819                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24820                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24821                }
24822            }
24823
24824            next_offset += envelope_size;
24825            _next_ordinal_to_read += 1;
24826            if next_offset >= end_offset {
24827                return Ok(());
24828            }
24829
24830            // Decode unknown envelopes for gaps in ordinals.
24831            while _next_ordinal_to_read < 3 {
24832                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24833                _next_ordinal_to_read += 1;
24834                next_offset += envelope_size;
24835            }
24836
24837            let next_out_of_line = decoder.next_out_of_line();
24838            let handles_before = decoder.remaining_handles();
24839            if let Some((inlined, num_bytes, num_handles)) =
24840                fidl::encoding::decode_envelope_header(decoder, next_offset)?
24841            {
24842                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24843                if inlined != (member_inline_size <= 4) {
24844                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
24845                }
24846                let inner_offset;
24847                let mut inner_depth = depth.clone();
24848                if inlined {
24849                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24850                    inner_offset = next_offset;
24851                } else {
24852                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24853                    inner_depth.increment()?;
24854                }
24855                let val_ref = self.target_path.get_or_insert_with(|| {
24856                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
24857                });
24858                fidl::decode!(
24859                    fidl::encoding::BoundedString<1024>,
24860                    D,
24861                    val_ref,
24862                    decoder,
24863                    inner_offset,
24864                    inner_depth
24865                )?;
24866                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24867                {
24868                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
24869                }
24870                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24871                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24872                }
24873            }
24874
24875            next_offset += envelope_size;
24876            _next_ordinal_to_read += 1;
24877            if next_offset >= end_offset {
24878                return Ok(());
24879            }
24880
24881            // Decode unknown envelopes for gaps in ordinals.
24882            while _next_ordinal_to_read < 4 {
24883                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24884                _next_ordinal_to_read += 1;
24885                next_offset += envelope_size;
24886            }
24887
24888            let next_out_of_line = decoder.next_out_of_line();
24889            let handles_before = decoder.remaining_handles();
24890            if let Some((inlined, num_bytes, num_handles)) =
24891                fidl::encoding::decode_envelope_header(decoder, next_offset)?
24892            {
24893                let member_inline_size =
24894                    <DependencyType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24895                if inlined != (member_inline_size <= 4) {
24896                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
24897                }
24898                let inner_offset;
24899                let mut inner_depth = depth.clone();
24900                if inlined {
24901                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24902                    inner_offset = next_offset;
24903                } else {
24904                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24905                    inner_depth.increment()?;
24906                }
24907                let val_ref =
24908                    self.dependency_type.get_or_insert_with(|| fidl::new_empty!(DependencyType, D));
24909                fidl::decode!(DependencyType, D, val_ref, decoder, inner_offset, inner_depth)?;
24910                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24911                {
24912                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
24913                }
24914                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24915                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24916                }
24917            }
24918
24919            next_offset += envelope_size;
24920            _next_ordinal_to_read += 1;
24921            if next_offset >= end_offset {
24922                return Ok(());
24923            }
24924
24925            // Decode unknown envelopes for gaps in ordinals.
24926            while _next_ordinal_to_read < 5 {
24927                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24928                _next_ordinal_to_read += 1;
24929                next_offset += envelope_size;
24930            }
24931
24932            let next_out_of_line = decoder.next_out_of_line();
24933            let handles_before = decoder.remaining_handles();
24934            if let Some((inlined, num_bytes, num_handles)) =
24935                fidl::encoding::decode_envelope_header(decoder, next_offset)?
24936            {
24937                let member_inline_size =
24938                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24939                if inlined != (member_inline_size <= 4) {
24940                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
24941                }
24942                let inner_offset;
24943                let mut inner_depth = depth.clone();
24944                if inlined {
24945                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24946                    inner_offset = next_offset;
24947                } else {
24948                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24949                    inner_depth.increment()?;
24950                }
24951                let val_ref =
24952                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
24953                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
24954                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
24955                {
24956                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
24957                }
24958                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
24959                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
24960                }
24961            }
24962
24963            next_offset += envelope_size;
24964            _next_ordinal_to_read += 1;
24965            if next_offset >= end_offset {
24966                return Ok(());
24967            }
24968
24969            // Decode unknown envelopes for gaps in ordinals.
24970            while _next_ordinal_to_read < 6 {
24971                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
24972                _next_ordinal_to_read += 1;
24973                next_offset += envelope_size;
24974            }
24975
24976            let next_out_of_line = decoder.next_out_of_line();
24977            let handles_before = decoder.remaining_handles();
24978            if let Some((inlined, num_bytes, num_handles)) =
24979                fidl::encoding::decode_envelope_header(decoder, next_offset)?
24980            {
24981                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
24982                if inlined != (member_inline_size <= 4) {
24983                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
24984                }
24985                let inner_offset;
24986                let mut inner_depth = depth.clone();
24987                if inlined {
24988                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
24989                    inner_offset = next_offset;
24990                } else {
24991                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
24992                    inner_depth.increment()?;
24993                }
24994                let val_ref = self.source_dictionary.get_or_insert_with(|| {
24995                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
24996                });
24997                fidl::decode!(
24998                    fidl::encoding::BoundedString<1024>,
24999                    D,
25000                    val_ref,
25001                    decoder,
25002                    inner_offset,
25003                    inner_depth
25004                )?;
25005                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
25006                {
25007                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
25008                }
25009                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25010                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25011                }
25012            }
25013
25014            next_offset += envelope_size;
25015
25016            // Decode the remaining unknown envelopes.
25017            while next_offset < end_offset {
25018                _next_ordinal_to_read += 1;
25019                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
25020                next_offset += envelope_size;
25021            }
25022
25023            Ok(())
25024        }
25025    }
25026
25027    impl UseStorage {
25028        #[inline(always)]
25029        fn max_ordinal_present(&self) -> u64 {
25030            if let Some(_) = self.availability {
25031                return 3;
25032            }
25033            if let Some(_) = self.target_path {
25034                return 2;
25035            }
25036            if let Some(_) = self.source_name {
25037                return 1;
25038            }
25039            0
25040        }
25041    }
25042
25043    impl fidl::encoding::ValueTypeMarker for UseStorage {
25044        type Borrowed<'a> = &'a Self;
25045        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
25046            value
25047        }
25048    }
25049
25050    unsafe impl fidl::encoding::TypeMarker for UseStorage {
25051        type Owned = Self;
25052
25053        #[inline(always)]
25054        fn inline_align(_context: fidl::encoding::Context) -> usize {
25055            8
25056        }
25057
25058        #[inline(always)]
25059        fn inline_size(_context: fidl::encoding::Context) -> usize {
25060            16
25061        }
25062    }
25063
25064    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UseStorage, D>
25065        for &UseStorage
25066    {
25067        unsafe fn encode(
25068            self,
25069            encoder: &mut fidl::encoding::Encoder<'_, D>,
25070            offset: usize,
25071            mut depth: fidl::encoding::Depth,
25072        ) -> fidl::Result<()> {
25073            encoder.debug_check_bounds::<UseStorage>(offset);
25074            // Vector header
25075            let max_ordinal: u64 = self.max_ordinal_present();
25076            encoder.write_num(max_ordinal, offset);
25077            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
25078            // Calling encoder.out_of_line_offset(0) is not allowed.
25079            if max_ordinal == 0 {
25080                return Ok(());
25081            }
25082            depth.increment()?;
25083            let envelope_size = 8;
25084            let bytes_len = max_ordinal as usize * envelope_size;
25085            #[allow(unused_variables)]
25086            let offset = encoder.out_of_line_offset(bytes_len);
25087            let mut _prev_end_offset: usize = 0;
25088            if 1 > max_ordinal {
25089                return Ok(());
25090            }
25091
25092            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
25093            // are envelope_size bytes.
25094            let cur_offset: usize = (1 - 1) * envelope_size;
25095
25096            // Zero reserved fields.
25097            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
25098
25099            // Safety:
25100            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
25101            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
25102            //   envelope_size bytes, there is always sufficient room.
25103            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<100>, D>(
25104                self.source_name.as_ref().map(
25105                    <fidl::encoding::BoundedString<100> as fidl::encoding::ValueTypeMarker>::borrow,
25106                ),
25107                encoder,
25108                offset + cur_offset,
25109                depth,
25110            )?;
25111
25112            _prev_end_offset = cur_offset + envelope_size;
25113            if 2 > max_ordinal {
25114                return Ok(());
25115            }
25116
25117            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
25118            // are envelope_size bytes.
25119            let cur_offset: usize = (2 - 1) * envelope_size;
25120
25121            // Zero reserved fields.
25122            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
25123
25124            // Safety:
25125            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
25126            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
25127            //   envelope_size bytes, there is always sufficient room.
25128            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
25129            self.target_path.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
25130            encoder, offset + cur_offset, depth
25131        )?;
25132
25133            _prev_end_offset = cur_offset + envelope_size;
25134            if 3 > max_ordinal {
25135                return Ok(());
25136            }
25137
25138            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
25139            // are envelope_size bytes.
25140            let cur_offset: usize = (3 - 1) * envelope_size;
25141
25142            // Zero reserved fields.
25143            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
25144
25145            // Safety:
25146            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
25147            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
25148            //   envelope_size bytes, there is always sufficient room.
25149            fidl::encoding::encode_in_envelope_optional::<Availability, D>(
25150                self.availability
25151                    .as_ref()
25152                    .map(<Availability as fidl::encoding::ValueTypeMarker>::borrow),
25153                encoder,
25154                offset + cur_offset,
25155                depth,
25156            )?;
25157
25158            _prev_end_offset = cur_offset + envelope_size;
25159
25160            Ok(())
25161        }
25162    }
25163
25164    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UseStorage {
25165        #[inline(always)]
25166        fn new_empty() -> Self {
25167            Self::default()
25168        }
25169
25170        unsafe fn decode(
25171            &mut self,
25172            decoder: &mut fidl::encoding::Decoder<'_, D>,
25173            offset: usize,
25174            mut depth: fidl::encoding::Depth,
25175        ) -> fidl::Result<()> {
25176            decoder.debug_check_bounds::<Self>(offset);
25177            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
25178                None => return Err(fidl::Error::NotNullable),
25179                Some(len) => len,
25180            };
25181            // Calling decoder.out_of_line_offset(0) is not allowed.
25182            if len == 0 {
25183                return Ok(());
25184            };
25185            depth.increment()?;
25186            let envelope_size = 8;
25187            let bytes_len = len * envelope_size;
25188            let offset = decoder.out_of_line_offset(bytes_len)?;
25189            // Decode the envelope for each type.
25190            let mut _next_ordinal_to_read = 0;
25191            let mut next_offset = offset;
25192            let end_offset = offset + bytes_len;
25193            _next_ordinal_to_read += 1;
25194            if next_offset >= end_offset {
25195                return Ok(());
25196            }
25197
25198            // Decode unknown envelopes for gaps in ordinals.
25199            while _next_ordinal_to_read < 1 {
25200                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
25201                _next_ordinal_to_read += 1;
25202                next_offset += envelope_size;
25203            }
25204
25205            let next_out_of_line = decoder.next_out_of_line();
25206            let handles_before = decoder.remaining_handles();
25207            if let Some((inlined, num_bytes, num_handles)) =
25208                fidl::encoding::decode_envelope_header(decoder, next_offset)?
25209            {
25210                let member_inline_size =
25211                    <fidl::encoding::BoundedString<100> as fidl::encoding::TypeMarker>::inline_size(
25212                        decoder.context,
25213                    );
25214                if inlined != (member_inline_size <= 4) {
25215                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
25216                }
25217                let inner_offset;
25218                let mut inner_depth = depth.clone();
25219                if inlined {
25220                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
25221                    inner_offset = next_offset;
25222                } else {
25223                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25224                    inner_depth.increment()?;
25225                }
25226                let val_ref = self
25227                    .source_name
25228                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<100>, D));
25229                fidl::decode!(
25230                    fidl::encoding::BoundedString<100>,
25231                    D,
25232                    val_ref,
25233                    decoder,
25234                    inner_offset,
25235                    inner_depth
25236                )?;
25237                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
25238                {
25239                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
25240                }
25241                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25242                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25243                }
25244            }
25245
25246            next_offset += envelope_size;
25247            _next_ordinal_to_read += 1;
25248            if next_offset >= end_offset {
25249                return Ok(());
25250            }
25251
25252            // Decode unknown envelopes for gaps in ordinals.
25253            while _next_ordinal_to_read < 2 {
25254                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
25255                _next_ordinal_to_read += 1;
25256                next_offset += envelope_size;
25257            }
25258
25259            let next_out_of_line = decoder.next_out_of_line();
25260            let handles_before = decoder.remaining_handles();
25261            if let Some((inlined, num_bytes, num_handles)) =
25262                fidl::encoding::decode_envelope_header(decoder, next_offset)?
25263            {
25264                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
25265                if inlined != (member_inline_size <= 4) {
25266                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
25267                }
25268                let inner_offset;
25269                let mut inner_depth = depth.clone();
25270                if inlined {
25271                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
25272                    inner_offset = next_offset;
25273                } else {
25274                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25275                    inner_depth.increment()?;
25276                }
25277                let val_ref = self.target_path.get_or_insert_with(|| {
25278                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
25279                });
25280                fidl::decode!(
25281                    fidl::encoding::BoundedString<1024>,
25282                    D,
25283                    val_ref,
25284                    decoder,
25285                    inner_offset,
25286                    inner_depth
25287                )?;
25288                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
25289                {
25290                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
25291                }
25292                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25293                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25294                }
25295            }
25296
25297            next_offset += envelope_size;
25298            _next_ordinal_to_read += 1;
25299            if next_offset >= end_offset {
25300                return Ok(());
25301            }
25302
25303            // Decode unknown envelopes for gaps in ordinals.
25304            while _next_ordinal_to_read < 3 {
25305                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
25306                _next_ordinal_to_read += 1;
25307                next_offset += envelope_size;
25308            }
25309
25310            let next_out_of_line = decoder.next_out_of_line();
25311            let handles_before = decoder.remaining_handles();
25312            if let Some((inlined, num_bytes, num_handles)) =
25313                fidl::encoding::decode_envelope_header(decoder, next_offset)?
25314            {
25315                let member_inline_size =
25316                    <Availability as fidl::encoding::TypeMarker>::inline_size(decoder.context);
25317                if inlined != (member_inline_size <= 4) {
25318                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
25319                }
25320                let inner_offset;
25321                let mut inner_depth = depth.clone();
25322                if inlined {
25323                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
25324                    inner_offset = next_offset;
25325                } else {
25326                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25327                    inner_depth.increment()?;
25328                }
25329                let val_ref =
25330                    self.availability.get_or_insert_with(|| fidl::new_empty!(Availability, D));
25331                fidl::decode!(Availability, D, val_ref, decoder, inner_offset, inner_depth)?;
25332                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
25333                {
25334                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
25335                }
25336                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25337                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25338                }
25339            }
25340
25341            next_offset += envelope_size;
25342
25343            // Decode the remaining unknown envelopes.
25344            while next_offset < end_offset {
25345                _next_ordinal_to_read += 1;
25346                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
25347                next_offset += envelope_size;
25348            }
25349
25350            Ok(())
25351        }
25352    }
25353
25354    impl fidl::encoding::ValueTypeMarker for Capability {
25355        type Borrowed<'a> = &'a Self;
25356        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
25357            value
25358        }
25359    }
25360
25361    unsafe impl fidl::encoding::TypeMarker for Capability {
25362        type Owned = Self;
25363
25364        #[inline(always)]
25365        fn inline_align(_context: fidl::encoding::Context) -> usize {
25366            8
25367        }
25368
25369        #[inline(always)]
25370        fn inline_size(_context: fidl::encoding::Context) -> usize {
25371            16
25372        }
25373    }
25374
25375    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Capability, D>
25376        for &Capability
25377    {
25378        #[inline]
25379        unsafe fn encode(
25380            self,
25381            encoder: &mut fidl::encoding::Encoder<'_, D>,
25382            offset: usize,
25383            _depth: fidl::encoding::Depth,
25384        ) -> fidl::Result<()> {
25385            encoder.debug_check_bounds::<Capability>(offset);
25386            encoder.write_num::<u64>(self.ordinal(), offset);
25387            match self {
25388                Capability::Service(ref val) => fidl::encoding::encode_in_envelope::<Service, D>(
25389                    <Service as fidl::encoding::ValueTypeMarker>::borrow(val),
25390                    encoder,
25391                    offset + 8,
25392                    _depth,
25393                ),
25394                Capability::Protocol(ref val) => fidl::encoding::encode_in_envelope::<Protocol, D>(
25395                    <Protocol as fidl::encoding::ValueTypeMarker>::borrow(val),
25396                    encoder,
25397                    offset + 8,
25398                    _depth,
25399                ),
25400                Capability::Directory(ref val) => {
25401                    fidl::encoding::encode_in_envelope::<Directory, D>(
25402                        <Directory as fidl::encoding::ValueTypeMarker>::borrow(val),
25403                        encoder,
25404                        offset + 8,
25405                        _depth,
25406                    )
25407                }
25408                Capability::Storage(ref val) => fidl::encoding::encode_in_envelope::<Storage, D>(
25409                    <Storage as fidl::encoding::ValueTypeMarker>::borrow(val),
25410                    encoder,
25411                    offset + 8,
25412                    _depth,
25413                ),
25414                Capability::Runner(ref val) => fidl::encoding::encode_in_envelope::<Runner, D>(
25415                    <Runner as fidl::encoding::ValueTypeMarker>::borrow(val),
25416                    encoder,
25417                    offset + 8,
25418                    _depth,
25419                ),
25420                Capability::Resolver(ref val) => fidl::encoding::encode_in_envelope::<Resolver, D>(
25421                    <Resolver as fidl::encoding::ValueTypeMarker>::borrow(val),
25422                    encoder,
25423                    offset + 8,
25424                    _depth,
25425                ),
25426                Capability::EventStream(ref val) => {
25427                    fidl::encoding::encode_in_envelope::<EventStream, D>(
25428                        <EventStream as fidl::encoding::ValueTypeMarker>::borrow(val),
25429                        encoder,
25430                        offset + 8,
25431                        _depth,
25432                    )
25433                }
25434                Capability::Dictionary(ref val) => {
25435                    fidl::encoding::encode_in_envelope::<Dictionary, D>(
25436                        <Dictionary as fidl::encoding::ValueTypeMarker>::borrow(val),
25437                        encoder,
25438                        offset + 8,
25439                        _depth,
25440                    )
25441                }
25442                Capability::Config(ref val) => {
25443                    fidl::encoding::encode_in_envelope::<Configuration, D>(
25444                        <Configuration as fidl::encoding::ValueTypeMarker>::borrow(val),
25445                        encoder,
25446                        offset + 8,
25447                        _depth,
25448                    )
25449                }
25450                Capability::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
25451            }
25452        }
25453    }
25454
25455    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Capability {
25456        #[inline(always)]
25457        fn new_empty() -> Self {
25458            Self::__SourceBreaking { unknown_ordinal: 0 }
25459        }
25460
25461        #[inline]
25462        unsafe fn decode(
25463            &mut self,
25464            decoder: &mut fidl::encoding::Decoder<'_, D>,
25465            offset: usize,
25466            mut depth: fidl::encoding::Depth,
25467        ) -> fidl::Result<()> {
25468            decoder.debug_check_bounds::<Self>(offset);
25469            #[allow(unused_variables)]
25470            let next_out_of_line = decoder.next_out_of_line();
25471            let handles_before = decoder.remaining_handles();
25472            let (ordinal, inlined, num_bytes, num_handles) =
25473                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
25474
25475            let member_inline_size = match ordinal {
25476                1 => <Service as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25477                2 => <Protocol as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25478                3 => <Directory as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25479                4 => <Storage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25480                5 => <Runner as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25481                6 => <Resolver as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25482                8 => <EventStream as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25483                9 => <Dictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25484                10 => <Configuration as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25485                0 => return Err(fidl::Error::UnknownUnionTag),
25486                _ => num_bytes as usize,
25487            };
25488
25489            if inlined != (member_inline_size <= 4) {
25490                return Err(fidl::Error::InvalidInlineBitInEnvelope);
25491            }
25492            let _inner_offset;
25493            if inlined {
25494                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
25495                _inner_offset = offset + 8;
25496            } else {
25497                depth.increment()?;
25498                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25499            }
25500            match ordinal {
25501                1 => {
25502                    #[allow(irrefutable_let_patterns)]
25503                    if let Capability::Service(_) = self {
25504                        // Do nothing, read the value into the object
25505                    } else {
25506                        // Initialize `self` to the right variant
25507                        *self = Capability::Service(fidl::new_empty!(Service, D));
25508                    }
25509                    #[allow(irrefutable_let_patterns)]
25510                    if let Capability::Service(ref mut val) = self {
25511                        fidl::decode!(Service, D, val, decoder, _inner_offset, depth)?;
25512                    } else {
25513                        unreachable!()
25514                    }
25515                }
25516                2 => {
25517                    #[allow(irrefutable_let_patterns)]
25518                    if let Capability::Protocol(_) = self {
25519                        // Do nothing, read the value into the object
25520                    } else {
25521                        // Initialize `self` to the right variant
25522                        *self = Capability::Protocol(fidl::new_empty!(Protocol, D));
25523                    }
25524                    #[allow(irrefutable_let_patterns)]
25525                    if let Capability::Protocol(ref mut val) = self {
25526                        fidl::decode!(Protocol, D, val, decoder, _inner_offset, depth)?;
25527                    } else {
25528                        unreachable!()
25529                    }
25530                }
25531                3 => {
25532                    #[allow(irrefutable_let_patterns)]
25533                    if let Capability::Directory(_) = self {
25534                        // Do nothing, read the value into the object
25535                    } else {
25536                        // Initialize `self` to the right variant
25537                        *self = Capability::Directory(fidl::new_empty!(Directory, D));
25538                    }
25539                    #[allow(irrefutable_let_patterns)]
25540                    if let Capability::Directory(ref mut val) = self {
25541                        fidl::decode!(Directory, D, val, decoder, _inner_offset, depth)?;
25542                    } else {
25543                        unreachable!()
25544                    }
25545                }
25546                4 => {
25547                    #[allow(irrefutable_let_patterns)]
25548                    if let Capability::Storage(_) = self {
25549                        // Do nothing, read the value into the object
25550                    } else {
25551                        // Initialize `self` to the right variant
25552                        *self = Capability::Storage(fidl::new_empty!(Storage, D));
25553                    }
25554                    #[allow(irrefutable_let_patterns)]
25555                    if let Capability::Storage(ref mut val) = self {
25556                        fidl::decode!(Storage, D, val, decoder, _inner_offset, depth)?;
25557                    } else {
25558                        unreachable!()
25559                    }
25560                }
25561                5 => {
25562                    #[allow(irrefutable_let_patterns)]
25563                    if let Capability::Runner(_) = self {
25564                        // Do nothing, read the value into the object
25565                    } else {
25566                        // Initialize `self` to the right variant
25567                        *self = Capability::Runner(fidl::new_empty!(Runner, D));
25568                    }
25569                    #[allow(irrefutable_let_patterns)]
25570                    if let Capability::Runner(ref mut val) = self {
25571                        fidl::decode!(Runner, D, val, decoder, _inner_offset, depth)?;
25572                    } else {
25573                        unreachable!()
25574                    }
25575                }
25576                6 => {
25577                    #[allow(irrefutable_let_patterns)]
25578                    if let Capability::Resolver(_) = self {
25579                        // Do nothing, read the value into the object
25580                    } else {
25581                        // Initialize `self` to the right variant
25582                        *self = Capability::Resolver(fidl::new_empty!(Resolver, D));
25583                    }
25584                    #[allow(irrefutable_let_patterns)]
25585                    if let Capability::Resolver(ref mut val) = self {
25586                        fidl::decode!(Resolver, D, val, decoder, _inner_offset, depth)?;
25587                    } else {
25588                        unreachable!()
25589                    }
25590                }
25591                8 => {
25592                    #[allow(irrefutable_let_patterns)]
25593                    if let Capability::EventStream(_) = self {
25594                        // Do nothing, read the value into the object
25595                    } else {
25596                        // Initialize `self` to the right variant
25597                        *self = Capability::EventStream(fidl::new_empty!(EventStream, D));
25598                    }
25599                    #[allow(irrefutable_let_patterns)]
25600                    if let Capability::EventStream(ref mut val) = self {
25601                        fidl::decode!(EventStream, D, val, decoder, _inner_offset, depth)?;
25602                    } else {
25603                        unreachable!()
25604                    }
25605                }
25606                9 => {
25607                    #[allow(irrefutable_let_patterns)]
25608                    if let Capability::Dictionary(_) = self {
25609                        // Do nothing, read the value into the object
25610                    } else {
25611                        // Initialize `self` to the right variant
25612                        *self = Capability::Dictionary(fidl::new_empty!(Dictionary, D));
25613                    }
25614                    #[allow(irrefutable_let_patterns)]
25615                    if let Capability::Dictionary(ref mut val) = self {
25616                        fidl::decode!(Dictionary, D, val, decoder, _inner_offset, depth)?;
25617                    } else {
25618                        unreachable!()
25619                    }
25620                }
25621                10 => {
25622                    #[allow(irrefutable_let_patterns)]
25623                    if let Capability::Config(_) = self {
25624                        // Do nothing, read the value into the object
25625                    } else {
25626                        // Initialize `self` to the right variant
25627                        *self = Capability::Config(fidl::new_empty!(Configuration, D));
25628                    }
25629                    #[allow(irrefutable_let_patterns)]
25630                    if let Capability::Config(ref mut val) = self {
25631                        fidl::decode!(Configuration, D, val, decoder, _inner_offset, depth)?;
25632                    } else {
25633                        unreachable!()
25634                    }
25635                }
25636                #[allow(deprecated)]
25637                ordinal => {
25638                    for _ in 0..num_handles {
25639                        decoder.drop_next_handle()?;
25640                    }
25641                    *self = Capability::__SourceBreaking { unknown_ordinal: ordinal };
25642                }
25643            }
25644            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
25645                return Err(fidl::Error::InvalidNumBytesInEnvelope);
25646            }
25647            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25648                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25649            }
25650            Ok(())
25651        }
25652    }
25653
25654    impl fidl::encoding::ValueTypeMarker for ConfigChecksum {
25655        type Borrowed<'a> = &'a Self;
25656        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
25657            value
25658        }
25659    }
25660
25661    unsafe impl fidl::encoding::TypeMarker for ConfigChecksum {
25662        type Owned = Self;
25663
25664        #[inline(always)]
25665        fn inline_align(_context: fidl::encoding::Context) -> usize {
25666            8
25667        }
25668
25669        #[inline(always)]
25670        fn inline_size(_context: fidl::encoding::Context) -> usize {
25671            16
25672        }
25673    }
25674
25675    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigChecksum, D>
25676        for &ConfigChecksum
25677    {
25678        #[inline]
25679        unsafe fn encode(
25680            self,
25681            encoder: &mut fidl::encoding::Encoder<'_, D>,
25682            offset: usize,
25683            _depth: fidl::encoding::Depth,
25684        ) -> fidl::Result<()> {
25685            encoder.debug_check_bounds::<ConfigChecksum>(offset);
25686            encoder.write_num::<u64>(self.ordinal(), offset);
25687            match self {
25688                ConfigChecksum::Sha256(ref val) => fidl::encoding::encode_in_envelope::<
25689                    fidl::encoding::Array<u8, 32>,
25690                    D,
25691                >(
25692                    <fidl::encoding::Array<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow(val),
25693                    encoder,
25694                    offset + 8,
25695                    _depth,
25696                ),
25697                ConfigChecksum::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
25698            }
25699        }
25700    }
25701
25702    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigChecksum {
25703        #[inline(always)]
25704        fn new_empty() -> Self {
25705            Self::__SourceBreaking { unknown_ordinal: 0 }
25706        }
25707
25708        #[inline]
25709        unsafe fn decode(
25710            &mut self,
25711            decoder: &mut fidl::encoding::Decoder<'_, D>,
25712            offset: usize,
25713            mut depth: fidl::encoding::Depth,
25714        ) -> fidl::Result<()> {
25715            decoder.debug_check_bounds::<Self>(offset);
25716            #[allow(unused_variables)]
25717            let next_out_of_line = decoder.next_out_of_line();
25718            let handles_before = decoder.remaining_handles();
25719            let (ordinal, inlined, num_bytes, num_handles) =
25720                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
25721
25722            let member_inline_size = match ordinal {
25723                1 => <fidl::encoding::Array<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
25724                    decoder.context,
25725                ),
25726                0 => return Err(fidl::Error::UnknownUnionTag),
25727                _ => num_bytes as usize,
25728            };
25729
25730            if inlined != (member_inline_size <= 4) {
25731                return Err(fidl::Error::InvalidInlineBitInEnvelope);
25732            }
25733            let _inner_offset;
25734            if inlined {
25735                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
25736                _inner_offset = offset + 8;
25737            } else {
25738                depth.increment()?;
25739                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25740            }
25741            match ordinal {
25742                1 => {
25743                    #[allow(irrefutable_let_patterns)]
25744                    if let ConfigChecksum::Sha256(_) = self {
25745                        // Do nothing, read the value into the object
25746                    } else {
25747                        // Initialize `self` to the right variant
25748                        *self = ConfigChecksum::Sha256(
25749                            fidl::new_empty!(fidl::encoding::Array<u8, 32>, D),
25750                        );
25751                    }
25752                    #[allow(irrefutable_let_patterns)]
25753                    if let ConfigChecksum::Sha256(ref mut val) = self {
25754                        fidl::decode!(fidl::encoding::Array<u8, 32>, D, val, decoder, _inner_offset, depth)?;
25755                    } else {
25756                        unreachable!()
25757                    }
25758                }
25759                #[allow(deprecated)]
25760                ordinal => {
25761                    for _ in 0..num_handles {
25762                        decoder.drop_next_handle()?;
25763                    }
25764                    *self = ConfigChecksum::__SourceBreaking { unknown_ordinal: ordinal };
25765                }
25766            }
25767            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
25768                return Err(fidl::Error::InvalidNumBytesInEnvelope);
25769            }
25770            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
25771                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
25772            }
25773            Ok(())
25774        }
25775    }
25776
25777    impl fidl::encoding::ValueTypeMarker for ConfigSingleValue {
25778        type Borrowed<'a> = &'a Self;
25779        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
25780            value
25781        }
25782    }
25783
25784    unsafe impl fidl::encoding::TypeMarker for ConfigSingleValue {
25785        type Owned = Self;
25786
25787        #[inline(always)]
25788        fn inline_align(_context: fidl::encoding::Context) -> usize {
25789            8
25790        }
25791
25792        #[inline(always)]
25793        fn inline_size(_context: fidl::encoding::Context) -> usize {
25794            16
25795        }
25796    }
25797
25798    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigSingleValue, D>
25799        for &ConfigSingleValue
25800    {
25801        #[inline]
25802        unsafe fn encode(
25803            self,
25804            encoder: &mut fidl::encoding::Encoder<'_, D>,
25805            offset: usize,
25806            _depth: fidl::encoding::Depth,
25807        ) -> fidl::Result<()> {
25808            encoder.debug_check_bounds::<ConfigSingleValue>(offset);
25809            encoder.write_num::<u64>(self.ordinal(), offset);
25810            match self {
25811                ConfigSingleValue::Bool(ref val) => fidl::encoding::encode_in_envelope::<bool, D>(
25812                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
25813                    encoder,
25814                    offset + 8,
25815                    _depth,
25816                ),
25817                ConfigSingleValue::Uint8(ref val) => fidl::encoding::encode_in_envelope::<u8, D>(
25818                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
25819                    encoder,
25820                    offset + 8,
25821                    _depth,
25822                ),
25823                ConfigSingleValue::Uint16(ref val) => fidl::encoding::encode_in_envelope::<u16, D>(
25824                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
25825                    encoder,
25826                    offset + 8,
25827                    _depth,
25828                ),
25829                ConfigSingleValue::Uint32(ref val) => fidl::encoding::encode_in_envelope::<u32, D>(
25830                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
25831                    encoder,
25832                    offset + 8,
25833                    _depth,
25834                ),
25835                ConfigSingleValue::Uint64(ref val) => fidl::encoding::encode_in_envelope::<u64, D>(
25836                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
25837                    encoder,
25838                    offset + 8,
25839                    _depth,
25840                ),
25841                ConfigSingleValue::Int8(ref val) => fidl::encoding::encode_in_envelope::<i8, D>(
25842                    <i8 as fidl::encoding::ValueTypeMarker>::borrow(val),
25843                    encoder,
25844                    offset + 8,
25845                    _depth,
25846                ),
25847                ConfigSingleValue::Int16(ref val) => fidl::encoding::encode_in_envelope::<i16, D>(
25848                    <i16 as fidl::encoding::ValueTypeMarker>::borrow(val),
25849                    encoder,
25850                    offset + 8,
25851                    _depth,
25852                ),
25853                ConfigSingleValue::Int32(ref val) => fidl::encoding::encode_in_envelope::<i32, D>(
25854                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
25855                    encoder,
25856                    offset + 8,
25857                    _depth,
25858                ),
25859                ConfigSingleValue::Int64(ref val) => fidl::encoding::encode_in_envelope::<i64, D>(
25860                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
25861                    encoder,
25862                    offset + 8,
25863                    _depth,
25864                ),
25865                ConfigSingleValue::String(ref val) => fidl::encoding::encode_in_envelope::<
25866                    fidl::encoding::UnboundedString,
25867                    D,
25868                >(
25869                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
25870                        val,
25871                    ),
25872                    encoder,
25873                    offset + 8,
25874                    _depth,
25875                ),
25876                ConfigSingleValue::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
25877            }
25878        }
25879    }
25880
25881    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigSingleValue {
25882        #[inline(always)]
25883        fn new_empty() -> Self {
25884            Self::__SourceBreaking { unknown_ordinal: 0 }
25885        }
25886
25887        #[inline]
25888        unsafe fn decode(
25889            &mut self,
25890            decoder: &mut fidl::encoding::Decoder<'_, D>,
25891            offset: usize,
25892            mut depth: fidl::encoding::Depth,
25893        ) -> fidl::Result<()> {
25894            decoder.debug_check_bounds::<Self>(offset);
25895            #[allow(unused_variables)]
25896            let next_out_of_line = decoder.next_out_of_line();
25897            let handles_before = decoder.remaining_handles();
25898            let (ordinal, inlined, num_bytes, num_handles) =
25899                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
25900
25901            let member_inline_size = match ordinal {
25902                1 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25903                2 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25904                3 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25905                4 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25906                5 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25907                6 => <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25908                7 => <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25909                8 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25910                9 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
25911                10 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
25912                    decoder.context,
25913                ),
25914                0 => return Err(fidl::Error::UnknownUnionTag),
25915                _ => num_bytes as usize,
25916            };
25917
25918            if inlined != (member_inline_size <= 4) {
25919                return Err(fidl::Error::InvalidInlineBitInEnvelope);
25920            }
25921            let _inner_offset;
25922            if inlined {
25923                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
25924                _inner_offset = offset + 8;
25925            } else {
25926                depth.increment()?;
25927                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
25928            }
25929            match ordinal {
25930                1 => {
25931                    #[allow(irrefutable_let_patterns)]
25932                    if let ConfigSingleValue::Bool(_) = self {
25933                        // Do nothing, read the value into the object
25934                    } else {
25935                        // Initialize `self` to the right variant
25936                        *self = ConfigSingleValue::Bool(fidl::new_empty!(bool, D));
25937                    }
25938                    #[allow(irrefutable_let_patterns)]
25939                    if let ConfigSingleValue::Bool(ref mut val) = self {
25940                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
25941                    } else {
25942                        unreachable!()
25943                    }
25944                }
25945                2 => {
25946                    #[allow(irrefutable_let_patterns)]
25947                    if let ConfigSingleValue::Uint8(_) = self {
25948                        // Do nothing, read the value into the object
25949                    } else {
25950                        // Initialize `self` to the right variant
25951                        *self = ConfigSingleValue::Uint8(fidl::new_empty!(u8, D));
25952                    }
25953                    #[allow(irrefutable_let_patterns)]
25954                    if let ConfigSingleValue::Uint8(ref mut val) = self {
25955                        fidl::decode!(u8, D, val, decoder, _inner_offset, depth)?;
25956                    } else {
25957                        unreachable!()
25958                    }
25959                }
25960                3 => {
25961                    #[allow(irrefutable_let_patterns)]
25962                    if let ConfigSingleValue::Uint16(_) = self {
25963                        // Do nothing, read the value into the object
25964                    } else {
25965                        // Initialize `self` to the right variant
25966                        *self = ConfigSingleValue::Uint16(fidl::new_empty!(u16, D));
25967                    }
25968                    #[allow(irrefutable_let_patterns)]
25969                    if let ConfigSingleValue::Uint16(ref mut val) = self {
25970                        fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
25971                    } else {
25972                        unreachable!()
25973                    }
25974                }
25975                4 => {
25976                    #[allow(irrefutable_let_patterns)]
25977                    if let ConfigSingleValue::Uint32(_) = self {
25978                        // Do nothing, read the value into the object
25979                    } else {
25980                        // Initialize `self` to the right variant
25981                        *self = ConfigSingleValue::Uint32(fidl::new_empty!(u32, D));
25982                    }
25983                    #[allow(irrefutable_let_patterns)]
25984                    if let ConfigSingleValue::Uint32(ref mut val) = self {
25985                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
25986                    } else {
25987                        unreachable!()
25988                    }
25989                }
25990                5 => {
25991                    #[allow(irrefutable_let_patterns)]
25992                    if let ConfigSingleValue::Uint64(_) = self {
25993                        // Do nothing, read the value into the object
25994                    } else {
25995                        // Initialize `self` to the right variant
25996                        *self = ConfigSingleValue::Uint64(fidl::new_empty!(u64, D));
25997                    }
25998                    #[allow(irrefutable_let_patterns)]
25999                    if let ConfigSingleValue::Uint64(ref mut val) = self {
26000                        fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
26001                    } else {
26002                        unreachable!()
26003                    }
26004                }
26005                6 => {
26006                    #[allow(irrefutable_let_patterns)]
26007                    if let ConfigSingleValue::Int8(_) = self {
26008                        // Do nothing, read the value into the object
26009                    } else {
26010                        // Initialize `self` to the right variant
26011                        *self = ConfigSingleValue::Int8(fidl::new_empty!(i8, D));
26012                    }
26013                    #[allow(irrefutable_let_patterns)]
26014                    if let ConfigSingleValue::Int8(ref mut val) = self {
26015                        fidl::decode!(i8, D, val, decoder, _inner_offset, depth)?;
26016                    } else {
26017                        unreachable!()
26018                    }
26019                }
26020                7 => {
26021                    #[allow(irrefutable_let_patterns)]
26022                    if let ConfigSingleValue::Int16(_) = self {
26023                        // Do nothing, read the value into the object
26024                    } else {
26025                        // Initialize `self` to the right variant
26026                        *self = ConfigSingleValue::Int16(fidl::new_empty!(i16, D));
26027                    }
26028                    #[allow(irrefutable_let_patterns)]
26029                    if let ConfigSingleValue::Int16(ref mut val) = self {
26030                        fidl::decode!(i16, D, val, decoder, _inner_offset, depth)?;
26031                    } else {
26032                        unreachable!()
26033                    }
26034                }
26035                8 => {
26036                    #[allow(irrefutable_let_patterns)]
26037                    if let ConfigSingleValue::Int32(_) = self {
26038                        // Do nothing, read the value into the object
26039                    } else {
26040                        // Initialize `self` to the right variant
26041                        *self = ConfigSingleValue::Int32(fidl::new_empty!(i32, D));
26042                    }
26043                    #[allow(irrefutable_let_patterns)]
26044                    if let ConfigSingleValue::Int32(ref mut val) = self {
26045                        fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
26046                    } else {
26047                        unreachable!()
26048                    }
26049                }
26050                9 => {
26051                    #[allow(irrefutable_let_patterns)]
26052                    if let ConfigSingleValue::Int64(_) = self {
26053                        // Do nothing, read the value into the object
26054                    } else {
26055                        // Initialize `self` to the right variant
26056                        *self = ConfigSingleValue::Int64(fidl::new_empty!(i64, D));
26057                    }
26058                    #[allow(irrefutable_let_patterns)]
26059                    if let ConfigSingleValue::Int64(ref mut val) = self {
26060                        fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
26061                    } else {
26062                        unreachable!()
26063                    }
26064                }
26065                10 => {
26066                    #[allow(irrefutable_let_patterns)]
26067                    if let ConfigSingleValue::String(_) = self {
26068                        // Do nothing, read the value into the object
26069                    } else {
26070                        // Initialize `self` to the right variant
26071                        *self = ConfigSingleValue::String(fidl::new_empty!(
26072                            fidl::encoding::UnboundedString,
26073                            D
26074                        ));
26075                    }
26076                    #[allow(irrefutable_let_patterns)]
26077                    if let ConfigSingleValue::String(ref mut val) = self {
26078                        fidl::decode!(
26079                            fidl::encoding::UnboundedString,
26080                            D,
26081                            val,
26082                            decoder,
26083                            _inner_offset,
26084                            depth
26085                        )?;
26086                    } else {
26087                        unreachable!()
26088                    }
26089                }
26090                #[allow(deprecated)]
26091                ordinal => {
26092                    for _ in 0..num_handles {
26093                        decoder.drop_next_handle()?;
26094                    }
26095                    *self = ConfigSingleValue::__SourceBreaking { unknown_ordinal: ordinal };
26096                }
26097            }
26098            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
26099                return Err(fidl::Error::InvalidNumBytesInEnvelope);
26100            }
26101            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
26102                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
26103            }
26104            Ok(())
26105        }
26106    }
26107
26108    impl fidl::encoding::ValueTypeMarker for ConfigValue {
26109        type Borrowed<'a> = &'a Self;
26110        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
26111            value
26112        }
26113    }
26114
26115    unsafe impl fidl::encoding::TypeMarker for ConfigValue {
26116        type Owned = Self;
26117
26118        #[inline(always)]
26119        fn inline_align(_context: fidl::encoding::Context) -> usize {
26120            8
26121        }
26122
26123        #[inline(always)]
26124        fn inline_size(_context: fidl::encoding::Context) -> usize {
26125            16
26126        }
26127    }
26128
26129    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigValue, D>
26130        for &ConfigValue
26131    {
26132        #[inline]
26133        unsafe fn encode(
26134            self,
26135            encoder: &mut fidl::encoding::Encoder<'_, D>,
26136            offset: usize,
26137            _depth: fidl::encoding::Depth,
26138        ) -> fidl::Result<()> {
26139            encoder.debug_check_bounds::<ConfigValue>(offset);
26140            encoder.write_num::<u64>(self.ordinal(), offset);
26141            match self {
26142                ConfigValue::Single(ref val) => {
26143                    fidl::encoding::encode_in_envelope::<ConfigSingleValue, D>(
26144                        <ConfigSingleValue as fidl::encoding::ValueTypeMarker>::borrow(val),
26145                        encoder,
26146                        offset + 8,
26147                        _depth,
26148                    )
26149                }
26150                ConfigValue::Vector(ref val) => {
26151                    fidl::encoding::encode_in_envelope::<ConfigVectorValue, D>(
26152                        <ConfigVectorValue as fidl::encoding::ValueTypeMarker>::borrow(val),
26153                        encoder,
26154                        offset + 8,
26155                        _depth,
26156                    )
26157                }
26158                ConfigValue::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
26159            }
26160        }
26161    }
26162
26163    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigValue {
26164        #[inline(always)]
26165        fn new_empty() -> Self {
26166            Self::__SourceBreaking { unknown_ordinal: 0 }
26167        }
26168
26169        #[inline]
26170        unsafe fn decode(
26171            &mut self,
26172            decoder: &mut fidl::encoding::Decoder<'_, D>,
26173            offset: usize,
26174            mut depth: fidl::encoding::Depth,
26175        ) -> fidl::Result<()> {
26176            decoder.debug_check_bounds::<Self>(offset);
26177            #[allow(unused_variables)]
26178            let next_out_of_line = decoder.next_out_of_line();
26179            let handles_before = decoder.remaining_handles();
26180            let (ordinal, inlined, num_bytes, num_handles) =
26181                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
26182
26183            let member_inline_size = match ordinal {
26184                1 => {
26185                    <ConfigSingleValue as fidl::encoding::TypeMarker>::inline_size(decoder.context)
26186                }
26187                2 => {
26188                    <ConfigVectorValue as fidl::encoding::TypeMarker>::inline_size(decoder.context)
26189                }
26190                0 => return Err(fidl::Error::UnknownUnionTag),
26191                _ => num_bytes as usize,
26192            };
26193
26194            if inlined != (member_inline_size <= 4) {
26195                return Err(fidl::Error::InvalidInlineBitInEnvelope);
26196            }
26197            let _inner_offset;
26198            if inlined {
26199                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
26200                _inner_offset = offset + 8;
26201            } else {
26202                depth.increment()?;
26203                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
26204            }
26205            match ordinal {
26206                1 => {
26207                    #[allow(irrefutable_let_patterns)]
26208                    if let ConfigValue::Single(_) = self {
26209                        // Do nothing, read the value into the object
26210                    } else {
26211                        // Initialize `self` to the right variant
26212                        *self = ConfigValue::Single(fidl::new_empty!(ConfigSingleValue, D));
26213                    }
26214                    #[allow(irrefutable_let_patterns)]
26215                    if let ConfigValue::Single(ref mut val) = self {
26216                        fidl::decode!(ConfigSingleValue, D, val, decoder, _inner_offset, depth)?;
26217                    } else {
26218                        unreachable!()
26219                    }
26220                }
26221                2 => {
26222                    #[allow(irrefutable_let_patterns)]
26223                    if let ConfigValue::Vector(_) = self {
26224                        // Do nothing, read the value into the object
26225                    } else {
26226                        // Initialize `self` to the right variant
26227                        *self = ConfigValue::Vector(fidl::new_empty!(ConfigVectorValue, D));
26228                    }
26229                    #[allow(irrefutable_let_patterns)]
26230                    if let ConfigValue::Vector(ref mut val) = self {
26231                        fidl::decode!(ConfigVectorValue, D, val, decoder, _inner_offset, depth)?;
26232                    } else {
26233                        unreachable!()
26234                    }
26235                }
26236                #[allow(deprecated)]
26237                ordinal => {
26238                    for _ in 0..num_handles {
26239                        decoder.drop_next_handle()?;
26240                    }
26241                    *self = ConfigValue::__SourceBreaking { unknown_ordinal: ordinal };
26242                }
26243            }
26244            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
26245                return Err(fidl::Error::InvalidNumBytesInEnvelope);
26246            }
26247            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
26248                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
26249            }
26250            Ok(())
26251        }
26252    }
26253
26254    impl fidl::encoding::ValueTypeMarker for ConfigValueSource {
26255        type Borrowed<'a> = &'a Self;
26256        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
26257            value
26258        }
26259    }
26260
26261    unsafe impl fidl::encoding::TypeMarker for ConfigValueSource {
26262        type Owned = Self;
26263
26264        #[inline(always)]
26265        fn inline_align(_context: fidl::encoding::Context) -> usize {
26266            8
26267        }
26268
26269        #[inline(always)]
26270        fn inline_size(_context: fidl::encoding::Context) -> usize {
26271            16
26272        }
26273    }
26274
26275    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigValueSource, D>
26276        for &ConfigValueSource
26277    {
26278        #[inline]
26279        unsafe fn encode(
26280            self,
26281            encoder: &mut fidl::encoding::Encoder<'_, D>,
26282            offset: usize,
26283            _depth: fidl::encoding::Depth,
26284        ) -> fidl::Result<()> {
26285            encoder.debug_check_bounds::<ConfigValueSource>(offset);
26286            encoder.write_num::<u64>(self.ordinal(), offset);
26287            match self {
26288                ConfigValueSource::PackagePath(ref val) => fidl::encoding::encode_in_envelope::<
26289                    fidl::encoding::UnboundedString,
26290                    D,
26291                >(
26292                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
26293                        val,
26294                    ),
26295                    encoder,
26296                    offset + 8,
26297                    _depth,
26298                ),
26299                ConfigValueSource::Capabilities(ref val) => {
26300                    fidl::encoding::encode_in_envelope::<ConfigSourceCapabilities, D>(
26301                        <ConfigSourceCapabilities as fidl::encoding::ValueTypeMarker>::borrow(val),
26302                        encoder,
26303                        offset + 8,
26304                        _depth,
26305                    )
26306                }
26307                ConfigValueSource::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
26308            }
26309        }
26310    }
26311
26312    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigValueSource {
26313        #[inline(always)]
26314        fn new_empty() -> Self {
26315            Self::__SourceBreaking { unknown_ordinal: 0 }
26316        }
26317
26318        #[inline]
26319        unsafe fn decode(
26320            &mut self,
26321            decoder: &mut fidl::encoding::Decoder<'_, D>,
26322            offset: usize,
26323            mut depth: fidl::encoding::Depth,
26324        ) -> fidl::Result<()> {
26325            decoder.debug_check_bounds::<Self>(offset);
26326            #[allow(unused_variables)]
26327            let next_out_of_line = decoder.next_out_of_line();
26328            let handles_before = decoder.remaining_handles();
26329            let (ordinal, inlined, num_bytes, num_handles) =
26330                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
26331
26332            let member_inline_size = match ordinal {
26333                1 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
26334                    decoder.context,
26335                ),
26336                2 => <ConfigSourceCapabilities as fidl::encoding::TypeMarker>::inline_size(
26337                    decoder.context,
26338                ),
26339                0 => return Err(fidl::Error::UnknownUnionTag),
26340                _ => num_bytes as usize,
26341            };
26342
26343            if inlined != (member_inline_size <= 4) {
26344                return Err(fidl::Error::InvalidInlineBitInEnvelope);
26345            }
26346            let _inner_offset;
26347            if inlined {
26348                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
26349                _inner_offset = offset + 8;
26350            } else {
26351                depth.increment()?;
26352                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
26353            }
26354            match ordinal {
26355                1 => {
26356                    #[allow(irrefutable_let_patterns)]
26357                    if let ConfigValueSource::PackagePath(_) = self {
26358                        // Do nothing, read the value into the object
26359                    } else {
26360                        // Initialize `self` to the right variant
26361                        *self = ConfigValueSource::PackagePath(fidl::new_empty!(
26362                            fidl::encoding::UnboundedString,
26363                            D
26364                        ));
26365                    }
26366                    #[allow(irrefutable_let_patterns)]
26367                    if let ConfigValueSource::PackagePath(ref mut val) = self {
26368                        fidl::decode!(
26369                            fidl::encoding::UnboundedString,
26370                            D,
26371                            val,
26372                            decoder,
26373                            _inner_offset,
26374                            depth
26375                        )?;
26376                    } else {
26377                        unreachable!()
26378                    }
26379                }
26380                2 => {
26381                    #[allow(irrefutable_let_patterns)]
26382                    if let ConfigValueSource::Capabilities(_) = self {
26383                        // Do nothing, read the value into the object
26384                    } else {
26385                        // Initialize `self` to the right variant
26386                        *self = ConfigValueSource::Capabilities(fidl::new_empty!(
26387                            ConfigSourceCapabilities,
26388                            D
26389                        ));
26390                    }
26391                    #[allow(irrefutable_let_patterns)]
26392                    if let ConfigValueSource::Capabilities(ref mut val) = self {
26393                        fidl::decode!(
26394                            ConfigSourceCapabilities,
26395                            D,
26396                            val,
26397                            decoder,
26398                            _inner_offset,
26399                            depth
26400                        )?;
26401                    } else {
26402                        unreachable!()
26403                    }
26404                }
26405                #[allow(deprecated)]
26406                ordinal => {
26407                    for _ in 0..num_handles {
26408                        decoder.drop_next_handle()?;
26409                    }
26410                    *self = ConfigValueSource::__SourceBreaking { unknown_ordinal: ordinal };
26411                }
26412            }
26413            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
26414                return Err(fidl::Error::InvalidNumBytesInEnvelope);
26415            }
26416            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
26417                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
26418            }
26419            Ok(())
26420        }
26421    }
26422
26423    impl fidl::encoding::ValueTypeMarker for ConfigVectorValue {
26424        type Borrowed<'a> = &'a Self;
26425        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
26426            value
26427        }
26428    }
26429
26430    unsafe impl fidl::encoding::TypeMarker for ConfigVectorValue {
26431        type Owned = Self;
26432
26433        #[inline(always)]
26434        fn inline_align(_context: fidl::encoding::Context) -> usize {
26435            8
26436        }
26437
26438        #[inline(always)]
26439        fn inline_size(_context: fidl::encoding::Context) -> usize {
26440            16
26441        }
26442    }
26443
26444    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConfigVectorValue, D>
26445        for &ConfigVectorValue
26446    {
26447        #[inline]
26448        unsafe fn encode(
26449            self,
26450            encoder: &mut fidl::encoding::Encoder<'_, D>,
26451            offset: usize,
26452            _depth: fidl::encoding::Depth,
26453        ) -> fidl::Result<()> {
26454            encoder.debug_check_bounds::<ConfigVectorValue>(offset);
26455            encoder.write_num::<u64>(self.ordinal(), offset);
26456            match self {
26457            ConfigVectorValue::BoolVector(ref val) => {
26458                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<bool>, D>(
26459                    <fidl::encoding::UnboundedVector<bool> as fidl::encoding::ValueTypeMarker>::borrow(val),
26460                    encoder, offset + 8, _depth
26461                )
26462            }
26463            ConfigVectorValue::Uint8Vector(ref val) => {
26464                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u8>, D>(
26465                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(val),
26466                    encoder, offset + 8, _depth
26467                )
26468            }
26469            ConfigVectorValue::Uint16Vector(ref val) => {
26470                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u16>, D>(
26471                    <fidl::encoding::UnboundedVector<u16> as fidl::encoding::ValueTypeMarker>::borrow(val),
26472                    encoder, offset + 8, _depth
26473                )
26474            }
26475            ConfigVectorValue::Uint32Vector(ref val) => {
26476                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u32>, D>(
26477                    <fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow(val),
26478                    encoder, offset + 8, _depth
26479                )
26480            }
26481            ConfigVectorValue::Uint64Vector(ref val) => {
26482                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u64>, D>(
26483                    <fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(val),
26484                    encoder, offset + 8, _depth
26485                )
26486            }
26487            ConfigVectorValue::Int8Vector(ref val) => {
26488                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<i8>, D>(
26489                    <fidl::encoding::UnboundedVector<i8> as fidl::encoding::ValueTypeMarker>::borrow(val),
26490                    encoder, offset + 8, _depth
26491                )
26492            }
26493            ConfigVectorValue::Int16Vector(ref val) => {
26494                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<i16>, D>(
26495                    <fidl::encoding::UnboundedVector<i16> as fidl::encoding::ValueTypeMarker>::borrow(val),
26496                    encoder, offset + 8, _depth
26497                )
26498            }
26499            ConfigVectorValue::Int32Vector(ref val) => {
26500                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<i32>, D>(
26501                    <fidl::encoding::UnboundedVector<i32> as fidl::encoding::ValueTypeMarker>::borrow(val),
26502                    encoder, offset + 8, _depth
26503                )
26504            }
26505            ConfigVectorValue::Int64Vector(ref val) => {
26506                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<i64>, D>(
26507                    <fidl::encoding::UnboundedVector<i64> as fidl::encoding::ValueTypeMarker>::borrow(val),
26508                    encoder, offset + 8, _depth
26509                )
26510            }
26511            ConfigVectorValue::StringVector(ref val) => {
26512                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>, D>(
26513                    <fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(val),
26514                    encoder, offset + 8, _depth
26515                )
26516            }
26517            ConfigVectorValue::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
26518        }
26519        }
26520    }
26521
26522    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConfigVectorValue {
26523        #[inline(always)]
26524        fn new_empty() -> Self {
26525            Self::__SourceBreaking { unknown_ordinal: 0 }
26526        }
26527
26528        #[inline]
26529        unsafe fn decode(
26530            &mut self,
26531            decoder: &mut fidl::encoding::Decoder<'_, D>,
26532            offset: usize,
26533            mut depth: fidl::encoding::Depth,
26534        ) -> fidl::Result<()> {
26535            decoder.debug_check_bounds::<Self>(offset);
26536            #[allow(unused_variables)]
26537            let next_out_of_line = decoder.next_out_of_line();
26538            let handles_before = decoder.remaining_handles();
26539            let (ordinal, inlined, num_bytes, num_handles) =
26540                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
26541
26542            let member_inline_size = match ordinal {
26543            1 => <fidl::encoding::UnboundedVector<bool> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26544            2 => <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26545            3 => <fidl::encoding::UnboundedVector<u16> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26546            4 => <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26547            5 => <fidl::encoding::UnboundedVector<u64> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26548            6 => <fidl::encoding::UnboundedVector<i8> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26549            7 => <fidl::encoding::UnboundedVector<i16> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26550            8 => <fidl::encoding::UnboundedVector<i32> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26551            9 => <fidl::encoding::UnboundedVector<i64> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26552            10 => <fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
26553            0 => return Err(fidl::Error::UnknownUnionTag),
26554            _ => num_bytes as usize,
26555        };
26556
26557            if inlined != (member_inline_size <= 4) {
26558                return Err(fidl::Error::InvalidInlineBitInEnvelope);
26559            }
26560            let _inner_offset;
26561            if inlined {
26562                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
26563                _inner_offset = offset + 8;
26564            } else {
26565                depth.increment()?;
26566                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
26567            }
26568            match ordinal {
26569                1 => {
26570                    #[allow(irrefutable_let_patterns)]
26571                    if let ConfigVectorValue::BoolVector(_) = self {
26572                        // Do nothing, read the value into the object
26573                    } else {
26574                        // Initialize `self` to the right variant
26575                        *self = ConfigVectorValue::BoolVector(fidl::new_empty!(
26576                            fidl::encoding::UnboundedVector<bool>,
26577                            D
26578                        ));
26579                    }
26580                    #[allow(irrefutable_let_patterns)]
26581                    if let ConfigVectorValue::BoolVector(ref mut val) = self {
26582                        fidl::decode!(
26583                            fidl::encoding::UnboundedVector<bool>,
26584                            D,
26585                            val,
26586                            decoder,
26587                            _inner_offset,
26588                            depth
26589                        )?;
26590                    } else {
26591                        unreachable!()
26592                    }
26593                }
26594                2 => {
26595                    #[allow(irrefutable_let_patterns)]
26596                    if let ConfigVectorValue::Uint8Vector(_) = self {
26597                        // Do nothing, read the value into the object
26598                    } else {
26599                        // Initialize `self` to the right variant
26600                        *self = ConfigVectorValue::Uint8Vector(fidl::new_empty!(
26601                            fidl::encoding::UnboundedVector<u8>,
26602                            D
26603                        ));
26604                    }
26605                    #[allow(irrefutable_let_patterns)]
26606                    if let ConfigVectorValue::Uint8Vector(ref mut val) = self {
26607                        fidl::decode!(
26608                            fidl::encoding::UnboundedVector<u8>,
26609                            D,
26610                            val,
26611                            decoder,
26612                            _inner_offset,
26613                            depth
26614                        )?;
26615                    } else {
26616                        unreachable!()
26617                    }
26618                }
26619                3 => {
26620                    #[allow(irrefutable_let_patterns)]
26621                    if let ConfigVectorValue::Uint16Vector(_) = self {
26622                        // Do nothing, read the value into the object
26623                    } else {
26624                        // Initialize `self` to the right variant
26625                        *self = ConfigVectorValue::Uint16Vector(fidl::new_empty!(
26626                            fidl::encoding::UnboundedVector<u16>,
26627                            D
26628                        ));
26629                    }
26630                    #[allow(irrefutable_let_patterns)]
26631                    if let ConfigVectorValue::Uint16Vector(ref mut val) = self {
26632                        fidl::decode!(
26633                            fidl::encoding::UnboundedVector<u16>,
26634                            D,
26635                            val,
26636                            decoder,
26637                            _inner_offset,
26638                            depth
26639                        )?;
26640                    } else {
26641                        unreachable!()
26642                    }
26643                }
26644                4 => {
26645                    #[allow(irrefutable_let_patterns)]
26646                    if let ConfigVectorValue::Uint32Vector(_) = self {
26647                        // Do nothing, read the value into the object
26648                    } else {
26649                        // Initialize `self` to the right variant
26650                        *self = ConfigVectorValue::Uint32Vector(fidl::new_empty!(
26651                            fidl::encoding::UnboundedVector<u32>,
26652                            D
26653                        ));
26654                    }
26655                    #[allow(irrefutable_let_patterns)]
26656                    if let ConfigVectorValue::Uint32Vector(ref mut val) = self {
26657                        fidl::decode!(
26658                            fidl::encoding::UnboundedVector<u32>,
26659                            D,
26660                            val,
26661                            decoder,
26662                            _inner_offset,
26663                            depth
26664                        )?;
26665                    } else {
26666                        unreachable!()
26667                    }
26668                }
26669                5 => {
26670                    #[allow(irrefutable_let_patterns)]
26671                    if let ConfigVectorValue::Uint64Vector(_) = self {
26672                        // Do nothing, read the value into the object
26673                    } else {
26674                        // Initialize `self` to the right variant
26675                        *self = ConfigVectorValue::Uint64Vector(fidl::new_empty!(
26676                            fidl::encoding::UnboundedVector<u64>,
26677                            D
26678                        ));
26679                    }
26680                    #[allow(irrefutable_let_patterns)]
26681                    if let ConfigVectorValue::Uint64Vector(ref mut val) = self {
26682                        fidl::decode!(
26683                            fidl::encoding::UnboundedVector<u64>,
26684                            D,
26685                            val,
26686                            decoder,
26687                            _inner_offset,
26688                            depth
26689                        )?;
26690                    } else {
26691                        unreachable!()
26692                    }
26693                }
26694                6 => {
26695                    #[allow(irrefutable_let_patterns)]
26696                    if let ConfigVectorValue::Int8Vector(_) = self {
26697                        // Do nothing, read the value into the object
26698                    } else {
26699                        // Initialize `self` to the right variant
26700                        *self = ConfigVectorValue::Int8Vector(fidl::new_empty!(
26701                            fidl::encoding::UnboundedVector<i8>,
26702                            D
26703                        ));
26704                    }
26705                    #[allow(irrefutable_let_patterns)]
26706                    if let ConfigVectorValue::Int8Vector(ref mut val) = self {
26707                        fidl::decode!(
26708                            fidl::encoding::UnboundedVector<i8>,
26709                            D,
26710                            val,
26711                            decoder,
26712                            _inner_offset,
26713                            depth
26714                        )?;
26715                    } else {
26716                        unreachable!()
26717                    }
26718                }
26719                7 => {
26720                    #[allow(irrefutable_let_patterns)]
26721                    if let ConfigVectorValue::Int16Vector(_) = self {
26722                        // Do nothing, read the value into the object
26723                    } else {
26724                        // Initialize `self` to the right variant
26725                        *self = ConfigVectorValue::Int16Vector(fidl::new_empty!(
26726                            fidl::encoding::UnboundedVector<i16>,
26727                            D
26728                        ));
26729                    }
26730                    #[allow(irrefutable_let_patterns)]
26731                    if let ConfigVectorValue::Int16Vector(ref mut val) = self {
26732                        fidl::decode!(
26733                            fidl::encoding::UnboundedVector<i16>,
26734                            D,
26735                            val,
26736                            decoder,
26737                            _inner_offset,
26738                            depth
26739                        )?;
26740                    } else {
26741                        unreachable!()
26742                    }
26743                }
26744                8 => {
26745                    #[allow(irrefutable_let_patterns)]
26746                    if let ConfigVectorValue::Int32Vector(_) = self {
26747                        // Do nothing, read the value into the object
26748                    } else {
26749                        // Initialize `self` to the right variant
26750                        *self = ConfigVectorValue::Int32Vector(fidl::new_empty!(
26751                            fidl::encoding::UnboundedVector<i32>,
26752                            D
26753                        ));
26754                    }
26755                    #[allow(irrefutable_let_patterns)]
26756                    if let ConfigVectorValue::Int32Vector(ref mut val) = self {
26757                        fidl::decode!(
26758                            fidl::encoding::UnboundedVector<i32>,
26759                            D,
26760                            val,
26761                            decoder,
26762                            _inner_offset,
26763                            depth
26764                        )?;
26765                    } else {
26766                        unreachable!()
26767                    }
26768                }
26769                9 => {
26770                    #[allow(irrefutable_let_patterns)]
26771                    if let ConfigVectorValue::Int64Vector(_) = self {
26772                        // Do nothing, read the value into the object
26773                    } else {
26774                        // Initialize `self` to the right variant
26775                        *self = ConfigVectorValue::Int64Vector(fidl::new_empty!(
26776                            fidl::encoding::UnboundedVector<i64>,
26777                            D
26778                        ));
26779                    }
26780                    #[allow(irrefutable_let_patterns)]
26781                    if let ConfigVectorValue::Int64Vector(ref mut val) = self {
26782                        fidl::decode!(
26783                            fidl::encoding::UnboundedVector<i64>,
26784                            D,
26785                            val,
26786                            decoder,
26787                            _inner_offset,
26788                            depth
26789                        )?;
26790                    } else {
26791                        unreachable!()
26792                    }
26793                }
26794                10 => {
26795                    #[allow(irrefutable_let_patterns)]
26796                    if let ConfigVectorValue::StringVector(_) = self {
26797                        // Do nothing, read the value into the object
26798                    } else {
26799                        // Initialize `self` to the right variant
26800                        *self = ConfigVectorValue::StringVector(fidl::new_empty!(
26801                            fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
26802                            D
26803                        ));
26804                    }
26805                    #[allow(irrefutable_let_patterns)]
26806                    if let ConfigVectorValue::StringVector(ref mut val) = self {
26807                        fidl::decode!(
26808                            fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
26809                            D,
26810                            val,
26811                            decoder,
26812                            _inner_offset,
26813                            depth
26814                        )?;
26815                    } else {
26816                        unreachable!()
26817                    }
26818                }
26819                #[allow(deprecated)]
26820                ordinal => {
26821                    for _ in 0..num_handles {
26822                        decoder.drop_next_handle()?;
26823                    }
26824                    *self = ConfigVectorValue::__SourceBreaking { unknown_ordinal: ordinal };
26825                }
26826            }
26827            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
26828                return Err(fidl::Error::InvalidNumBytesInEnvelope);
26829            }
26830            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
26831                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
26832            }
26833            Ok(())
26834        }
26835    }
26836
26837    impl fidl::encoding::ValueTypeMarker for DebugRegistration {
26838        type Borrowed<'a> = &'a Self;
26839        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
26840            value
26841        }
26842    }
26843
26844    unsafe impl fidl::encoding::TypeMarker for DebugRegistration {
26845        type Owned = Self;
26846
26847        #[inline(always)]
26848        fn inline_align(_context: fidl::encoding::Context) -> usize {
26849            8
26850        }
26851
26852        #[inline(always)]
26853        fn inline_size(_context: fidl::encoding::Context) -> usize {
26854            16
26855        }
26856    }
26857
26858    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DebugRegistration, D>
26859        for &DebugRegistration
26860    {
26861        #[inline]
26862        unsafe fn encode(
26863            self,
26864            encoder: &mut fidl::encoding::Encoder<'_, D>,
26865            offset: usize,
26866            _depth: fidl::encoding::Depth,
26867        ) -> fidl::Result<()> {
26868            encoder.debug_check_bounds::<DebugRegistration>(offset);
26869            encoder.write_num::<u64>(self.ordinal(), offset);
26870            match self {
26871                DebugRegistration::Protocol(ref val) => {
26872                    fidl::encoding::encode_in_envelope::<DebugProtocolRegistration, D>(
26873                        <DebugProtocolRegistration as fidl::encoding::ValueTypeMarker>::borrow(val),
26874                        encoder,
26875                        offset + 8,
26876                        _depth,
26877                    )
26878                }
26879                DebugRegistration::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
26880            }
26881        }
26882    }
26883
26884    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DebugRegistration {
26885        #[inline(always)]
26886        fn new_empty() -> Self {
26887            Self::__SourceBreaking { unknown_ordinal: 0 }
26888        }
26889
26890        #[inline]
26891        unsafe fn decode(
26892            &mut self,
26893            decoder: &mut fidl::encoding::Decoder<'_, D>,
26894            offset: usize,
26895            mut depth: fidl::encoding::Depth,
26896        ) -> fidl::Result<()> {
26897            decoder.debug_check_bounds::<Self>(offset);
26898            #[allow(unused_variables)]
26899            let next_out_of_line = decoder.next_out_of_line();
26900            let handles_before = decoder.remaining_handles();
26901            let (ordinal, inlined, num_bytes, num_handles) =
26902                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
26903
26904            let member_inline_size = match ordinal {
26905                1 => <DebugProtocolRegistration as fidl::encoding::TypeMarker>::inline_size(
26906                    decoder.context,
26907                ),
26908                0 => return Err(fidl::Error::UnknownUnionTag),
26909                _ => num_bytes as usize,
26910            };
26911
26912            if inlined != (member_inline_size <= 4) {
26913                return Err(fidl::Error::InvalidInlineBitInEnvelope);
26914            }
26915            let _inner_offset;
26916            if inlined {
26917                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
26918                _inner_offset = offset + 8;
26919            } else {
26920                depth.increment()?;
26921                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
26922            }
26923            match ordinal {
26924                1 => {
26925                    #[allow(irrefutable_let_patterns)]
26926                    if let DebugRegistration::Protocol(_) = self {
26927                        // Do nothing, read the value into the object
26928                    } else {
26929                        // Initialize `self` to the right variant
26930                        *self = DebugRegistration::Protocol(fidl::new_empty!(
26931                            DebugProtocolRegistration,
26932                            D
26933                        ));
26934                    }
26935                    #[allow(irrefutable_let_patterns)]
26936                    if let DebugRegistration::Protocol(ref mut val) = self {
26937                        fidl::decode!(
26938                            DebugProtocolRegistration,
26939                            D,
26940                            val,
26941                            decoder,
26942                            _inner_offset,
26943                            depth
26944                        )?;
26945                    } else {
26946                        unreachable!()
26947                    }
26948                }
26949                #[allow(deprecated)]
26950                ordinal => {
26951                    for _ in 0..num_handles {
26952                        decoder.drop_next_handle()?;
26953                    }
26954                    *self = DebugRegistration::__SourceBreaking { unknown_ordinal: ordinal };
26955                }
26956            }
26957            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
26958                return Err(fidl::Error::InvalidNumBytesInEnvelope);
26959            }
26960            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
26961                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
26962            }
26963            Ok(())
26964        }
26965    }
26966
26967    impl fidl::encoding::ValueTypeMarker for Expose {
26968        type Borrowed<'a> = &'a Self;
26969        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
26970            value
26971        }
26972    }
26973
26974    unsafe impl fidl::encoding::TypeMarker for Expose {
26975        type Owned = Self;
26976
26977        #[inline(always)]
26978        fn inline_align(_context: fidl::encoding::Context) -> usize {
26979            8
26980        }
26981
26982        #[inline(always)]
26983        fn inline_size(_context: fidl::encoding::Context) -> usize {
26984            16
26985        }
26986    }
26987
26988    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Expose, D> for &Expose {
26989        #[inline]
26990        unsafe fn encode(
26991            self,
26992            encoder: &mut fidl::encoding::Encoder<'_, D>,
26993            offset: usize,
26994            _depth: fidl::encoding::Depth,
26995        ) -> fidl::Result<()> {
26996            encoder.debug_check_bounds::<Expose>(offset);
26997            encoder.write_num::<u64>(self.ordinal(), offset);
26998            match self {
26999                Expose::Service(ref val) => fidl::encoding::encode_in_envelope::<ExposeService, D>(
27000                    <ExposeService as fidl::encoding::ValueTypeMarker>::borrow(val),
27001                    encoder,
27002                    offset + 8,
27003                    _depth,
27004                ),
27005                Expose::Protocol(ref val) => {
27006                    fidl::encoding::encode_in_envelope::<ExposeProtocol, D>(
27007                        <ExposeProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
27008                        encoder,
27009                        offset + 8,
27010                        _depth,
27011                    )
27012                }
27013                Expose::Directory(ref val) => {
27014                    fidl::encoding::encode_in_envelope::<ExposeDirectory, D>(
27015                        <ExposeDirectory as fidl::encoding::ValueTypeMarker>::borrow(val),
27016                        encoder,
27017                        offset + 8,
27018                        _depth,
27019                    )
27020                }
27021                Expose::Runner(ref val) => fidl::encoding::encode_in_envelope::<ExposeRunner, D>(
27022                    <ExposeRunner as fidl::encoding::ValueTypeMarker>::borrow(val),
27023                    encoder,
27024                    offset + 8,
27025                    _depth,
27026                ),
27027                Expose::Resolver(ref val) => {
27028                    fidl::encoding::encode_in_envelope::<ExposeResolver, D>(
27029                        <ExposeResolver as fidl::encoding::ValueTypeMarker>::borrow(val),
27030                        encoder,
27031                        offset + 8,
27032                        _depth,
27033                    )
27034                }
27035                Expose::Dictionary(ref val) => {
27036                    fidl::encoding::encode_in_envelope::<ExposeDictionary, D>(
27037                        <ExposeDictionary as fidl::encoding::ValueTypeMarker>::borrow(val),
27038                        encoder,
27039                        offset + 8,
27040                        _depth,
27041                    )
27042                }
27043                Expose::Config(ref val) => {
27044                    fidl::encoding::encode_in_envelope::<ExposeConfiguration, D>(
27045                        <ExposeConfiguration as fidl::encoding::ValueTypeMarker>::borrow(val),
27046                        encoder,
27047                        offset + 8,
27048                        _depth,
27049                    )
27050                }
27051                Expose::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
27052            }
27053        }
27054    }
27055
27056    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Expose {
27057        #[inline(always)]
27058        fn new_empty() -> Self {
27059            Self::__SourceBreaking { unknown_ordinal: 0 }
27060        }
27061
27062        #[inline]
27063        unsafe fn decode(
27064            &mut self,
27065            decoder: &mut fidl::encoding::Decoder<'_, D>,
27066            offset: usize,
27067            mut depth: fidl::encoding::Depth,
27068        ) -> fidl::Result<()> {
27069            decoder.debug_check_bounds::<Self>(offset);
27070            #[allow(unused_variables)]
27071            let next_out_of_line = decoder.next_out_of_line();
27072            let handles_before = decoder.remaining_handles();
27073            let (ordinal, inlined, num_bytes, num_handles) =
27074                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
27075
27076            let member_inline_size = match ordinal {
27077                1 => <ExposeService as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27078                2 => <ExposeProtocol as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27079                3 => <ExposeDirectory as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27080                4 => <ExposeRunner as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27081                5 => <ExposeResolver as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27082                7 => <ExposeDictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27083                8 => <ExposeConfiguration as fidl::encoding::TypeMarker>::inline_size(
27084                    decoder.context,
27085                ),
27086                0 => return Err(fidl::Error::UnknownUnionTag),
27087                _ => num_bytes as usize,
27088            };
27089
27090            if inlined != (member_inline_size <= 4) {
27091                return Err(fidl::Error::InvalidInlineBitInEnvelope);
27092            }
27093            let _inner_offset;
27094            if inlined {
27095                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
27096                _inner_offset = offset + 8;
27097            } else {
27098                depth.increment()?;
27099                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
27100            }
27101            match ordinal {
27102                1 => {
27103                    #[allow(irrefutable_let_patterns)]
27104                    if let Expose::Service(_) = self {
27105                        // Do nothing, read the value into the object
27106                    } else {
27107                        // Initialize `self` to the right variant
27108                        *self = Expose::Service(fidl::new_empty!(ExposeService, D));
27109                    }
27110                    #[allow(irrefutable_let_patterns)]
27111                    if let Expose::Service(ref mut val) = self {
27112                        fidl::decode!(ExposeService, D, val, decoder, _inner_offset, depth)?;
27113                    } else {
27114                        unreachable!()
27115                    }
27116                }
27117                2 => {
27118                    #[allow(irrefutable_let_patterns)]
27119                    if let Expose::Protocol(_) = self {
27120                        // Do nothing, read the value into the object
27121                    } else {
27122                        // Initialize `self` to the right variant
27123                        *self = Expose::Protocol(fidl::new_empty!(ExposeProtocol, D));
27124                    }
27125                    #[allow(irrefutable_let_patterns)]
27126                    if let Expose::Protocol(ref mut val) = self {
27127                        fidl::decode!(ExposeProtocol, D, val, decoder, _inner_offset, depth)?;
27128                    } else {
27129                        unreachable!()
27130                    }
27131                }
27132                3 => {
27133                    #[allow(irrefutable_let_patterns)]
27134                    if let Expose::Directory(_) = self {
27135                        // Do nothing, read the value into the object
27136                    } else {
27137                        // Initialize `self` to the right variant
27138                        *self = Expose::Directory(fidl::new_empty!(ExposeDirectory, D));
27139                    }
27140                    #[allow(irrefutable_let_patterns)]
27141                    if let Expose::Directory(ref mut val) = self {
27142                        fidl::decode!(ExposeDirectory, D, val, decoder, _inner_offset, depth)?;
27143                    } else {
27144                        unreachable!()
27145                    }
27146                }
27147                4 => {
27148                    #[allow(irrefutable_let_patterns)]
27149                    if let Expose::Runner(_) = self {
27150                        // Do nothing, read the value into the object
27151                    } else {
27152                        // Initialize `self` to the right variant
27153                        *self = Expose::Runner(fidl::new_empty!(ExposeRunner, D));
27154                    }
27155                    #[allow(irrefutable_let_patterns)]
27156                    if let Expose::Runner(ref mut val) = self {
27157                        fidl::decode!(ExposeRunner, D, val, decoder, _inner_offset, depth)?;
27158                    } else {
27159                        unreachable!()
27160                    }
27161                }
27162                5 => {
27163                    #[allow(irrefutable_let_patterns)]
27164                    if let Expose::Resolver(_) = self {
27165                        // Do nothing, read the value into the object
27166                    } else {
27167                        // Initialize `self` to the right variant
27168                        *self = Expose::Resolver(fidl::new_empty!(ExposeResolver, D));
27169                    }
27170                    #[allow(irrefutable_let_patterns)]
27171                    if let Expose::Resolver(ref mut val) = self {
27172                        fidl::decode!(ExposeResolver, D, val, decoder, _inner_offset, depth)?;
27173                    } else {
27174                        unreachable!()
27175                    }
27176                }
27177                7 => {
27178                    #[allow(irrefutable_let_patterns)]
27179                    if let Expose::Dictionary(_) = self {
27180                        // Do nothing, read the value into the object
27181                    } else {
27182                        // Initialize `self` to the right variant
27183                        *self = Expose::Dictionary(fidl::new_empty!(ExposeDictionary, D));
27184                    }
27185                    #[allow(irrefutable_let_patterns)]
27186                    if let Expose::Dictionary(ref mut val) = self {
27187                        fidl::decode!(ExposeDictionary, D, val, decoder, _inner_offset, depth)?;
27188                    } else {
27189                        unreachable!()
27190                    }
27191                }
27192                8 => {
27193                    #[allow(irrefutable_let_patterns)]
27194                    if let Expose::Config(_) = self {
27195                        // Do nothing, read the value into the object
27196                    } else {
27197                        // Initialize `self` to the right variant
27198                        *self = Expose::Config(fidl::new_empty!(ExposeConfiguration, D));
27199                    }
27200                    #[allow(irrefutable_let_patterns)]
27201                    if let Expose::Config(ref mut val) = self {
27202                        fidl::decode!(ExposeConfiguration, D, val, decoder, _inner_offset, depth)?;
27203                    } else {
27204                        unreachable!()
27205                    }
27206                }
27207                #[allow(deprecated)]
27208                ordinal => {
27209                    for _ in 0..num_handles {
27210                        decoder.drop_next_handle()?;
27211                    }
27212                    *self = Expose::__SourceBreaking { unknown_ordinal: ordinal };
27213                }
27214            }
27215            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
27216                return Err(fidl::Error::InvalidNumBytesInEnvelope);
27217            }
27218            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
27219                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
27220            }
27221            Ok(())
27222        }
27223    }
27224
27225    impl fidl::encoding::ValueTypeMarker for LayoutConstraint {
27226        type Borrowed<'a> = &'a Self;
27227        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
27228            value
27229        }
27230    }
27231
27232    unsafe impl fidl::encoding::TypeMarker for LayoutConstraint {
27233        type Owned = Self;
27234
27235        #[inline(always)]
27236        fn inline_align(_context: fidl::encoding::Context) -> usize {
27237            8
27238        }
27239
27240        #[inline(always)]
27241        fn inline_size(_context: fidl::encoding::Context) -> usize {
27242            16
27243        }
27244    }
27245
27246    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LayoutConstraint, D>
27247        for &LayoutConstraint
27248    {
27249        #[inline]
27250        unsafe fn encode(
27251            self,
27252            encoder: &mut fidl::encoding::Encoder<'_, D>,
27253            offset: usize,
27254            _depth: fidl::encoding::Depth,
27255        ) -> fidl::Result<()> {
27256            encoder.debug_check_bounds::<LayoutConstraint>(offset);
27257            encoder.write_num::<u64>(self.ordinal(), offset);
27258            match self {
27259                LayoutConstraint::MaxSize(ref val) => fidl::encoding::encode_in_envelope::<u32, D>(
27260                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
27261                    encoder,
27262                    offset + 8,
27263                    _depth,
27264                ),
27265                LayoutConstraint::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
27266            }
27267        }
27268    }
27269
27270    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LayoutConstraint {
27271        #[inline(always)]
27272        fn new_empty() -> Self {
27273            Self::__SourceBreaking { unknown_ordinal: 0 }
27274        }
27275
27276        #[inline]
27277        unsafe fn decode(
27278            &mut self,
27279            decoder: &mut fidl::encoding::Decoder<'_, D>,
27280            offset: usize,
27281            mut depth: fidl::encoding::Depth,
27282        ) -> fidl::Result<()> {
27283            decoder.debug_check_bounds::<Self>(offset);
27284            #[allow(unused_variables)]
27285            let next_out_of_line = decoder.next_out_of_line();
27286            let handles_before = decoder.remaining_handles();
27287            let (ordinal, inlined, num_bytes, num_handles) =
27288                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
27289
27290            let member_inline_size = match ordinal {
27291                1 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27292                0 => return Err(fidl::Error::UnknownUnionTag),
27293                _ => num_bytes as usize,
27294            };
27295
27296            if inlined != (member_inline_size <= 4) {
27297                return Err(fidl::Error::InvalidInlineBitInEnvelope);
27298            }
27299            let _inner_offset;
27300            if inlined {
27301                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
27302                _inner_offset = offset + 8;
27303            } else {
27304                depth.increment()?;
27305                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
27306            }
27307            match ordinal {
27308                1 => {
27309                    #[allow(irrefutable_let_patterns)]
27310                    if let LayoutConstraint::MaxSize(_) = self {
27311                        // Do nothing, read the value into the object
27312                    } else {
27313                        // Initialize `self` to the right variant
27314                        *self = LayoutConstraint::MaxSize(fidl::new_empty!(u32, D));
27315                    }
27316                    #[allow(irrefutable_let_patterns)]
27317                    if let LayoutConstraint::MaxSize(ref mut val) = self {
27318                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
27319                    } else {
27320                        unreachable!()
27321                    }
27322                }
27323                #[allow(deprecated)]
27324                ordinal => {
27325                    for _ in 0..num_handles {
27326                        decoder.drop_next_handle()?;
27327                    }
27328                    *self = LayoutConstraint::__SourceBreaking { unknown_ordinal: ordinal };
27329                }
27330            }
27331            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
27332                return Err(fidl::Error::InvalidNumBytesInEnvelope);
27333            }
27334            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
27335                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
27336            }
27337            Ok(())
27338        }
27339    }
27340
27341    impl fidl::encoding::ValueTypeMarker for LayoutParameter {
27342        type Borrowed<'a> = &'a Self;
27343        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
27344            value
27345        }
27346    }
27347
27348    unsafe impl fidl::encoding::TypeMarker for LayoutParameter {
27349        type Owned = Self;
27350
27351        #[inline(always)]
27352        fn inline_align(_context: fidl::encoding::Context) -> usize {
27353            8
27354        }
27355
27356        #[inline(always)]
27357        fn inline_size(_context: fidl::encoding::Context) -> usize {
27358            16
27359        }
27360    }
27361
27362    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LayoutParameter, D>
27363        for &LayoutParameter
27364    {
27365        #[inline]
27366        unsafe fn encode(
27367            self,
27368            encoder: &mut fidl::encoding::Encoder<'_, D>,
27369            offset: usize,
27370            _depth: fidl::encoding::Depth,
27371        ) -> fidl::Result<()> {
27372            encoder.debug_check_bounds::<LayoutParameter>(offset);
27373            encoder.write_num::<u64>(self.ordinal(), offset);
27374            match self {
27375                LayoutParameter::NestedType(ref val) => {
27376                    fidl::encoding::encode_in_envelope::<ConfigType, D>(
27377                        <ConfigType as fidl::encoding::ValueTypeMarker>::borrow(val),
27378                        encoder,
27379                        offset + 8,
27380                        _depth,
27381                    )
27382                }
27383                LayoutParameter::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
27384            }
27385        }
27386    }
27387
27388    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LayoutParameter {
27389        #[inline(always)]
27390        fn new_empty() -> Self {
27391            Self::__SourceBreaking { unknown_ordinal: 0 }
27392        }
27393
27394        #[inline]
27395        unsafe fn decode(
27396            &mut self,
27397            decoder: &mut fidl::encoding::Decoder<'_, D>,
27398            offset: usize,
27399            mut depth: fidl::encoding::Depth,
27400        ) -> fidl::Result<()> {
27401            decoder.debug_check_bounds::<Self>(offset);
27402            #[allow(unused_variables)]
27403            let next_out_of_line = decoder.next_out_of_line();
27404            let handles_before = decoder.remaining_handles();
27405            let (ordinal, inlined, num_bytes, num_handles) =
27406                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
27407
27408            let member_inline_size = match ordinal {
27409                1 => <ConfigType as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27410                0 => return Err(fidl::Error::UnknownUnionTag),
27411                _ => num_bytes as usize,
27412            };
27413
27414            if inlined != (member_inline_size <= 4) {
27415                return Err(fidl::Error::InvalidInlineBitInEnvelope);
27416            }
27417            let _inner_offset;
27418            if inlined {
27419                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
27420                _inner_offset = offset + 8;
27421            } else {
27422                depth.increment()?;
27423                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
27424            }
27425            match ordinal {
27426                1 => {
27427                    #[allow(irrefutable_let_patterns)]
27428                    if let LayoutParameter::NestedType(_) = self {
27429                        // Do nothing, read the value into the object
27430                    } else {
27431                        // Initialize `self` to the right variant
27432                        *self = LayoutParameter::NestedType(fidl::new_empty!(ConfigType, D));
27433                    }
27434                    #[allow(irrefutable_let_patterns)]
27435                    if let LayoutParameter::NestedType(ref mut val) = self {
27436                        fidl::decode!(ConfigType, D, val, decoder, _inner_offset, depth)?;
27437                    } else {
27438                        unreachable!()
27439                    }
27440                }
27441                #[allow(deprecated)]
27442                ordinal => {
27443                    for _ in 0..num_handles {
27444                        decoder.drop_next_handle()?;
27445                    }
27446                    *self = LayoutParameter::__SourceBreaking { unknown_ordinal: ordinal };
27447                }
27448            }
27449            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
27450                return Err(fidl::Error::InvalidNumBytesInEnvelope);
27451            }
27452            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
27453                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
27454            }
27455            Ok(())
27456        }
27457    }
27458
27459    impl fidl::encoding::ValueTypeMarker for Offer {
27460        type Borrowed<'a> = &'a Self;
27461        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
27462            value
27463        }
27464    }
27465
27466    unsafe impl fidl::encoding::TypeMarker for Offer {
27467        type Owned = Self;
27468
27469        #[inline(always)]
27470        fn inline_align(_context: fidl::encoding::Context) -> usize {
27471            8
27472        }
27473
27474        #[inline(always)]
27475        fn inline_size(_context: fidl::encoding::Context) -> usize {
27476            16
27477        }
27478    }
27479
27480    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Offer, D> for &Offer {
27481        #[inline]
27482        unsafe fn encode(
27483            self,
27484            encoder: &mut fidl::encoding::Encoder<'_, D>,
27485            offset: usize,
27486            _depth: fidl::encoding::Depth,
27487        ) -> fidl::Result<()> {
27488            encoder.debug_check_bounds::<Offer>(offset);
27489            encoder.write_num::<u64>(self.ordinal(), offset);
27490            match self {
27491                Offer::Service(ref val) => fidl::encoding::encode_in_envelope::<OfferService, D>(
27492                    <OfferService as fidl::encoding::ValueTypeMarker>::borrow(val),
27493                    encoder,
27494                    offset + 8,
27495                    _depth,
27496                ),
27497                Offer::Protocol(ref val) => fidl::encoding::encode_in_envelope::<OfferProtocol, D>(
27498                    <OfferProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
27499                    encoder,
27500                    offset + 8,
27501                    _depth,
27502                ),
27503                Offer::Directory(ref val) => {
27504                    fidl::encoding::encode_in_envelope::<OfferDirectory, D>(
27505                        <OfferDirectory as fidl::encoding::ValueTypeMarker>::borrow(val),
27506                        encoder,
27507                        offset + 8,
27508                        _depth,
27509                    )
27510                }
27511                Offer::Storage(ref val) => fidl::encoding::encode_in_envelope::<OfferStorage, D>(
27512                    <OfferStorage as fidl::encoding::ValueTypeMarker>::borrow(val),
27513                    encoder,
27514                    offset + 8,
27515                    _depth,
27516                ),
27517                Offer::Runner(ref val) => fidl::encoding::encode_in_envelope::<OfferRunner, D>(
27518                    <OfferRunner as fidl::encoding::ValueTypeMarker>::borrow(val),
27519                    encoder,
27520                    offset + 8,
27521                    _depth,
27522                ),
27523                Offer::Resolver(ref val) => fidl::encoding::encode_in_envelope::<OfferResolver, D>(
27524                    <OfferResolver as fidl::encoding::ValueTypeMarker>::borrow(val),
27525                    encoder,
27526                    offset + 8,
27527                    _depth,
27528                ),
27529                Offer::EventStream(ref val) => {
27530                    fidl::encoding::encode_in_envelope::<OfferEventStream, D>(
27531                        <OfferEventStream as fidl::encoding::ValueTypeMarker>::borrow(val),
27532                        encoder,
27533                        offset + 8,
27534                        _depth,
27535                    )
27536                }
27537                Offer::Dictionary(ref val) => {
27538                    fidl::encoding::encode_in_envelope::<OfferDictionary, D>(
27539                        <OfferDictionary as fidl::encoding::ValueTypeMarker>::borrow(val),
27540                        encoder,
27541                        offset + 8,
27542                        _depth,
27543                    )
27544                }
27545                Offer::Config(ref val) => {
27546                    fidl::encoding::encode_in_envelope::<OfferConfiguration, D>(
27547                        <OfferConfiguration as fidl::encoding::ValueTypeMarker>::borrow(val),
27548                        encoder,
27549                        offset + 8,
27550                        _depth,
27551                    )
27552                }
27553                Offer::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
27554            }
27555        }
27556    }
27557
27558    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Offer {
27559        #[inline(always)]
27560        fn new_empty() -> Self {
27561            Self::__SourceBreaking { unknown_ordinal: 0 }
27562        }
27563
27564        #[inline]
27565        unsafe fn decode(
27566            &mut self,
27567            decoder: &mut fidl::encoding::Decoder<'_, D>,
27568            offset: usize,
27569            mut depth: fidl::encoding::Depth,
27570        ) -> fidl::Result<()> {
27571            decoder.debug_check_bounds::<Self>(offset);
27572            #[allow(unused_variables)]
27573            let next_out_of_line = decoder.next_out_of_line();
27574            let handles_before = decoder.remaining_handles();
27575            let (ordinal, inlined, num_bytes, num_handles) =
27576                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
27577
27578            let member_inline_size = match ordinal {
27579                1 => <OfferService as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27580                2 => <OfferProtocol as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27581                3 => <OfferDirectory as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27582                4 => <OfferStorage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27583                5 => <OfferRunner as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27584                6 => <OfferResolver as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27585                8 => <OfferEventStream as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27586                9 => <OfferDictionary as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27587                10 => {
27588                    <OfferConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context)
27589                }
27590                0 => return Err(fidl::Error::UnknownUnionTag),
27591                _ => num_bytes as usize,
27592            };
27593
27594            if inlined != (member_inline_size <= 4) {
27595                return Err(fidl::Error::InvalidInlineBitInEnvelope);
27596            }
27597            let _inner_offset;
27598            if inlined {
27599                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
27600                _inner_offset = offset + 8;
27601            } else {
27602                depth.increment()?;
27603                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
27604            }
27605            match ordinal {
27606                1 => {
27607                    #[allow(irrefutable_let_patterns)]
27608                    if let Offer::Service(_) = self {
27609                        // Do nothing, read the value into the object
27610                    } else {
27611                        // Initialize `self` to the right variant
27612                        *self = Offer::Service(fidl::new_empty!(OfferService, D));
27613                    }
27614                    #[allow(irrefutable_let_patterns)]
27615                    if let Offer::Service(ref mut val) = self {
27616                        fidl::decode!(OfferService, D, val, decoder, _inner_offset, depth)?;
27617                    } else {
27618                        unreachable!()
27619                    }
27620                }
27621                2 => {
27622                    #[allow(irrefutable_let_patterns)]
27623                    if let Offer::Protocol(_) = self {
27624                        // Do nothing, read the value into the object
27625                    } else {
27626                        // Initialize `self` to the right variant
27627                        *self = Offer::Protocol(fidl::new_empty!(OfferProtocol, D));
27628                    }
27629                    #[allow(irrefutable_let_patterns)]
27630                    if let Offer::Protocol(ref mut val) = self {
27631                        fidl::decode!(OfferProtocol, D, val, decoder, _inner_offset, depth)?;
27632                    } else {
27633                        unreachable!()
27634                    }
27635                }
27636                3 => {
27637                    #[allow(irrefutable_let_patterns)]
27638                    if let Offer::Directory(_) = self {
27639                        // Do nothing, read the value into the object
27640                    } else {
27641                        // Initialize `self` to the right variant
27642                        *self = Offer::Directory(fidl::new_empty!(OfferDirectory, D));
27643                    }
27644                    #[allow(irrefutable_let_patterns)]
27645                    if let Offer::Directory(ref mut val) = self {
27646                        fidl::decode!(OfferDirectory, D, val, decoder, _inner_offset, depth)?;
27647                    } else {
27648                        unreachable!()
27649                    }
27650                }
27651                4 => {
27652                    #[allow(irrefutable_let_patterns)]
27653                    if let Offer::Storage(_) = self {
27654                        // Do nothing, read the value into the object
27655                    } else {
27656                        // Initialize `self` to the right variant
27657                        *self = Offer::Storage(fidl::new_empty!(OfferStorage, D));
27658                    }
27659                    #[allow(irrefutable_let_patterns)]
27660                    if let Offer::Storage(ref mut val) = self {
27661                        fidl::decode!(OfferStorage, D, val, decoder, _inner_offset, depth)?;
27662                    } else {
27663                        unreachable!()
27664                    }
27665                }
27666                5 => {
27667                    #[allow(irrefutable_let_patterns)]
27668                    if let Offer::Runner(_) = self {
27669                        // Do nothing, read the value into the object
27670                    } else {
27671                        // Initialize `self` to the right variant
27672                        *self = Offer::Runner(fidl::new_empty!(OfferRunner, D));
27673                    }
27674                    #[allow(irrefutable_let_patterns)]
27675                    if let Offer::Runner(ref mut val) = self {
27676                        fidl::decode!(OfferRunner, D, val, decoder, _inner_offset, depth)?;
27677                    } else {
27678                        unreachable!()
27679                    }
27680                }
27681                6 => {
27682                    #[allow(irrefutable_let_patterns)]
27683                    if let Offer::Resolver(_) = self {
27684                        // Do nothing, read the value into the object
27685                    } else {
27686                        // Initialize `self` to the right variant
27687                        *self = Offer::Resolver(fidl::new_empty!(OfferResolver, D));
27688                    }
27689                    #[allow(irrefutable_let_patterns)]
27690                    if let Offer::Resolver(ref mut val) = self {
27691                        fidl::decode!(OfferResolver, D, val, decoder, _inner_offset, depth)?;
27692                    } else {
27693                        unreachable!()
27694                    }
27695                }
27696                8 => {
27697                    #[allow(irrefutable_let_patterns)]
27698                    if let Offer::EventStream(_) = self {
27699                        // Do nothing, read the value into the object
27700                    } else {
27701                        // Initialize `self` to the right variant
27702                        *self = Offer::EventStream(fidl::new_empty!(OfferEventStream, D));
27703                    }
27704                    #[allow(irrefutable_let_patterns)]
27705                    if let Offer::EventStream(ref mut val) = self {
27706                        fidl::decode!(OfferEventStream, D, val, decoder, _inner_offset, depth)?;
27707                    } else {
27708                        unreachable!()
27709                    }
27710                }
27711                9 => {
27712                    #[allow(irrefutable_let_patterns)]
27713                    if let Offer::Dictionary(_) = self {
27714                        // Do nothing, read the value into the object
27715                    } else {
27716                        // Initialize `self` to the right variant
27717                        *self = Offer::Dictionary(fidl::new_empty!(OfferDictionary, D));
27718                    }
27719                    #[allow(irrefutable_let_patterns)]
27720                    if let Offer::Dictionary(ref mut val) = self {
27721                        fidl::decode!(OfferDictionary, D, val, decoder, _inner_offset, depth)?;
27722                    } else {
27723                        unreachable!()
27724                    }
27725                }
27726                10 => {
27727                    #[allow(irrefutable_let_patterns)]
27728                    if let Offer::Config(_) = self {
27729                        // Do nothing, read the value into the object
27730                    } else {
27731                        // Initialize `self` to the right variant
27732                        *self = Offer::Config(fidl::new_empty!(OfferConfiguration, D));
27733                    }
27734                    #[allow(irrefutable_let_patterns)]
27735                    if let Offer::Config(ref mut val) = self {
27736                        fidl::decode!(OfferConfiguration, D, val, decoder, _inner_offset, depth)?;
27737                    } else {
27738                        unreachable!()
27739                    }
27740                }
27741                #[allow(deprecated)]
27742                ordinal => {
27743                    for _ in 0..num_handles {
27744                        decoder.drop_next_handle()?;
27745                    }
27746                    *self = Offer::__SourceBreaking { unknown_ordinal: ordinal };
27747                }
27748            }
27749            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
27750                return Err(fidl::Error::InvalidNumBytesInEnvelope);
27751            }
27752            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
27753                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
27754            }
27755            Ok(())
27756        }
27757    }
27758
27759    impl fidl::encoding::ValueTypeMarker for Ref {
27760        type Borrowed<'a> = &'a Self;
27761        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
27762            value
27763        }
27764    }
27765
27766    unsafe impl fidl::encoding::TypeMarker for Ref {
27767        type Owned = Self;
27768
27769        #[inline(always)]
27770        fn inline_align(_context: fidl::encoding::Context) -> usize {
27771            8
27772        }
27773
27774        #[inline(always)]
27775        fn inline_size(_context: fidl::encoding::Context) -> usize {
27776            16
27777        }
27778    }
27779
27780    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Ref, D> for &Ref {
27781        #[inline]
27782        unsafe fn encode(
27783            self,
27784            encoder: &mut fidl::encoding::Encoder<'_, D>,
27785            offset: usize,
27786            _depth: fidl::encoding::Depth,
27787        ) -> fidl::Result<()> {
27788            encoder.debug_check_bounds::<Ref>(offset);
27789            encoder.write_num::<u64>(self.ordinal(), offset);
27790            match self {
27791                Ref::Parent(ref val) => fidl::encoding::encode_in_envelope::<ParentRef, D>(
27792                    <ParentRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27793                    encoder,
27794                    offset + 8,
27795                    _depth,
27796                ),
27797                Ref::Self_(ref val) => fidl::encoding::encode_in_envelope::<SelfRef, D>(
27798                    <SelfRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27799                    encoder,
27800                    offset + 8,
27801                    _depth,
27802                ),
27803                Ref::Child(ref val) => fidl::encoding::encode_in_envelope::<ChildRef, D>(
27804                    <ChildRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27805                    encoder,
27806                    offset + 8,
27807                    _depth,
27808                ),
27809                Ref::Collection(ref val) => fidl::encoding::encode_in_envelope::<CollectionRef, D>(
27810                    <CollectionRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27811                    encoder,
27812                    offset + 8,
27813                    _depth,
27814                ),
27815                Ref::Framework(ref val) => fidl::encoding::encode_in_envelope::<FrameworkRef, D>(
27816                    <FrameworkRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27817                    encoder,
27818                    offset + 8,
27819                    _depth,
27820                ),
27821                Ref::Capability(ref val) => fidl::encoding::encode_in_envelope::<CapabilityRef, D>(
27822                    <CapabilityRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27823                    encoder,
27824                    offset + 8,
27825                    _depth,
27826                ),
27827                Ref::Debug(ref val) => fidl::encoding::encode_in_envelope::<DebugRef, D>(
27828                    <DebugRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27829                    encoder,
27830                    offset + 8,
27831                    _depth,
27832                ),
27833                Ref::VoidType(ref val) => fidl::encoding::encode_in_envelope::<VoidRef, D>(
27834                    <VoidRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27835                    encoder,
27836                    offset + 8,
27837                    _depth,
27838                ),
27839                Ref::Environment(ref val) => {
27840                    fidl::encoding::encode_in_envelope::<EnvironmentRef, D>(
27841                        <EnvironmentRef as fidl::encoding::ValueTypeMarker>::borrow(val),
27842                        encoder,
27843                        offset + 8,
27844                        _depth,
27845                    )
27846                }
27847                Ref::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
27848            }
27849        }
27850    }
27851
27852    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Ref {
27853        #[inline(always)]
27854        fn new_empty() -> Self {
27855            Self::__SourceBreaking { unknown_ordinal: 0 }
27856        }
27857
27858        #[inline]
27859        unsafe fn decode(
27860            &mut self,
27861            decoder: &mut fidl::encoding::Decoder<'_, D>,
27862            offset: usize,
27863            mut depth: fidl::encoding::Depth,
27864        ) -> fidl::Result<()> {
27865            decoder.debug_check_bounds::<Self>(offset);
27866            #[allow(unused_variables)]
27867            let next_out_of_line = decoder.next_out_of_line();
27868            let handles_before = decoder.remaining_handles();
27869            let (ordinal, inlined, num_bytes, num_handles) =
27870                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
27871
27872            let member_inline_size = match ordinal {
27873                1 => <ParentRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27874                2 => <SelfRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27875                3 => <ChildRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27876                4 => <CollectionRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27877                5 => <FrameworkRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27878                6 => <CapabilityRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27879                7 => <DebugRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27880                8 => <VoidRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27881                9 => <EnvironmentRef as fidl::encoding::TypeMarker>::inline_size(decoder.context),
27882                0 => return Err(fidl::Error::UnknownUnionTag),
27883                _ => num_bytes as usize,
27884            };
27885
27886            if inlined != (member_inline_size <= 4) {
27887                return Err(fidl::Error::InvalidInlineBitInEnvelope);
27888            }
27889            let _inner_offset;
27890            if inlined {
27891                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
27892                _inner_offset = offset + 8;
27893            } else {
27894                depth.increment()?;
27895                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
27896            }
27897            match ordinal {
27898                1 => {
27899                    #[allow(irrefutable_let_patterns)]
27900                    if let Ref::Parent(_) = self {
27901                        // Do nothing, read the value into the object
27902                    } else {
27903                        // Initialize `self` to the right variant
27904                        *self = Ref::Parent(fidl::new_empty!(ParentRef, D));
27905                    }
27906                    #[allow(irrefutable_let_patterns)]
27907                    if let Ref::Parent(ref mut val) = self {
27908                        fidl::decode!(ParentRef, D, val, decoder, _inner_offset, depth)?;
27909                    } else {
27910                        unreachable!()
27911                    }
27912                }
27913                2 => {
27914                    #[allow(irrefutable_let_patterns)]
27915                    if let Ref::Self_(_) = self {
27916                        // Do nothing, read the value into the object
27917                    } else {
27918                        // Initialize `self` to the right variant
27919                        *self = Ref::Self_(fidl::new_empty!(SelfRef, D));
27920                    }
27921                    #[allow(irrefutable_let_patterns)]
27922                    if let Ref::Self_(ref mut val) = self {
27923                        fidl::decode!(SelfRef, D, val, decoder, _inner_offset, depth)?;
27924                    } else {
27925                        unreachable!()
27926                    }
27927                }
27928                3 => {
27929                    #[allow(irrefutable_let_patterns)]
27930                    if let Ref::Child(_) = self {
27931                        // Do nothing, read the value into the object
27932                    } else {
27933                        // Initialize `self` to the right variant
27934                        *self = Ref::Child(fidl::new_empty!(ChildRef, D));
27935                    }
27936                    #[allow(irrefutable_let_patterns)]
27937                    if let Ref::Child(ref mut val) = self {
27938                        fidl::decode!(ChildRef, D, val, decoder, _inner_offset, depth)?;
27939                    } else {
27940                        unreachable!()
27941                    }
27942                }
27943                4 => {
27944                    #[allow(irrefutable_let_patterns)]
27945                    if let Ref::Collection(_) = self {
27946                        // Do nothing, read the value into the object
27947                    } else {
27948                        // Initialize `self` to the right variant
27949                        *self = Ref::Collection(fidl::new_empty!(CollectionRef, D));
27950                    }
27951                    #[allow(irrefutable_let_patterns)]
27952                    if let Ref::Collection(ref mut val) = self {
27953                        fidl::decode!(CollectionRef, D, val, decoder, _inner_offset, depth)?;
27954                    } else {
27955                        unreachable!()
27956                    }
27957                }
27958                5 => {
27959                    #[allow(irrefutable_let_patterns)]
27960                    if let Ref::Framework(_) = self {
27961                        // Do nothing, read the value into the object
27962                    } else {
27963                        // Initialize `self` to the right variant
27964                        *self = Ref::Framework(fidl::new_empty!(FrameworkRef, D));
27965                    }
27966                    #[allow(irrefutable_let_patterns)]
27967                    if let Ref::Framework(ref mut val) = self {
27968                        fidl::decode!(FrameworkRef, D, val, decoder, _inner_offset, depth)?;
27969                    } else {
27970                        unreachable!()
27971                    }
27972                }
27973                6 => {
27974                    #[allow(irrefutable_let_patterns)]
27975                    if let Ref::Capability(_) = self {
27976                        // Do nothing, read the value into the object
27977                    } else {
27978                        // Initialize `self` to the right variant
27979                        *self = Ref::Capability(fidl::new_empty!(CapabilityRef, D));
27980                    }
27981                    #[allow(irrefutable_let_patterns)]
27982                    if let Ref::Capability(ref mut val) = self {
27983                        fidl::decode!(CapabilityRef, D, val, decoder, _inner_offset, depth)?;
27984                    } else {
27985                        unreachable!()
27986                    }
27987                }
27988                7 => {
27989                    #[allow(irrefutable_let_patterns)]
27990                    if let Ref::Debug(_) = self {
27991                        // Do nothing, read the value into the object
27992                    } else {
27993                        // Initialize `self` to the right variant
27994                        *self = Ref::Debug(fidl::new_empty!(DebugRef, D));
27995                    }
27996                    #[allow(irrefutable_let_patterns)]
27997                    if let Ref::Debug(ref mut val) = self {
27998                        fidl::decode!(DebugRef, D, val, decoder, _inner_offset, depth)?;
27999                    } else {
28000                        unreachable!()
28001                    }
28002                }
28003                8 => {
28004                    #[allow(irrefutable_let_patterns)]
28005                    if let Ref::VoidType(_) = self {
28006                        // Do nothing, read the value into the object
28007                    } else {
28008                        // Initialize `self` to the right variant
28009                        *self = Ref::VoidType(fidl::new_empty!(VoidRef, D));
28010                    }
28011                    #[allow(irrefutable_let_patterns)]
28012                    if let Ref::VoidType(ref mut val) = self {
28013                        fidl::decode!(VoidRef, D, val, decoder, _inner_offset, depth)?;
28014                    } else {
28015                        unreachable!()
28016                    }
28017                }
28018                9 => {
28019                    #[allow(irrefutable_let_patterns)]
28020                    if let Ref::Environment(_) = self {
28021                        // Do nothing, read the value into the object
28022                    } else {
28023                        // Initialize `self` to the right variant
28024                        *self = Ref::Environment(fidl::new_empty!(EnvironmentRef, D));
28025                    }
28026                    #[allow(irrefutable_let_patterns)]
28027                    if let Ref::Environment(ref mut val) = self {
28028                        fidl::decode!(EnvironmentRef, D, val, decoder, _inner_offset, depth)?;
28029                    } else {
28030                        unreachable!()
28031                    }
28032                }
28033                #[allow(deprecated)]
28034                ordinal => {
28035                    for _ in 0..num_handles {
28036                        decoder.drop_next_handle()?;
28037                    }
28038                    *self = Ref::__SourceBreaking { unknown_ordinal: ordinal };
28039                }
28040            }
28041            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
28042                return Err(fidl::Error::InvalidNumBytesInEnvelope);
28043            }
28044            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
28045                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
28046            }
28047            Ok(())
28048        }
28049    }
28050
28051    impl fidl::encoding::ValueTypeMarker for Use {
28052        type Borrowed<'a> = &'a Self;
28053        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
28054            value
28055        }
28056    }
28057
28058    unsafe impl fidl::encoding::TypeMarker for Use {
28059        type Owned = Self;
28060
28061        #[inline(always)]
28062        fn inline_align(_context: fidl::encoding::Context) -> usize {
28063            8
28064        }
28065
28066        #[inline(always)]
28067        fn inline_size(_context: fidl::encoding::Context) -> usize {
28068            16
28069        }
28070    }
28071
28072    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Use, D> for &Use {
28073        #[inline]
28074        unsafe fn encode(
28075            self,
28076            encoder: &mut fidl::encoding::Encoder<'_, D>,
28077            offset: usize,
28078            _depth: fidl::encoding::Depth,
28079        ) -> fidl::Result<()> {
28080            encoder.debug_check_bounds::<Use>(offset);
28081            encoder.write_num::<u64>(self.ordinal(), offset);
28082            match self {
28083                Use::Service(ref val) => fidl::encoding::encode_in_envelope::<UseService, D>(
28084                    <UseService as fidl::encoding::ValueTypeMarker>::borrow(val),
28085                    encoder,
28086                    offset + 8,
28087                    _depth,
28088                ),
28089                Use::Protocol(ref val) => fidl::encoding::encode_in_envelope::<UseProtocol, D>(
28090                    <UseProtocol as fidl::encoding::ValueTypeMarker>::borrow(val),
28091                    encoder,
28092                    offset + 8,
28093                    _depth,
28094                ),
28095                Use::Directory(ref val) => fidl::encoding::encode_in_envelope::<UseDirectory, D>(
28096                    <UseDirectory as fidl::encoding::ValueTypeMarker>::borrow(val),
28097                    encoder,
28098                    offset + 8,
28099                    _depth,
28100                ),
28101                Use::Storage(ref val) => fidl::encoding::encode_in_envelope::<UseStorage, D>(
28102                    <UseStorage as fidl::encoding::ValueTypeMarker>::borrow(val),
28103                    encoder,
28104                    offset + 8,
28105                    _depth,
28106                ),
28107                Use::EventStream(ref val) => {
28108                    fidl::encoding::encode_in_envelope::<UseEventStream, D>(
28109                        <UseEventStream as fidl::encoding::ValueTypeMarker>::borrow(val),
28110                        encoder,
28111                        offset + 8,
28112                        _depth,
28113                    )
28114                }
28115                Use::Runner(ref val) => fidl::encoding::encode_in_envelope::<UseRunner, D>(
28116                    <UseRunner as fidl::encoding::ValueTypeMarker>::borrow(val),
28117                    encoder,
28118                    offset + 8,
28119                    _depth,
28120                ),
28121                Use::Config(ref val) => fidl::encoding::encode_in_envelope::<UseConfiguration, D>(
28122                    <UseConfiguration as fidl::encoding::ValueTypeMarker>::borrow(val),
28123                    encoder,
28124                    offset + 8,
28125                    _depth,
28126                ),
28127                Use::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
28128            }
28129        }
28130    }
28131
28132    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Use {
28133        #[inline(always)]
28134        fn new_empty() -> Self {
28135            Self::__SourceBreaking { unknown_ordinal: 0 }
28136        }
28137
28138        #[inline]
28139        unsafe fn decode(
28140            &mut self,
28141            decoder: &mut fidl::encoding::Decoder<'_, D>,
28142            offset: usize,
28143            mut depth: fidl::encoding::Depth,
28144        ) -> fidl::Result<()> {
28145            decoder.debug_check_bounds::<Self>(offset);
28146            #[allow(unused_variables)]
28147            let next_out_of_line = decoder.next_out_of_line();
28148            let handles_before = decoder.remaining_handles();
28149            let (ordinal, inlined, num_bytes, num_handles) =
28150                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
28151
28152            let member_inline_size = match ordinal {
28153                1 => <UseService as fidl::encoding::TypeMarker>::inline_size(decoder.context),
28154                2 => <UseProtocol as fidl::encoding::TypeMarker>::inline_size(decoder.context),
28155                3 => <UseDirectory as fidl::encoding::TypeMarker>::inline_size(decoder.context),
28156                4 => <UseStorage as fidl::encoding::TypeMarker>::inline_size(decoder.context),
28157                7 => <UseEventStream as fidl::encoding::TypeMarker>::inline_size(decoder.context),
28158                8 => <UseRunner as fidl::encoding::TypeMarker>::inline_size(decoder.context),
28159                9 => <UseConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context),
28160                0 => return Err(fidl::Error::UnknownUnionTag),
28161                _ => num_bytes as usize,
28162            };
28163
28164            if inlined != (member_inline_size <= 4) {
28165                return Err(fidl::Error::InvalidInlineBitInEnvelope);
28166            }
28167            let _inner_offset;
28168            if inlined {
28169                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
28170                _inner_offset = offset + 8;
28171            } else {
28172                depth.increment()?;
28173                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
28174            }
28175            match ordinal {
28176                1 => {
28177                    #[allow(irrefutable_let_patterns)]
28178                    if let Use::Service(_) = self {
28179                        // Do nothing, read the value into the object
28180                    } else {
28181                        // Initialize `self` to the right variant
28182                        *self = Use::Service(fidl::new_empty!(UseService, D));
28183                    }
28184                    #[allow(irrefutable_let_patterns)]
28185                    if let Use::Service(ref mut val) = self {
28186                        fidl::decode!(UseService, D, val, decoder, _inner_offset, depth)?;
28187                    } else {
28188                        unreachable!()
28189                    }
28190                }
28191                2 => {
28192                    #[allow(irrefutable_let_patterns)]
28193                    if let Use::Protocol(_) = self {
28194                        // Do nothing, read the value into the object
28195                    } else {
28196                        // Initialize `self` to the right variant
28197                        *self = Use::Protocol(fidl::new_empty!(UseProtocol, D));
28198                    }
28199                    #[allow(irrefutable_let_patterns)]
28200                    if let Use::Protocol(ref mut val) = self {
28201                        fidl::decode!(UseProtocol, D, val, decoder, _inner_offset, depth)?;
28202                    } else {
28203                        unreachable!()
28204                    }
28205                }
28206                3 => {
28207                    #[allow(irrefutable_let_patterns)]
28208                    if let Use::Directory(_) = self {
28209                        // Do nothing, read the value into the object
28210                    } else {
28211                        // Initialize `self` to the right variant
28212                        *self = Use::Directory(fidl::new_empty!(UseDirectory, D));
28213                    }
28214                    #[allow(irrefutable_let_patterns)]
28215                    if let Use::Directory(ref mut val) = self {
28216                        fidl::decode!(UseDirectory, D, val, decoder, _inner_offset, depth)?;
28217                    } else {
28218                        unreachable!()
28219                    }
28220                }
28221                4 => {
28222                    #[allow(irrefutable_let_patterns)]
28223                    if let Use::Storage(_) = self {
28224                        // Do nothing, read the value into the object
28225                    } else {
28226                        // Initialize `self` to the right variant
28227                        *self = Use::Storage(fidl::new_empty!(UseStorage, D));
28228                    }
28229                    #[allow(irrefutable_let_patterns)]
28230                    if let Use::Storage(ref mut val) = self {
28231                        fidl::decode!(UseStorage, D, val, decoder, _inner_offset, depth)?;
28232                    } else {
28233                        unreachable!()
28234                    }
28235                }
28236                7 => {
28237                    #[allow(irrefutable_let_patterns)]
28238                    if let Use::EventStream(_) = self {
28239                        // Do nothing, read the value into the object
28240                    } else {
28241                        // Initialize `self` to the right variant
28242                        *self = Use::EventStream(fidl::new_empty!(UseEventStream, D));
28243                    }
28244                    #[allow(irrefutable_let_patterns)]
28245                    if let Use::EventStream(ref mut val) = self {
28246                        fidl::decode!(UseEventStream, D, val, decoder, _inner_offset, depth)?;
28247                    } else {
28248                        unreachable!()
28249                    }
28250                }
28251                8 => {
28252                    #[allow(irrefutable_let_patterns)]
28253                    if let Use::Runner(_) = self {
28254                        // Do nothing, read the value into the object
28255                    } else {
28256                        // Initialize `self` to the right variant
28257                        *self = Use::Runner(fidl::new_empty!(UseRunner, D));
28258                    }
28259                    #[allow(irrefutable_let_patterns)]
28260                    if let Use::Runner(ref mut val) = self {
28261                        fidl::decode!(UseRunner, D, val, decoder, _inner_offset, depth)?;
28262                    } else {
28263                        unreachable!()
28264                    }
28265                }
28266                9 => {
28267                    #[allow(irrefutable_let_patterns)]
28268                    if let Use::Config(_) = self {
28269                        // Do nothing, read the value into the object
28270                    } else {
28271                        // Initialize `self` to the right variant
28272                        *self = Use::Config(fidl::new_empty!(UseConfiguration, D));
28273                    }
28274                    #[allow(irrefutable_let_patterns)]
28275                    if let Use::Config(ref mut val) = self {
28276                        fidl::decode!(UseConfiguration, D, val, decoder, _inner_offset, depth)?;
28277                    } else {
28278                        unreachable!()
28279                    }
28280                }
28281                #[allow(deprecated)]
28282                ordinal => {
28283                    for _ in 0..num_handles {
28284                        decoder.drop_next_handle()?;
28285                    }
28286                    *self = Use::__SourceBreaking { unknown_ordinal: ordinal };
28287                }
28288            }
28289            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
28290                return Err(fidl::Error::InvalidNumBytesInEnvelope);
28291            }
28292            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
28293                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
28294            }
28295            Ok(())
28296        }
28297    }
28298}