fidl_fuchsia_driver_framework__common/
fidl_fuchsia_driver_framework__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub type NodeName = String;
12
13pub type NodeOffersVector = Vec<Offer>;
14
15pub type NodeProperties = Vec<NodeProperty2>;
16
17pub type NodePropertyDictionary = Vec<NodePropertyEntry>;
18
19pub type NodePropertyDictionary2 = Vec<NodePropertyEntry2>;
20
21pub type NodePropertyKeyString = String;
22
23pub type NodePropertyKeyUint = u32;
24
25pub type NodePropertyValueBool = bool;
26
27pub type NodePropertyValueEnum = String;
28
29pub type NodePropertyValueString = String;
30
31pub type NodePropertyValueUint = u32;
32
33pub type NodePropertyVector = Vec<NodeProperty>;
34
35pub const MAX_DEVICE_ADDRESS_ARRAY_LEN: u32 = 10;
36
37pub const MAX_DEVICE_ADDRESS_STR_LEN: u32 = 32;
38
39pub const MAX_MODULE_NAME_LENGTH: u8 = 128;
40
41pub const MAX_NAMESPACE_COUNT: u32 =
42    fidl_fuchsia_component_runner__common::MAX_NAMESPACE_COUNT as u32;
43
44pub const MAX_NODE_NAME_LENGTH: u8 = 128;
45
46pub const MAX_OFFER_COUNT: u32 = fidl_fuchsia_component__common::MAX_DYNAMIC_OFFER_COUNT as u32;
47
48pub const MAX_PROPERTY_COUNT: u8 = 64;
49
50pub const MAX_RESOURCE_NAME_LENGTH: u8 = 128;
51
52pub const MAX_SYMBOL_COUNT: u8 = 64;
53
54pub const MAX_SYMBOL_NAME_LENGTH: u8 = 128;
55
56#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
57pub enum BusType {
58    Platform,
59    Acpi,
60    DeviceTree,
61    Pci,
62    Usb,
63    Gpio,
64    I2C,
65    Spi,
66    Sdio,
67    Uart,
68    Spmi,
69    #[doc(hidden)]
70    __SourceBreaking {
71        unknown_ordinal: u32,
72    },
73}
74
75/// Pattern that matches an unknown `BusType` member.
76#[macro_export]
77macro_rules! BusTypeUnknown {
78    () => {
79        _
80    };
81}
82
83impl BusType {
84    #[inline]
85    pub fn from_primitive(prim: u32) -> Option<Self> {
86        match prim {
87            1 => Some(Self::Platform),
88            2 => Some(Self::Acpi),
89            3 => Some(Self::DeviceTree),
90            4 => Some(Self::Pci),
91            5 => Some(Self::Usb),
92            6 => Some(Self::Gpio),
93            7 => Some(Self::I2C),
94            8 => Some(Self::Spi),
95            9 => Some(Self::Sdio),
96            10 => Some(Self::Uart),
97            11 => Some(Self::Spmi),
98            _ => None,
99        }
100    }
101
102    #[inline]
103    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
104        match prim {
105            1 => Self::Platform,
106            2 => Self::Acpi,
107            3 => Self::DeviceTree,
108            4 => Self::Pci,
109            5 => Self::Usb,
110            6 => Self::Gpio,
111            7 => Self::I2C,
112            8 => Self::Spi,
113            9 => Self::Sdio,
114            10 => Self::Uart,
115            11 => Self::Spmi,
116            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
117        }
118    }
119
120    #[inline]
121    pub fn unknown() -> Self {
122        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
123    }
124
125    #[inline]
126    pub const fn into_primitive(self) -> u32 {
127        match self {
128            Self::Platform => 1,
129            Self::Acpi => 2,
130            Self::DeviceTree => 3,
131            Self::Pci => 4,
132            Self::Usb => 5,
133            Self::Gpio => 6,
134            Self::I2C => 7,
135            Self::Spi => 8,
136            Self::Sdio => 9,
137            Self::Uart => 10,
138            Self::Spmi => 11,
139            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
140        }
141    }
142
143    #[inline]
144    pub fn is_unknown(&self) -> bool {
145        match self {
146            Self::__SourceBreaking { unknown_ordinal: _ } => true,
147            _ => false,
148        }
149    }
150}
151
152/// Error codes for the CompositeNodeManager protocol.
153#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
154pub enum CompositeNodeSpecError {
155    /// An argument of the composite node spec was not provided.
156    MissingArgs,
157    /// The given composite node spec's `nodes` is empty.
158    EmptyNodes,
159    /// The `name` in the given composite node spec is a duplicate of an already
160    /// created composite node spec.
161    AlreadyExists,
162    /// The spec failed to be added to the driver index.
163    DriverIndexFailure,
164    /// The `parents` and `parents2` fields were both specified.
165    DuplicateParents,
166    #[doc(hidden)]
167    __SourceBreaking { unknown_ordinal: u32 },
168}
169
170/// Pattern that matches an unknown `CompositeNodeSpecError` member.
171#[macro_export]
172macro_rules! CompositeNodeSpecErrorUnknown {
173    () => {
174        _
175    };
176}
177
178impl CompositeNodeSpecError {
179    #[inline]
180    pub fn from_primitive(prim: u32) -> Option<Self> {
181        match prim {
182            1 => Some(Self::MissingArgs),
183            2 => Some(Self::EmptyNodes),
184            3 => Some(Self::AlreadyExists),
185            4 => Some(Self::DriverIndexFailure),
186            5 => Some(Self::DuplicateParents),
187            _ => None,
188        }
189    }
190
191    #[inline]
192    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
193        match prim {
194            1 => Self::MissingArgs,
195            2 => Self::EmptyNodes,
196            3 => Self::AlreadyExists,
197            4 => Self::DriverIndexFailure,
198            5 => Self::DuplicateParents,
199            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
200        }
201    }
202
203    #[inline]
204    pub fn unknown() -> Self {
205        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
206    }
207
208    #[inline]
209    pub const fn into_primitive(self) -> u32 {
210        match self {
211            Self::MissingArgs => 1,
212            Self::EmptyNodes => 2,
213            Self::AlreadyExists => 3,
214            Self::DriverIndexFailure => 4,
215            Self::DuplicateParents => 5,
216            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
217        }
218    }
219
220    #[inline]
221    pub fn is_unknown(&self) -> bool {
222        match self {
223            Self::__SourceBreaking { unknown_ordinal: _ } => true,
224            _ => false,
225        }
226    }
227}
228
229/// Represents a bind rule condition.
230#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
231#[repr(u32)]
232pub enum Condition {
233    Unknown = 0,
234    Accept = 1,
235    Reject = 2,
236}
237
238impl Condition {
239    #[inline]
240    pub fn from_primitive(prim: u32) -> Option<Self> {
241        match prim {
242            0 => Some(Self::Unknown),
243            1 => Some(Self::Accept),
244            2 => Some(Self::Reject),
245            _ => None,
246        }
247    }
248
249    #[inline]
250    pub const fn into_primitive(self) -> u32 {
251        self as u32
252    }
253}
254
255#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
256pub enum DeviceAddressStability {
257    /// When the driver is restarted, the device address may change.
258    UnstableBetweenDriverRestart,
259    /// When the system is restarted, the device address may change.
260    UnstableBetweenBoot,
261    /// When the system is updated, the device address may change.
262    UnstableBetweenSoftwareUpdate,
263    /// The device address on the bus is guaranteed stable for the lifetime of the system.
264    Stable,
265    #[doc(hidden)]
266    __SourceBreaking { unknown_ordinal: u32 },
267}
268
269/// Pattern that matches an unknown `DeviceAddressStability` member.
270#[macro_export]
271macro_rules! DeviceAddressStabilityUnknown {
272    () => {
273        _
274    };
275}
276
277impl DeviceAddressStability {
278    #[inline]
279    pub fn from_primitive(prim: u32) -> Option<Self> {
280        match prim {
281            0 => Some(Self::UnstableBetweenDriverRestart),
282            1 => Some(Self::UnstableBetweenBoot),
283            2 => Some(Self::UnstableBetweenSoftwareUpdate),
284            3 => Some(Self::Stable),
285            _ => None,
286        }
287    }
288
289    #[inline]
290    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
291        match prim {
292            0 => Self::UnstableBetweenDriverRestart,
293            1 => Self::UnstableBetweenBoot,
294            2 => Self::UnstableBetweenSoftwareUpdate,
295            3 => Self::Stable,
296            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
297        }
298    }
299
300    #[inline]
301    pub fn unknown() -> Self {
302        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
303    }
304
305    #[inline]
306    pub const fn into_primitive(self) -> u32 {
307        match self {
308            Self::UnstableBetweenDriverRestart => 0,
309            Self::UnstableBetweenBoot => 1,
310            Self::UnstableBetweenSoftwareUpdate => 2,
311            Self::Stable => 3,
312            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
313        }
314    }
315
316    #[inline]
317    pub fn is_unknown(&self) -> bool {
318        match self {
319            Self::__SourceBreaking { unknown_ordinal: _ } => true,
320            _ => false,
321        }
322    }
323}
324
325/// The type of Fuchsia package that a driver component is inside of.
326/// More details about the various package categories are available at:
327/// https://fuchsia.dev/fuchsia-src/concepts/packages/package#types_of_packages
328#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
329pub enum DriverPackageType {
330    /// BOOT packages are inside the Zircon boot image.
331    Boot,
332    /// BASE packages are included in the Fuchsia build as static local packages.
333    Base,
334    /// CACHED packages are BASE packages that can be updated during a resolve if a full package
335    /// resolver is available.
336    Cached,
337    /// UNIVERSE packages get onto the device only when resolved by the full package resolver.
338    Universe,
339    #[doc(hidden)]
340    __SourceBreaking { unknown_ordinal: u8 },
341}
342
343/// Pattern that matches an unknown `DriverPackageType` member.
344#[macro_export]
345macro_rules! DriverPackageTypeUnknown {
346    () => {
347        _
348    };
349}
350
351impl DriverPackageType {
352    #[inline]
353    pub fn from_primitive(prim: u8) -> Option<Self> {
354        match prim {
355            0 => Some(Self::Boot),
356            1 => Some(Self::Base),
357            2 => Some(Self::Cached),
358            3 => Some(Self::Universe),
359            _ => None,
360        }
361    }
362
363    #[inline]
364    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
365        match prim {
366            0 => Self::Boot,
367            1 => Self::Base,
368            2 => Self::Cached,
369            3 => Self::Universe,
370            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
371        }
372    }
373
374    #[inline]
375    pub fn unknown() -> Self {
376        Self::__SourceBreaking { unknown_ordinal: 0xff }
377    }
378
379    #[inline]
380    pub const fn into_primitive(self) -> u8 {
381        match self {
382            Self::Boot => 0,
383            Self::Base => 1,
384            Self::Cached => 2,
385            Self::Universe => 3,
386            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
387        }
388    }
389
390    #[inline]
391    pub fn is_unknown(&self) -> bool {
392        match self {
393            Self::__SourceBreaking { unknown_ordinal: _ } => true,
394            _ => false,
395        }
396    }
397}
398
399/// Error codes for the Node protocol.
400#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
401pub enum NodeError {
402    Internal,
403    NodeRemoved,
404    NameMissing,
405    /// The Node's name is invalid. Specifically, it must not contain a period
406    /// in its name.
407    NameInvalid,
408    /// A sibling Node exists with the same name.
409    NameAlreadyExists,
410    /// An offer for this Node is missing a source name.
411    OfferSourceNameMissing,
412    /// An offer for this Node should not have a source or target.
413    OfferRefExists,
414    /// A symbol for this Node is missing a name.
415    SymbolNameMissing,
416    /// A symbol for this Node is missing an address.
417    SymbolAddressMissing,
418    /// There is another symbol for this Node with the same name.
419    SymbolAlreadyExists,
420    /// The node is in the process of unbinding all of its children.
421    UnbindChildrenInProgress,
422    /// The Node contains unsupported arguments, such as deprecated property keys or offers.
423    UnsupportedArgs,
424    #[doc(hidden)]
425    __SourceBreaking {
426        unknown_ordinal: u32,
427    },
428}
429
430/// Pattern that matches an unknown `NodeError` member.
431#[macro_export]
432macro_rules! NodeErrorUnknown {
433    () => {
434        _
435    };
436}
437
438impl NodeError {
439    #[inline]
440    pub fn from_primitive(prim: u32) -> Option<Self> {
441        match prim {
442            1 => Some(Self::Internal),
443            2 => Some(Self::NodeRemoved),
444            3 => Some(Self::NameMissing),
445            4 => Some(Self::NameInvalid),
446            5 => Some(Self::NameAlreadyExists),
447            6 => Some(Self::OfferSourceNameMissing),
448            7 => Some(Self::OfferRefExists),
449            8 => Some(Self::SymbolNameMissing),
450            9 => Some(Self::SymbolAddressMissing),
451            10 => Some(Self::SymbolAlreadyExists),
452            11 => Some(Self::UnbindChildrenInProgress),
453            12 => Some(Self::UnsupportedArgs),
454            _ => None,
455        }
456    }
457
458    #[inline]
459    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
460        match prim {
461            1 => Self::Internal,
462            2 => Self::NodeRemoved,
463            3 => Self::NameMissing,
464            4 => Self::NameInvalid,
465            5 => Self::NameAlreadyExists,
466            6 => Self::OfferSourceNameMissing,
467            7 => Self::OfferRefExists,
468            8 => Self::SymbolNameMissing,
469            9 => Self::SymbolAddressMissing,
470            10 => Self::SymbolAlreadyExists,
471            11 => Self::UnbindChildrenInProgress,
472            12 => Self::UnsupportedArgs,
473            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
474        }
475    }
476
477    #[inline]
478    pub fn unknown() -> Self {
479        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
480    }
481
482    #[inline]
483    pub const fn into_primitive(self) -> u32 {
484        match self {
485            Self::Internal => 1,
486            Self::NodeRemoved => 2,
487            Self::NameMissing => 3,
488            Self::NameInvalid => 4,
489            Self::NameAlreadyExists => 5,
490            Self::OfferSourceNameMissing => 6,
491            Self::OfferRefExists => 7,
492            Self::SymbolNameMissing => 8,
493            Self::SymbolAddressMissing => 9,
494            Self::SymbolAlreadyExists => 10,
495            Self::UnbindChildrenInProgress => 11,
496            Self::UnsupportedArgs => 12,
497            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
498        }
499    }
500
501    #[inline]
502    pub fn is_unknown(&self) -> bool {
503        match self {
504            Self::__SourceBreaking { unknown_ordinal: _ } => true,
505            _ => false,
506        }
507    }
508}
509
510/// Represents a bind rule in a parent specification.
511#[derive(Clone, Debug, PartialEq)]
512pub struct BindRule {
513    /// Property key. Only string-based keys are supported.
514    pub key: NodePropertyKey,
515    /// Condition for evaluating the property values in
516    /// the matching process. The values must be ACCEPT
517    /// or REJECT.
518    pub condition: Condition,
519    /// A list of property values. Must not be empty. The property
520    /// values must be the same type.
521    pub values: Vec<NodePropertyValue>,
522}
523
524impl fidl::Persistable for BindRule {}
525
526/// Represents a bind rule in a parent specification.
527#[derive(Clone, Debug, PartialEq)]
528pub struct BindRule2 {
529    /// Property key.
530    pub key: String,
531    /// Condition for evaluating the property values in
532    /// the matching process. The values must be ACCEPT
533    /// or REJECT.
534    pub condition: Condition,
535    /// A list of property values. Must not be empty. The property
536    /// values must be the same type.
537    pub values: Vec<NodePropertyValue>,
538}
539
540impl fidl::Persistable for BindRule2 {}
541
542/// Definition of a property for a node. A property is commonly used to match a
543/// node to a driver for driver binding.
544#[derive(Clone, Debug, PartialEq)]
545pub struct NodeProperty {
546    /// Key for the property. Integer-based keys are no longer supported. The NodePropertyKey
547    /// must be a string value.
548    pub key: NodePropertyKey,
549    /// Value for the property.
550    pub value: NodePropertyValue,
551}
552
553impl fidl::Persistable for NodeProperty {}
554
555#[derive(Clone, Debug, PartialEq)]
556pub struct NodeProperty2 {
557    /// Property key.
558    pub key: String,
559    /// Property value.
560    pub value: NodePropertyValue,
561}
562
563impl fidl::Persistable for NodeProperty2 {}
564
565/// Contains the node properties that belong to a node.
566#[derive(Clone, Debug, PartialEq)]
567pub struct NodePropertyEntry {
568    /// Name of the node that has |node_properties|.
569    pub name: String,
570    /// Node properties that belong to the node whose name is |node_name|. If
571    /// the node is a composite then |properties| is empty and does not contain
572    /// its parents' properties.
573    pub properties: Vec<NodeProperty>,
574}
575
576impl fidl::Persistable for NodePropertyEntry {}
577
578/// Contains the node properties that belong to a node.
579#[derive(Clone, Debug, PartialEq)]
580pub struct NodePropertyEntry2 {
581    /// Name of the node that has |node_properties|.
582    pub name: String,
583    /// Node properties that belong to the node whose name is |node_name|. If
584    /// the node is a composite then |properties| is empty and does not contain
585    /// its parents' properties.
586    pub properties: Vec<NodeProperty2>,
587}
588
589impl fidl::Persistable for NodePropertyEntry2 {}
590
591/// Specification for a node that parents the composite node created from the
592/// composite node specification.
593#[derive(Clone, Debug, PartialEq)]
594pub struct ParentSpec {
595    /// Parent's bind rules. Property keys must be unique. Must not be empty.
596    pub bind_rules: Vec<BindRule>,
597    /// Properties for matching against a composite driver's bind rules.
598    /// Keys must be unique and string-based.
599    pub properties: Vec<NodeProperty>,
600}
601
602impl fidl::Persistable for ParentSpec {}
603
604/// Specification for a node that parents the composite node created from the
605/// composite node specification.
606#[derive(Clone, Debug, PartialEq)]
607pub struct ParentSpec2 {
608    /// Parent's bind rules. Property keys must be unique. Must not be empty.
609    pub bind_rules: Vec<BindRule2>,
610    /// Properties for matching against a composite driver's bind rules.
611    /// Keys must be unique and string-based.
612    pub properties: Vec<NodeProperty2>,
613}
614
615impl fidl::Persistable for ParentSpec2 {}
616
617#[derive(Clone, Debug, Default, PartialEq)]
618pub struct BusInfo {
619    /// The type of bus this node sits on.
620    pub bus: Option<BusType>,
621    /// A unique identifier that describes the identity of this device on the given bus.
622    pub address: Option<DeviceAddress>,
623    /// How stable the address.
624    pub address_stability: Option<DeviceAddressStability>,
625    #[doc(hidden)]
626    pub __source_breaking: fidl::marker::SourceBreaking,
627}
628
629impl fidl::Persistable for BusInfo {}
630
631/// Information for a composite driver.
632#[derive(Clone, Debug, Default, PartialEq)]
633pub struct CompositeDriverInfo {
634    /// The name of the composite as specified in the driver's composite bind rules.
635    pub composite_name: Option<String>,
636    /// General information for the driver.
637    pub driver_info: Option<DriverInfo>,
638    #[doc(hidden)]
639    pub __source_breaking: fidl::marker::SourceBreaking,
640}
641
642impl fidl::Persistable for CompositeDriverInfo {}
643
644/// Information for a composite driver that has matched with a composite.
645#[derive(Clone, Debug, Default, PartialEq)]
646pub struct CompositeDriverMatch {
647    /// Information for the composite driver that has matched.
648    pub composite_driver: Option<CompositeDriverInfo>,
649    /// A list of all the parent names, ordered by index.
650    /// These names come from the node definitions in the driver's composite bind rules.
651    pub parent_names: Option<Vec<String>>,
652    /// The primary node index. Identified by the primary node in the driver's
653    /// composite bind rules.
654    pub primary_parent_index: Option<u32>,
655    #[doc(hidden)]
656    pub __source_breaking: fidl::marker::SourceBreaking,
657}
658
659impl fidl::Persistable for CompositeDriverMatch {}
660
661/// Information for a composite that is defined by a composite node spec.
662#[derive(Clone, Debug, Default, PartialEq)]
663pub struct CompositeInfo {
664    /// The spec information that this composite node spec was created with.
665    pub spec: Option<CompositeNodeSpec>,
666    /// Information for the node spec that is available only when a driver
667    /// has matched to the properties in this spec's parents.
668    pub matched_driver: Option<CompositeDriverMatch>,
669    #[doc(hidden)]
670    pub __source_breaking: fidl::marker::SourceBreaking,
671}
672
673impl fidl::Persistable for CompositeInfo {}
674
675/// Struct that represents a composite node specification.
676#[derive(Clone, Debug, Default, PartialEq)]
677pub struct CompositeNodeSpec {
678    /// The composite node spec's name.
679    pub name: Option<String>,
680    /// The nodes in the composite node spec. Must not be empty. The first node is
681    /// the primary node.
682    pub parents: Option<Vec<ParentSpec>>,
683    /// The nodes in the composite node spec. Must not be empty. The first node is
684    /// the primary node.
685    pub parents2: Option<Vec<ParentSpec2>>,
686    #[doc(hidden)]
687    pub __source_breaking: fidl::marker::SourceBreaking,
688}
689
690impl fidl::Persistable for CompositeNodeSpec {}
691
692/// A parent to a composite that is defined by a composite node spec.
693#[derive(Clone, Debug, Default, PartialEq)]
694pub struct CompositeParent {
695    /// Information about the composite that this is a parent of.
696    pub composite: Option<CompositeInfo>,
697    /// The index of this parent in the spec's parents.
698    pub index: Option<u32>,
699    #[doc(hidden)]
700    pub __source_breaking: fidl::marker::SourceBreaking,
701}
702
703impl fidl::Persistable for CompositeParent {}
704
705/// Device categories as provided in the driver's component manifest.
706#[derive(Clone, Debug, Default, PartialEq)]
707pub struct DeviceCategory {
708    pub category: Option<String>,
709    pub subcategory: Option<String>,
710    #[doc(hidden)]
711    pub __source_breaking: fidl::marker::SourceBreaking,
712}
713
714impl fidl::Persistable for DeviceCategory {}
715
716/// General information for a driver, used with both composite and normal drivers.
717#[derive(Clone, Debug, Default, PartialEq)]
718pub struct DriverInfo {
719    /// URL of the driver component.
720    pub url: Option<String>,
721    /// Name of the driver, taken from the first field of the `ZIRCON_DRIVER`
722    /// macro in the driver.
723    pub name: Option<String>,
724    /// If this is true then the driver should be colocated in its parent's DriverHost.
725    pub colocate: Option<bool>,
726    /// The type of package this driver is in.
727    pub package_type: Option<DriverPackageType>,
728    /// If this is true then the driver is a fallback driver. Fallback drivers have a
729    /// lesser priority for binding, so they will only be chosen for binding if there
730    /// is no non-fallback driver that has matched.
731    pub is_fallback: Option<bool>,
732    /// Device categories
733    pub device_categories: Option<Vec<DeviceCategory>>,
734    /// Bind rules which declare set of constraints to evaluate in order to
735    /// determine whether the driver indexer should bind this driver to a
736    /// device.
737    pub bind_rules_bytecode: Option<Vec<u8>>,
738    /// The version of the driver framework that this driver is using.
739    /// Supported values are 1 (DFv1) and 2 (DFv2).
740    /// If not provided, 1 is the assumed version.
741    pub driver_framework_version: Option<u8>,
742    /// Whether the driver is disabled. If true, this driver is not chosen to bind to nodes.
743    pub is_disabled: Option<bool>,
744    #[doc(hidden)]
745    pub __source_breaking: fidl::marker::SourceBreaking,
746}
747
748impl fidl::Persistable for DriverInfo {}
749
750#[derive(Clone, Debug, Default, PartialEq)]
751pub struct NodeControllerRequestBindRequest {
752    /// If this is true, then the node unbinds from its matched driver before it attempts to
753    /// bind through the normal bind process.
754    pub force_rebind: Option<bool>,
755    /// If this is set, then only drivers matching this URL suffix will be considered in
756    /// binding.
757    /// E.g: "gpt.cm", "meta/gpt.cm", "fuchsia-boot:///#meta/gpt.cm".
758    pub driver_url_suffix: Option<String>,
759    #[doc(hidden)]
760    pub __source_breaking: fidl::marker::SourceBreaking,
761}
762
763impl fidl::Persistable for NodeControllerRequestBindRequest {}
764
765/// Definition of a symbol provided by a driver for a node. A symbol is local to
766/// a driver host.
767#[derive(Clone, Debug, Default, PartialEq)]
768pub struct NodeSymbol {
769    /// Name of the symbol.
770    pub name: Option<String>,
771    /// Virtual address of the symbol, within a driver host's process.
772    pub address: Option<u64>,
773    /// Module name that provided the symbol.
774    /// Will not be provided when the symbol originates from the primary parent.
775    pub module_name: Option<String>,
776    #[doc(hidden)]
777    pub __source_breaking: fidl::marker::SourceBreaking,
778}
779
780impl fidl::Persistable for NodeSymbol {}
781
782#[derive(Clone, Debug)]
783pub enum DeviceAddress {
784    /// A fixed integer id, eg a spi bus address
785    IntValue(u8),
786    /// An array of integers, eg a PCI BDF.
787    ArrayIntValue(Vec<u8>),
788    /// A uint32 value that can be interpretted as a 4 character sequence.
789    CharIntValue(String),
790    /// An array of character sequences, eg a ACPI node path.
791    ArrayCharIntValue(Vec<String>),
792    /// A generic string, eg the device tree node path.
793    StringValue(String),
794    #[doc(hidden)]
795    __SourceBreaking { unknown_ordinal: u64 },
796}
797
798/// Pattern that matches an unknown `DeviceAddress` member.
799#[macro_export]
800macro_rules! DeviceAddressUnknown {
801    () => {
802        _
803    };
804}
805
806// Custom PartialEq so that unknown variants are not equal to themselves.
807impl PartialEq for DeviceAddress {
808    fn eq(&self, other: &Self) -> bool {
809        match (self, other) {
810            (Self::IntValue(x), Self::IntValue(y)) => *x == *y,
811            (Self::ArrayIntValue(x), Self::ArrayIntValue(y)) => *x == *y,
812            (Self::CharIntValue(x), Self::CharIntValue(y)) => *x == *y,
813            (Self::ArrayCharIntValue(x), Self::ArrayCharIntValue(y)) => *x == *y,
814            (Self::StringValue(x), Self::StringValue(y)) => *x == *y,
815            _ => false,
816        }
817    }
818}
819
820impl DeviceAddress {
821    #[inline]
822    pub fn ordinal(&self) -> u64 {
823        match *self {
824            Self::IntValue(_) => 1,
825            Self::ArrayIntValue(_) => 2,
826            Self::CharIntValue(_) => 3,
827            Self::ArrayCharIntValue(_) => 4,
828            Self::StringValue(_) => 5,
829            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
830        }
831    }
832
833    #[inline]
834    pub fn unknown_variant_for_testing() -> Self {
835        Self::__SourceBreaking { unknown_ordinal: 0 }
836    }
837
838    #[inline]
839    pub fn is_unknown(&self) -> bool {
840        match self {
841            Self::__SourceBreaking { .. } => true,
842            _ => false,
843        }
844    }
845}
846
847impl fidl::Persistable for DeviceAddress {}
848
849#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
850pub enum NodePropertyKey {
851    /// Integer-based keys are no longer supported. Use |string_value| instead.
852    IntValue(u32),
853    StringValue(String),
854}
855
856impl NodePropertyKey {
857    #[inline]
858    pub fn ordinal(&self) -> u64 {
859        match *self {
860            Self::IntValue(_) => 1,
861            Self::StringValue(_) => 2,
862        }
863    }
864}
865
866impl fidl::Persistable for NodePropertyKey {}
867
868#[derive(Clone, Debug)]
869pub enum NodePropertyValue {
870    IntValue(u32),
871    StringValue(String),
872    BoolValue(bool),
873    EnumValue(String),
874    #[doc(hidden)]
875    __SourceBreaking {
876        unknown_ordinal: u64,
877    },
878}
879
880/// Pattern that matches an unknown `NodePropertyValue` member.
881#[macro_export]
882macro_rules! NodePropertyValueUnknown {
883    () => {
884        _
885    };
886}
887
888// Custom PartialEq so that unknown variants are not equal to themselves.
889impl PartialEq for NodePropertyValue {
890    fn eq(&self, other: &Self) -> bool {
891        match (self, other) {
892            (Self::IntValue(x), Self::IntValue(y)) => *x == *y,
893            (Self::StringValue(x), Self::StringValue(y)) => *x == *y,
894            (Self::BoolValue(x), Self::BoolValue(y)) => *x == *y,
895            (Self::EnumValue(x), Self::EnumValue(y)) => *x == *y,
896            _ => false,
897        }
898    }
899}
900
901impl NodePropertyValue {
902    #[inline]
903    pub fn ordinal(&self) -> u64 {
904        match *self {
905            Self::IntValue(_) => 1,
906            Self::StringValue(_) => 2,
907            Self::BoolValue(_) => 3,
908            Self::EnumValue(_) => 4,
909            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
910        }
911    }
912
913    #[inline]
914    pub fn unknown_variant_for_testing() -> Self {
915        Self::__SourceBreaking { unknown_ordinal: 0 }
916    }
917
918    #[inline]
919    pub fn is_unknown(&self) -> bool {
920        match self {
921            Self::__SourceBreaking { .. } => true,
922            _ => false,
923        }
924    }
925}
926
927impl fidl::Persistable for NodePropertyValue {}
928
929#[derive(Clone, Debug)]
930pub enum Offer {
931    ZirconTransport(fidl_fuchsia_component_decl__common::Offer),
932    DriverTransport(fidl_fuchsia_component_decl__common::Offer),
933    #[doc(hidden)]
934    __SourceBreaking {
935        unknown_ordinal: u64,
936    },
937}
938
939/// Pattern that matches an unknown `Offer` member.
940#[macro_export]
941macro_rules! OfferUnknown {
942    () => {
943        _
944    };
945}
946
947// Custom PartialEq so that unknown variants are not equal to themselves.
948impl PartialEq for Offer {
949    fn eq(&self, other: &Self) -> bool {
950        match (self, other) {
951            (Self::ZirconTransport(x), Self::ZirconTransport(y)) => *x == *y,
952            (Self::DriverTransport(x), Self::DriverTransport(y)) => *x == *y,
953            _ => false,
954        }
955    }
956}
957
958impl Offer {
959    #[inline]
960    pub fn ordinal(&self) -> u64 {
961        match *self {
962            Self::ZirconTransport(_) => 1,
963            Self::DriverTransport(_) => 2,
964            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
965        }
966    }
967
968    #[inline]
969    pub fn unknown_variant_for_testing() -> Self {
970        Self::__SourceBreaking { unknown_ordinal: 0 }
971    }
972
973    #[inline]
974    pub fn is_unknown(&self) -> bool {
975        match self {
976            Self::__SourceBreaking { .. } => true,
977            _ => false,
978        }
979    }
980}
981
982impl fidl::Persistable for Offer {}
983
984mod internal {
985    use super::*;
986    unsafe impl fidl::encoding::TypeMarker for BusType {
987        type Owned = Self;
988
989        #[inline(always)]
990        fn inline_align(_context: fidl::encoding::Context) -> usize {
991            std::mem::align_of::<u32>()
992        }
993
994        #[inline(always)]
995        fn inline_size(_context: fidl::encoding::Context) -> usize {
996            std::mem::size_of::<u32>()
997        }
998
999        #[inline(always)]
1000        fn encode_is_copy() -> bool {
1001            false
1002        }
1003
1004        #[inline(always)]
1005        fn decode_is_copy() -> bool {
1006            false
1007        }
1008    }
1009
1010    impl fidl::encoding::ValueTypeMarker for BusType {
1011        type Borrowed<'a> = Self;
1012        #[inline(always)]
1013        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1014            *value
1015        }
1016    }
1017
1018    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for BusType {
1019        #[inline]
1020        unsafe fn encode(
1021            self,
1022            encoder: &mut fidl::encoding::Encoder<'_, D>,
1023            offset: usize,
1024            _depth: fidl::encoding::Depth,
1025        ) -> fidl::Result<()> {
1026            encoder.debug_check_bounds::<Self>(offset);
1027            encoder.write_num(self.into_primitive(), offset);
1028            Ok(())
1029        }
1030    }
1031
1032    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BusType {
1033        #[inline(always)]
1034        fn new_empty() -> Self {
1035            Self::unknown()
1036        }
1037
1038        #[inline]
1039        unsafe fn decode(
1040            &mut self,
1041            decoder: &mut fidl::encoding::Decoder<'_, D>,
1042            offset: usize,
1043            _depth: fidl::encoding::Depth,
1044        ) -> fidl::Result<()> {
1045            decoder.debug_check_bounds::<Self>(offset);
1046            let prim = decoder.read_num::<u32>(offset);
1047
1048            *self = Self::from_primitive_allow_unknown(prim);
1049            Ok(())
1050        }
1051    }
1052    unsafe impl fidl::encoding::TypeMarker for CompositeNodeSpecError {
1053        type Owned = Self;
1054
1055        #[inline(always)]
1056        fn inline_align(_context: fidl::encoding::Context) -> usize {
1057            std::mem::align_of::<u32>()
1058        }
1059
1060        #[inline(always)]
1061        fn inline_size(_context: fidl::encoding::Context) -> usize {
1062            std::mem::size_of::<u32>()
1063        }
1064
1065        #[inline(always)]
1066        fn encode_is_copy() -> bool {
1067            false
1068        }
1069
1070        #[inline(always)]
1071        fn decode_is_copy() -> bool {
1072            false
1073        }
1074    }
1075
1076    impl fidl::encoding::ValueTypeMarker for CompositeNodeSpecError {
1077        type Borrowed<'a> = Self;
1078        #[inline(always)]
1079        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1080            *value
1081        }
1082    }
1083
1084    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1085        for CompositeNodeSpecError
1086    {
1087        #[inline]
1088        unsafe fn encode(
1089            self,
1090            encoder: &mut fidl::encoding::Encoder<'_, D>,
1091            offset: usize,
1092            _depth: fidl::encoding::Depth,
1093        ) -> fidl::Result<()> {
1094            encoder.debug_check_bounds::<Self>(offset);
1095            encoder.write_num(self.into_primitive(), offset);
1096            Ok(())
1097        }
1098    }
1099
1100    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1101        for CompositeNodeSpecError
1102    {
1103        #[inline(always)]
1104        fn new_empty() -> Self {
1105            Self::unknown()
1106        }
1107
1108        #[inline]
1109        unsafe fn decode(
1110            &mut self,
1111            decoder: &mut fidl::encoding::Decoder<'_, D>,
1112            offset: usize,
1113            _depth: fidl::encoding::Depth,
1114        ) -> fidl::Result<()> {
1115            decoder.debug_check_bounds::<Self>(offset);
1116            let prim = decoder.read_num::<u32>(offset);
1117
1118            *self = Self::from_primitive_allow_unknown(prim);
1119            Ok(())
1120        }
1121    }
1122    unsafe impl fidl::encoding::TypeMarker for Condition {
1123        type Owned = Self;
1124
1125        #[inline(always)]
1126        fn inline_align(_context: fidl::encoding::Context) -> usize {
1127            std::mem::align_of::<u32>()
1128        }
1129
1130        #[inline(always)]
1131        fn inline_size(_context: fidl::encoding::Context) -> usize {
1132            std::mem::size_of::<u32>()
1133        }
1134
1135        #[inline(always)]
1136        fn encode_is_copy() -> bool {
1137            true
1138        }
1139
1140        #[inline(always)]
1141        fn decode_is_copy() -> bool {
1142            false
1143        }
1144    }
1145
1146    impl fidl::encoding::ValueTypeMarker for Condition {
1147        type Borrowed<'a> = Self;
1148        #[inline(always)]
1149        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1150            *value
1151        }
1152    }
1153
1154    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Condition {
1155        #[inline]
1156        unsafe fn encode(
1157            self,
1158            encoder: &mut fidl::encoding::Encoder<'_, D>,
1159            offset: usize,
1160            _depth: fidl::encoding::Depth,
1161        ) -> fidl::Result<()> {
1162            encoder.debug_check_bounds::<Self>(offset);
1163            encoder.write_num(self.into_primitive(), offset);
1164            Ok(())
1165        }
1166    }
1167
1168    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Condition {
1169        #[inline(always)]
1170        fn new_empty() -> Self {
1171            Self::Unknown
1172        }
1173
1174        #[inline]
1175        unsafe fn decode(
1176            &mut self,
1177            decoder: &mut fidl::encoding::Decoder<'_, D>,
1178            offset: usize,
1179            _depth: fidl::encoding::Depth,
1180        ) -> fidl::Result<()> {
1181            decoder.debug_check_bounds::<Self>(offset);
1182            let prim = decoder.read_num::<u32>(offset);
1183
1184            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1185            Ok(())
1186        }
1187    }
1188    unsafe impl fidl::encoding::TypeMarker for DeviceAddressStability {
1189        type Owned = Self;
1190
1191        #[inline(always)]
1192        fn inline_align(_context: fidl::encoding::Context) -> usize {
1193            std::mem::align_of::<u32>()
1194        }
1195
1196        #[inline(always)]
1197        fn inline_size(_context: fidl::encoding::Context) -> usize {
1198            std::mem::size_of::<u32>()
1199        }
1200
1201        #[inline(always)]
1202        fn encode_is_copy() -> bool {
1203            false
1204        }
1205
1206        #[inline(always)]
1207        fn decode_is_copy() -> bool {
1208            false
1209        }
1210    }
1211
1212    impl fidl::encoding::ValueTypeMarker for DeviceAddressStability {
1213        type Borrowed<'a> = Self;
1214        #[inline(always)]
1215        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1216            *value
1217        }
1218    }
1219
1220    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1221        for DeviceAddressStability
1222    {
1223        #[inline]
1224        unsafe fn encode(
1225            self,
1226            encoder: &mut fidl::encoding::Encoder<'_, D>,
1227            offset: usize,
1228            _depth: fidl::encoding::Depth,
1229        ) -> fidl::Result<()> {
1230            encoder.debug_check_bounds::<Self>(offset);
1231            encoder.write_num(self.into_primitive(), offset);
1232            Ok(())
1233        }
1234    }
1235
1236    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1237        for DeviceAddressStability
1238    {
1239        #[inline(always)]
1240        fn new_empty() -> Self {
1241            Self::unknown()
1242        }
1243
1244        #[inline]
1245        unsafe fn decode(
1246            &mut self,
1247            decoder: &mut fidl::encoding::Decoder<'_, D>,
1248            offset: usize,
1249            _depth: fidl::encoding::Depth,
1250        ) -> fidl::Result<()> {
1251            decoder.debug_check_bounds::<Self>(offset);
1252            let prim = decoder.read_num::<u32>(offset);
1253
1254            *self = Self::from_primitive_allow_unknown(prim);
1255            Ok(())
1256        }
1257    }
1258    unsafe impl fidl::encoding::TypeMarker for DriverPackageType {
1259        type Owned = Self;
1260
1261        #[inline(always)]
1262        fn inline_align(_context: fidl::encoding::Context) -> usize {
1263            std::mem::align_of::<u8>()
1264        }
1265
1266        #[inline(always)]
1267        fn inline_size(_context: fidl::encoding::Context) -> usize {
1268            std::mem::size_of::<u8>()
1269        }
1270
1271        #[inline(always)]
1272        fn encode_is_copy() -> bool {
1273            false
1274        }
1275
1276        #[inline(always)]
1277        fn decode_is_copy() -> bool {
1278            false
1279        }
1280    }
1281
1282    impl fidl::encoding::ValueTypeMarker for DriverPackageType {
1283        type Borrowed<'a> = Self;
1284        #[inline(always)]
1285        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1286            *value
1287        }
1288    }
1289
1290    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1291        for DriverPackageType
1292    {
1293        #[inline]
1294        unsafe fn encode(
1295            self,
1296            encoder: &mut fidl::encoding::Encoder<'_, D>,
1297            offset: usize,
1298            _depth: fidl::encoding::Depth,
1299        ) -> fidl::Result<()> {
1300            encoder.debug_check_bounds::<Self>(offset);
1301            encoder.write_num(self.into_primitive(), offset);
1302            Ok(())
1303        }
1304    }
1305
1306    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DriverPackageType {
1307        #[inline(always)]
1308        fn new_empty() -> Self {
1309            Self::unknown()
1310        }
1311
1312        #[inline]
1313        unsafe fn decode(
1314            &mut self,
1315            decoder: &mut fidl::encoding::Decoder<'_, D>,
1316            offset: usize,
1317            _depth: fidl::encoding::Depth,
1318        ) -> fidl::Result<()> {
1319            decoder.debug_check_bounds::<Self>(offset);
1320            let prim = decoder.read_num::<u8>(offset);
1321
1322            *self = Self::from_primitive_allow_unknown(prim);
1323            Ok(())
1324        }
1325    }
1326    unsafe impl fidl::encoding::TypeMarker for NodeError {
1327        type Owned = Self;
1328
1329        #[inline(always)]
1330        fn inline_align(_context: fidl::encoding::Context) -> usize {
1331            std::mem::align_of::<u32>()
1332        }
1333
1334        #[inline(always)]
1335        fn inline_size(_context: fidl::encoding::Context) -> usize {
1336            std::mem::size_of::<u32>()
1337        }
1338
1339        #[inline(always)]
1340        fn encode_is_copy() -> bool {
1341            false
1342        }
1343
1344        #[inline(always)]
1345        fn decode_is_copy() -> bool {
1346            false
1347        }
1348    }
1349
1350    impl fidl::encoding::ValueTypeMarker for NodeError {
1351        type Borrowed<'a> = Self;
1352        #[inline(always)]
1353        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1354            *value
1355        }
1356    }
1357
1358    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for NodeError {
1359        #[inline]
1360        unsafe fn encode(
1361            self,
1362            encoder: &mut fidl::encoding::Encoder<'_, D>,
1363            offset: usize,
1364            _depth: fidl::encoding::Depth,
1365        ) -> fidl::Result<()> {
1366            encoder.debug_check_bounds::<Self>(offset);
1367            encoder.write_num(self.into_primitive(), offset);
1368            Ok(())
1369        }
1370    }
1371
1372    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeError {
1373        #[inline(always)]
1374        fn new_empty() -> Self {
1375            Self::unknown()
1376        }
1377
1378        #[inline]
1379        unsafe fn decode(
1380            &mut self,
1381            decoder: &mut fidl::encoding::Decoder<'_, D>,
1382            offset: usize,
1383            _depth: fidl::encoding::Depth,
1384        ) -> fidl::Result<()> {
1385            decoder.debug_check_bounds::<Self>(offset);
1386            let prim = decoder.read_num::<u32>(offset);
1387
1388            *self = Self::from_primitive_allow_unknown(prim);
1389            Ok(())
1390        }
1391    }
1392
1393    impl fidl::encoding::ValueTypeMarker for BindRule {
1394        type Borrowed<'a> = &'a Self;
1395        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1396            value
1397        }
1398    }
1399
1400    unsafe impl fidl::encoding::TypeMarker for BindRule {
1401        type Owned = Self;
1402
1403        #[inline(always)]
1404        fn inline_align(_context: fidl::encoding::Context) -> usize {
1405            8
1406        }
1407
1408        #[inline(always)]
1409        fn inline_size(_context: fidl::encoding::Context) -> usize {
1410            40
1411        }
1412    }
1413
1414    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BindRule, D> for &BindRule {
1415        #[inline]
1416        unsafe fn encode(
1417            self,
1418            encoder: &mut fidl::encoding::Encoder<'_, D>,
1419            offset: usize,
1420            _depth: fidl::encoding::Depth,
1421        ) -> fidl::Result<()> {
1422            encoder.debug_check_bounds::<BindRule>(offset);
1423            // Delegate to tuple encoding.
1424            fidl::encoding::Encode::<BindRule, D>::encode(
1425                (
1426                    <NodePropertyKey as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
1427                    <Condition as fidl::encoding::ValueTypeMarker>::borrow(&self.condition),
1428                    <fidl::encoding::Vector<NodePropertyValue, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.values),
1429                ),
1430                encoder, offset, _depth
1431            )
1432        }
1433    }
1434    unsafe impl<
1435            D: fidl::encoding::ResourceDialect,
1436            T0: fidl::encoding::Encode<NodePropertyKey, D>,
1437            T1: fidl::encoding::Encode<Condition, D>,
1438            T2: fidl::encoding::Encode<fidl::encoding::Vector<NodePropertyValue, 64>, D>,
1439        > fidl::encoding::Encode<BindRule, D> for (T0, T1, T2)
1440    {
1441        #[inline]
1442        unsafe fn encode(
1443            self,
1444            encoder: &mut fidl::encoding::Encoder<'_, D>,
1445            offset: usize,
1446            depth: fidl::encoding::Depth,
1447        ) -> fidl::Result<()> {
1448            encoder.debug_check_bounds::<BindRule>(offset);
1449            // Zero out padding regions. There's no need to apply masks
1450            // because the unmasked parts will be overwritten by fields.
1451            unsafe {
1452                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
1453                (ptr as *mut u64).write_unaligned(0);
1454            }
1455            // Write the fields.
1456            self.0.encode(encoder, offset + 0, depth)?;
1457            self.1.encode(encoder, offset + 16, depth)?;
1458            self.2.encode(encoder, offset + 24, depth)?;
1459            Ok(())
1460        }
1461    }
1462
1463    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BindRule {
1464        #[inline(always)]
1465        fn new_empty() -> Self {
1466            Self {
1467                key: fidl::new_empty!(NodePropertyKey, D),
1468                condition: fidl::new_empty!(Condition, D),
1469                values: fidl::new_empty!(fidl::encoding::Vector<NodePropertyValue, 64>, D),
1470            }
1471        }
1472
1473        #[inline]
1474        unsafe fn decode(
1475            &mut self,
1476            decoder: &mut fidl::encoding::Decoder<'_, D>,
1477            offset: usize,
1478            _depth: fidl::encoding::Depth,
1479        ) -> fidl::Result<()> {
1480            decoder.debug_check_bounds::<Self>(offset);
1481            // Verify that padding bytes are zero.
1482            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
1483            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1484            let mask = 0xffffffff00000000u64;
1485            let maskedval = padval & mask;
1486            if maskedval != 0 {
1487                return Err(fidl::Error::NonZeroPadding {
1488                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
1489                });
1490            }
1491            fidl::decode!(NodePropertyKey, D, &mut self.key, decoder, offset + 0, _depth)?;
1492            fidl::decode!(Condition, D, &mut self.condition, decoder, offset + 16, _depth)?;
1493            fidl::decode!(fidl::encoding::Vector<NodePropertyValue, 64>, D, &mut self.values, decoder, offset + 24, _depth)?;
1494            Ok(())
1495        }
1496    }
1497
1498    impl fidl::encoding::ValueTypeMarker for BindRule2 {
1499        type Borrowed<'a> = &'a Self;
1500        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1501            value
1502        }
1503    }
1504
1505    unsafe impl fidl::encoding::TypeMarker for BindRule2 {
1506        type Owned = Self;
1507
1508        #[inline(always)]
1509        fn inline_align(_context: fidl::encoding::Context) -> usize {
1510            8
1511        }
1512
1513        #[inline(always)]
1514        fn inline_size(_context: fidl::encoding::Context) -> usize {
1515            40
1516        }
1517    }
1518
1519    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BindRule2, D>
1520        for &BindRule2
1521    {
1522        #[inline]
1523        unsafe fn encode(
1524            self,
1525            encoder: &mut fidl::encoding::Encoder<'_, D>,
1526            offset: usize,
1527            _depth: fidl::encoding::Depth,
1528        ) -> fidl::Result<()> {
1529            encoder.debug_check_bounds::<BindRule2>(offset);
1530            // Delegate to tuple encoding.
1531            fidl::encoding::Encode::<BindRule2, D>::encode(
1532                (
1533                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
1534                    <Condition as fidl::encoding::ValueTypeMarker>::borrow(&self.condition),
1535                    <fidl::encoding::Vector<NodePropertyValue, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.values),
1536                ),
1537                encoder, offset, _depth
1538            )
1539        }
1540    }
1541    unsafe impl<
1542            D: fidl::encoding::ResourceDialect,
1543            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
1544            T1: fidl::encoding::Encode<Condition, D>,
1545            T2: fidl::encoding::Encode<fidl::encoding::Vector<NodePropertyValue, 64>, D>,
1546        > fidl::encoding::Encode<BindRule2, D> for (T0, T1, T2)
1547    {
1548        #[inline]
1549        unsafe fn encode(
1550            self,
1551            encoder: &mut fidl::encoding::Encoder<'_, D>,
1552            offset: usize,
1553            depth: fidl::encoding::Depth,
1554        ) -> fidl::Result<()> {
1555            encoder.debug_check_bounds::<BindRule2>(offset);
1556            // Zero out padding regions. There's no need to apply masks
1557            // because the unmasked parts will be overwritten by fields.
1558            unsafe {
1559                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
1560                (ptr as *mut u64).write_unaligned(0);
1561            }
1562            // Write the fields.
1563            self.0.encode(encoder, offset + 0, depth)?;
1564            self.1.encode(encoder, offset + 16, depth)?;
1565            self.2.encode(encoder, offset + 24, depth)?;
1566            Ok(())
1567        }
1568    }
1569
1570    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BindRule2 {
1571        #[inline(always)]
1572        fn new_empty() -> Self {
1573            Self {
1574                key: fidl::new_empty!(fidl::encoding::BoundedString<256>, D),
1575                condition: fidl::new_empty!(Condition, D),
1576                values: fidl::new_empty!(fidl::encoding::Vector<NodePropertyValue, 64>, D),
1577            }
1578        }
1579
1580        #[inline]
1581        unsafe fn decode(
1582            &mut self,
1583            decoder: &mut fidl::encoding::Decoder<'_, D>,
1584            offset: usize,
1585            _depth: fidl::encoding::Depth,
1586        ) -> fidl::Result<()> {
1587            decoder.debug_check_bounds::<Self>(offset);
1588            // Verify that padding bytes are zero.
1589            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
1590            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1591            let mask = 0xffffffff00000000u64;
1592            let maskedval = padval & mask;
1593            if maskedval != 0 {
1594                return Err(fidl::Error::NonZeroPadding {
1595                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
1596                });
1597            }
1598            fidl::decode!(
1599                fidl::encoding::BoundedString<256>,
1600                D,
1601                &mut self.key,
1602                decoder,
1603                offset + 0,
1604                _depth
1605            )?;
1606            fidl::decode!(Condition, D, &mut self.condition, decoder, offset + 16, _depth)?;
1607            fidl::decode!(fidl::encoding::Vector<NodePropertyValue, 64>, D, &mut self.values, decoder, offset + 24, _depth)?;
1608            Ok(())
1609        }
1610    }
1611
1612    impl fidl::encoding::ValueTypeMarker for NodeProperty {
1613        type Borrowed<'a> = &'a Self;
1614        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1615            value
1616        }
1617    }
1618
1619    unsafe impl fidl::encoding::TypeMarker for NodeProperty {
1620        type Owned = Self;
1621
1622        #[inline(always)]
1623        fn inline_align(_context: fidl::encoding::Context) -> usize {
1624            8
1625        }
1626
1627        #[inline(always)]
1628        fn inline_size(_context: fidl::encoding::Context) -> usize {
1629            32
1630        }
1631    }
1632
1633    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeProperty, D>
1634        for &NodeProperty
1635    {
1636        #[inline]
1637        unsafe fn encode(
1638            self,
1639            encoder: &mut fidl::encoding::Encoder<'_, D>,
1640            offset: usize,
1641            _depth: fidl::encoding::Depth,
1642        ) -> fidl::Result<()> {
1643            encoder.debug_check_bounds::<NodeProperty>(offset);
1644            // Delegate to tuple encoding.
1645            fidl::encoding::Encode::<NodeProperty, D>::encode(
1646                (
1647                    <NodePropertyKey as fidl::encoding::ValueTypeMarker>::borrow(&self.key),
1648                    <NodePropertyValue as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
1649                ),
1650                encoder,
1651                offset,
1652                _depth,
1653            )
1654        }
1655    }
1656    unsafe impl<
1657            D: fidl::encoding::ResourceDialect,
1658            T0: fidl::encoding::Encode<NodePropertyKey, D>,
1659            T1: fidl::encoding::Encode<NodePropertyValue, D>,
1660        > fidl::encoding::Encode<NodeProperty, D> for (T0, T1)
1661    {
1662        #[inline]
1663        unsafe fn encode(
1664            self,
1665            encoder: &mut fidl::encoding::Encoder<'_, D>,
1666            offset: usize,
1667            depth: fidl::encoding::Depth,
1668        ) -> fidl::Result<()> {
1669            encoder.debug_check_bounds::<NodeProperty>(offset);
1670            // Zero out padding regions. There's no need to apply masks
1671            // because the unmasked parts will be overwritten by fields.
1672            // Write the fields.
1673            self.0.encode(encoder, offset + 0, depth)?;
1674            self.1.encode(encoder, offset + 16, depth)?;
1675            Ok(())
1676        }
1677    }
1678
1679    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeProperty {
1680        #[inline(always)]
1681        fn new_empty() -> Self {
1682            Self {
1683                key: fidl::new_empty!(NodePropertyKey, D),
1684                value: fidl::new_empty!(NodePropertyValue, D),
1685            }
1686        }
1687
1688        #[inline]
1689        unsafe fn decode(
1690            &mut self,
1691            decoder: &mut fidl::encoding::Decoder<'_, D>,
1692            offset: usize,
1693            _depth: fidl::encoding::Depth,
1694        ) -> fidl::Result<()> {
1695            decoder.debug_check_bounds::<Self>(offset);
1696            // Verify that padding bytes are zero.
1697            fidl::decode!(NodePropertyKey, D, &mut self.key, decoder, offset + 0, _depth)?;
1698            fidl::decode!(NodePropertyValue, D, &mut self.value, decoder, offset + 16, _depth)?;
1699            Ok(())
1700        }
1701    }
1702
1703    impl fidl::encoding::ValueTypeMarker for NodeProperty2 {
1704        type Borrowed<'a> = &'a Self;
1705        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1706            value
1707        }
1708    }
1709
1710    unsafe impl fidl::encoding::TypeMarker for NodeProperty2 {
1711        type Owned = Self;
1712
1713        #[inline(always)]
1714        fn inline_align(_context: fidl::encoding::Context) -> usize {
1715            8
1716        }
1717
1718        #[inline(always)]
1719        fn inline_size(_context: fidl::encoding::Context) -> usize {
1720            32
1721        }
1722    }
1723
1724    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeProperty2, D>
1725        for &NodeProperty2
1726    {
1727        #[inline]
1728        unsafe fn encode(
1729            self,
1730            encoder: &mut fidl::encoding::Encoder<'_, D>,
1731            offset: usize,
1732            _depth: fidl::encoding::Depth,
1733        ) -> fidl::Result<()> {
1734            encoder.debug_check_bounds::<NodeProperty2>(offset);
1735            // Delegate to tuple encoding.
1736            fidl::encoding::Encode::<NodeProperty2, D>::encode(
1737                (
1738                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
1739                        &self.key,
1740                    ),
1741                    <NodePropertyValue as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
1742                ),
1743                encoder,
1744                offset,
1745                _depth,
1746            )
1747        }
1748    }
1749    unsafe impl<
1750            D: fidl::encoding::ResourceDialect,
1751            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<256>, D>,
1752            T1: fidl::encoding::Encode<NodePropertyValue, D>,
1753        > fidl::encoding::Encode<NodeProperty2, D> for (T0, T1)
1754    {
1755        #[inline]
1756        unsafe fn encode(
1757            self,
1758            encoder: &mut fidl::encoding::Encoder<'_, D>,
1759            offset: usize,
1760            depth: fidl::encoding::Depth,
1761        ) -> fidl::Result<()> {
1762            encoder.debug_check_bounds::<NodeProperty2>(offset);
1763            // Zero out padding regions. There's no need to apply masks
1764            // because the unmasked parts will be overwritten by fields.
1765            // Write the fields.
1766            self.0.encode(encoder, offset + 0, depth)?;
1767            self.1.encode(encoder, offset + 16, depth)?;
1768            Ok(())
1769        }
1770    }
1771
1772    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeProperty2 {
1773        #[inline(always)]
1774        fn new_empty() -> Self {
1775            Self {
1776                key: fidl::new_empty!(fidl::encoding::BoundedString<256>, D),
1777                value: fidl::new_empty!(NodePropertyValue, D),
1778            }
1779        }
1780
1781        #[inline]
1782        unsafe fn decode(
1783            &mut self,
1784            decoder: &mut fidl::encoding::Decoder<'_, D>,
1785            offset: usize,
1786            _depth: fidl::encoding::Depth,
1787        ) -> fidl::Result<()> {
1788            decoder.debug_check_bounds::<Self>(offset);
1789            // Verify that padding bytes are zero.
1790            fidl::decode!(
1791                fidl::encoding::BoundedString<256>,
1792                D,
1793                &mut self.key,
1794                decoder,
1795                offset + 0,
1796                _depth
1797            )?;
1798            fidl::decode!(NodePropertyValue, D, &mut self.value, decoder, offset + 16, _depth)?;
1799            Ok(())
1800        }
1801    }
1802
1803    impl fidl::encoding::ValueTypeMarker for NodePropertyEntry {
1804        type Borrowed<'a> = &'a Self;
1805        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1806            value
1807        }
1808    }
1809
1810    unsafe impl fidl::encoding::TypeMarker for NodePropertyEntry {
1811        type Owned = Self;
1812
1813        #[inline(always)]
1814        fn inline_align(_context: fidl::encoding::Context) -> usize {
1815            8
1816        }
1817
1818        #[inline(always)]
1819        fn inline_size(_context: fidl::encoding::Context) -> usize {
1820            32
1821        }
1822    }
1823
1824    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodePropertyEntry, D>
1825        for &NodePropertyEntry
1826    {
1827        #[inline]
1828        unsafe fn encode(
1829            self,
1830            encoder: &mut fidl::encoding::Encoder<'_, D>,
1831            offset: usize,
1832            _depth: fidl::encoding::Depth,
1833        ) -> fidl::Result<()> {
1834            encoder.debug_check_bounds::<NodePropertyEntry>(offset);
1835            // Delegate to tuple encoding.
1836            fidl::encoding::Encode::<NodePropertyEntry, D>::encode(
1837                (
1838                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1839                    <fidl::encoding::Vector<NodeProperty, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
1840                ),
1841                encoder, offset, _depth
1842            )
1843        }
1844    }
1845    unsafe impl<
1846            D: fidl::encoding::ResourceDialect,
1847            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<128>, D>,
1848            T1: fidl::encoding::Encode<fidl::encoding::Vector<NodeProperty, 64>, D>,
1849        > fidl::encoding::Encode<NodePropertyEntry, D> for (T0, T1)
1850    {
1851        #[inline]
1852        unsafe fn encode(
1853            self,
1854            encoder: &mut fidl::encoding::Encoder<'_, D>,
1855            offset: usize,
1856            depth: fidl::encoding::Depth,
1857        ) -> fidl::Result<()> {
1858            encoder.debug_check_bounds::<NodePropertyEntry>(offset);
1859            // Zero out padding regions. There's no need to apply masks
1860            // because the unmasked parts will be overwritten by fields.
1861            // Write the fields.
1862            self.0.encode(encoder, offset + 0, depth)?;
1863            self.1.encode(encoder, offset + 16, depth)?;
1864            Ok(())
1865        }
1866    }
1867
1868    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodePropertyEntry {
1869        #[inline(always)]
1870        fn new_empty() -> Self {
1871            Self {
1872                name: fidl::new_empty!(fidl::encoding::BoundedString<128>, D),
1873                properties: fidl::new_empty!(fidl::encoding::Vector<NodeProperty, 64>, D),
1874            }
1875        }
1876
1877        #[inline]
1878        unsafe fn decode(
1879            &mut self,
1880            decoder: &mut fidl::encoding::Decoder<'_, D>,
1881            offset: usize,
1882            _depth: fidl::encoding::Depth,
1883        ) -> fidl::Result<()> {
1884            decoder.debug_check_bounds::<Self>(offset);
1885            // Verify that padding bytes are zero.
1886            fidl::decode!(
1887                fidl::encoding::BoundedString<128>,
1888                D,
1889                &mut self.name,
1890                decoder,
1891                offset + 0,
1892                _depth
1893            )?;
1894            fidl::decode!(fidl::encoding::Vector<NodeProperty, 64>, D, &mut self.properties, decoder, offset + 16, _depth)?;
1895            Ok(())
1896        }
1897    }
1898
1899    impl fidl::encoding::ValueTypeMarker for NodePropertyEntry2 {
1900        type Borrowed<'a> = &'a Self;
1901        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1902            value
1903        }
1904    }
1905
1906    unsafe impl fidl::encoding::TypeMarker for NodePropertyEntry2 {
1907        type Owned = Self;
1908
1909        #[inline(always)]
1910        fn inline_align(_context: fidl::encoding::Context) -> usize {
1911            8
1912        }
1913
1914        #[inline(always)]
1915        fn inline_size(_context: fidl::encoding::Context) -> usize {
1916            32
1917        }
1918    }
1919
1920    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodePropertyEntry2, D>
1921        for &NodePropertyEntry2
1922    {
1923        #[inline]
1924        unsafe fn encode(
1925            self,
1926            encoder: &mut fidl::encoding::Encoder<'_, D>,
1927            offset: usize,
1928            _depth: fidl::encoding::Depth,
1929        ) -> fidl::Result<()> {
1930            encoder.debug_check_bounds::<NodePropertyEntry2>(offset);
1931            // Delegate to tuple encoding.
1932            fidl::encoding::Encode::<NodePropertyEntry2, D>::encode(
1933                (
1934                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1935                    <fidl::encoding::Vector<NodeProperty2, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
1936                ),
1937                encoder, offset, _depth
1938            )
1939        }
1940    }
1941    unsafe impl<
1942            D: fidl::encoding::ResourceDialect,
1943            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<128>, D>,
1944            T1: fidl::encoding::Encode<fidl::encoding::Vector<NodeProperty2, 64>, D>,
1945        > fidl::encoding::Encode<NodePropertyEntry2, D> for (T0, T1)
1946    {
1947        #[inline]
1948        unsafe fn encode(
1949            self,
1950            encoder: &mut fidl::encoding::Encoder<'_, D>,
1951            offset: usize,
1952            depth: fidl::encoding::Depth,
1953        ) -> fidl::Result<()> {
1954            encoder.debug_check_bounds::<NodePropertyEntry2>(offset);
1955            // Zero out padding regions. There's no need to apply masks
1956            // because the unmasked parts will be overwritten by fields.
1957            // Write the fields.
1958            self.0.encode(encoder, offset + 0, depth)?;
1959            self.1.encode(encoder, offset + 16, depth)?;
1960            Ok(())
1961        }
1962    }
1963
1964    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodePropertyEntry2 {
1965        #[inline(always)]
1966        fn new_empty() -> Self {
1967            Self {
1968                name: fidl::new_empty!(fidl::encoding::BoundedString<128>, D),
1969                properties: fidl::new_empty!(fidl::encoding::Vector<NodeProperty2, 64>, D),
1970            }
1971        }
1972
1973        #[inline]
1974        unsafe fn decode(
1975            &mut self,
1976            decoder: &mut fidl::encoding::Decoder<'_, D>,
1977            offset: usize,
1978            _depth: fidl::encoding::Depth,
1979        ) -> fidl::Result<()> {
1980            decoder.debug_check_bounds::<Self>(offset);
1981            // Verify that padding bytes are zero.
1982            fidl::decode!(
1983                fidl::encoding::BoundedString<128>,
1984                D,
1985                &mut self.name,
1986                decoder,
1987                offset + 0,
1988                _depth
1989            )?;
1990            fidl::decode!(fidl::encoding::Vector<NodeProperty2, 64>, D, &mut self.properties, decoder, offset + 16, _depth)?;
1991            Ok(())
1992        }
1993    }
1994
1995    impl fidl::encoding::ValueTypeMarker for ParentSpec {
1996        type Borrowed<'a> = &'a Self;
1997        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1998            value
1999        }
2000    }
2001
2002    unsafe impl fidl::encoding::TypeMarker for ParentSpec {
2003        type Owned = Self;
2004
2005        #[inline(always)]
2006        fn inline_align(_context: fidl::encoding::Context) -> usize {
2007            8
2008        }
2009
2010        #[inline(always)]
2011        fn inline_size(_context: fidl::encoding::Context) -> usize {
2012            32
2013        }
2014    }
2015
2016    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ParentSpec, D>
2017        for &ParentSpec
2018    {
2019        #[inline]
2020        unsafe fn encode(
2021            self,
2022            encoder: &mut fidl::encoding::Encoder<'_, D>,
2023            offset: usize,
2024            _depth: fidl::encoding::Depth,
2025        ) -> fidl::Result<()> {
2026            encoder.debug_check_bounds::<ParentSpec>(offset);
2027            // Delegate to tuple encoding.
2028            fidl::encoding::Encode::<ParentSpec, D>::encode(
2029                (
2030                    <fidl::encoding::Vector<BindRule, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.bind_rules),
2031                    <fidl::encoding::Vector<NodeProperty, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
2032                ),
2033                encoder, offset, _depth
2034            )
2035        }
2036    }
2037    unsafe impl<
2038            D: fidl::encoding::ResourceDialect,
2039            T0: fidl::encoding::Encode<fidl::encoding::Vector<BindRule, 64>, D>,
2040            T1: fidl::encoding::Encode<fidl::encoding::Vector<NodeProperty, 64>, D>,
2041        > fidl::encoding::Encode<ParentSpec, D> for (T0, T1)
2042    {
2043        #[inline]
2044        unsafe fn encode(
2045            self,
2046            encoder: &mut fidl::encoding::Encoder<'_, D>,
2047            offset: usize,
2048            depth: fidl::encoding::Depth,
2049        ) -> fidl::Result<()> {
2050            encoder.debug_check_bounds::<ParentSpec>(offset);
2051            // Zero out padding regions. There's no need to apply masks
2052            // because the unmasked parts will be overwritten by fields.
2053            // Write the fields.
2054            self.0.encode(encoder, offset + 0, depth)?;
2055            self.1.encode(encoder, offset + 16, depth)?;
2056            Ok(())
2057        }
2058    }
2059
2060    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ParentSpec {
2061        #[inline(always)]
2062        fn new_empty() -> Self {
2063            Self {
2064                bind_rules: fidl::new_empty!(fidl::encoding::Vector<BindRule, 64>, D),
2065                properties: fidl::new_empty!(fidl::encoding::Vector<NodeProperty, 64>, D),
2066            }
2067        }
2068
2069        #[inline]
2070        unsafe fn decode(
2071            &mut self,
2072            decoder: &mut fidl::encoding::Decoder<'_, D>,
2073            offset: usize,
2074            _depth: fidl::encoding::Depth,
2075        ) -> fidl::Result<()> {
2076            decoder.debug_check_bounds::<Self>(offset);
2077            // Verify that padding bytes are zero.
2078            fidl::decode!(fidl::encoding::Vector<BindRule, 64>, D, &mut self.bind_rules, decoder, offset + 0, _depth)?;
2079            fidl::decode!(fidl::encoding::Vector<NodeProperty, 64>, D, &mut self.properties, decoder, offset + 16, _depth)?;
2080            Ok(())
2081        }
2082    }
2083
2084    impl fidl::encoding::ValueTypeMarker for ParentSpec2 {
2085        type Borrowed<'a> = &'a Self;
2086        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2087            value
2088        }
2089    }
2090
2091    unsafe impl fidl::encoding::TypeMarker for ParentSpec2 {
2092        type Owned = Self;
2093
2094        #[inline(always)]
2095        fn inline_align(_context: fidl::encoding::Context) -> usize {
2096            8
2097        }
2098
2099        #[inline(always)]
2100        fn inline_size(_context: fidl::encoding::Context) -> usize {
2101            32
2102        }
2103    }
2104
2105    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ParentSpec2, D>
2106        for &ParentSpec2
2107    {
2108        #[inline]
2109        unsafe fn encode(
2110            self,
2111            encoder: &mut fidl::encoding::Encoder<'_, D>,
2112            offset: usize,
2113            _depth: fidl::encoding::Depth,
2114        ) -> fidl::Result<()> {
2115            encoder.debug_check_bounds::<ParentSpec2>(offset);
2116            // Delegate to tuple encoding.
2117            fidl::encoding::Encode::<ParentSpec2, D>::encode(
2118                (
2119                    <fidl::encoding::Vector<BindRule2, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.bind_rules),
2120                    <fidl::encoding::Vector<NodeProperty2, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.properties),
2121                ),
2122                encoder, offset, _depth
2123            )
2124        }
2125    }
2126    unsafe impl<
2127            D: fidl::encoding::ResourceDialect,
2128            T0: fidl::encoding::Encode<fidl::encoding::Vector<BindRule2, 64>, D>,
2129            T1: fidl::encoding::Encode<fidl::encoding::Vector<NodeProperty2, 64>, D>,
2130        > fidl::encoding::Encode<ParentSpec2, D> for (T0, T1)
2131    {
2132        #[inline]
2133        unsafe fn encode(
2134            self,
2135            encoder: &mut fidl::encoding::Encoder<'_, D>,
2136            offset: usize,
2137            depth: fidl::encoding::Depth,
2138        ) -> fidl::Result<()> {
2139            encoder.debug_check_bounds::<ParentSpec2>(offset);
2140            // Zero out padding regions. There's no need to apply masks
2141            // because the unmasked parts will be overwritten by fields.
2142            // Write the fields.
2143            self.0.encode(encoder, offset + 0, depth)?;
2144            self.1.encode(encoder, offset + 16, depth)?;
2145            Ok(())
2146        }
2147    }
2148
2149    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ParentSpec2 {
2150        #[inline(always)]
2151        fn new_empty() -> Self {
2152            Self {
2153                bind_rules: fidl::new_empty!(fidl::encoding::Vector<BindRule2, 64>, D),
2154                properties: fidl::new_empty!(fidl::encoding::Vector<NodeProperty2, 64>, D),
2155            }
2156        }
2157
2158        #[inline]
2159        unsafe fn decode(
2160            &mut self,
2161            decoder: &mut fidl::encoding::Decoder<'_, D>,
2162            offset: usize,
2163            _depth: fidl::encoding::Depth,
2164        ) -> fidl::Result<()> {
2165            decoder.debug_check_bounds::<Self>(offset);
2166            // Verify that padding bytes are zero.
2167            fidl::decode!(fidl::encoding::Vector<BindRule2, 64>, D, &mut self.bind_rules, decoder, offset + 0, _depth)?;
2168            fidl::decode!(fidl::encoding::Vector<NodeProperty2, 64>, D, &mut self.properties, decoder, offset + 16, _depth)?;
2169            Ok(())
2170        }
2171    }
2172
2173    impl BusInfo {
2174        #[inline(always)]
2175        fn max_ordinal_present(&self) -> u64 {
2176            if let Some(_) = self.address_stability {
2177                return 3;
2178            }
2179            if let Some(_) = self.address {
2180                return 2;
2181            }
2182            if let Some(_) = self.bus {
2183                return 1;
2184            }
2185            0
2186        }
2187    }
2188
2189    impl fidl::encoding::ValueTypeMarker for BusInfo {
2190        type Borrowed<'a> = &'a Self;
2191        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2192            value
2193        }
2194    }
2195
2196    unsafe impl fidl::encoding::TypeMarker for BusInfo {
2197        type Owned = Self;
2198
2199        #[inline(always)]
2200        fn inline_align(_context: fidl::encoding::Context) -> usize {
2201            8
2202        }
2203
2204        #[inline(always)]
2205        fn inline_size(_context: fidl::encoding::Context) -> usize {
2206            16
2207        }
2208    }
2209
2210    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BusInfo, D> for &BusInfo {
2211        unsafe fn encode(
2212            self,
2213            encoder: &mut fidl::encoding::Encoder<'_, D>,
2214            offset: usize,
2215            mut depth: fidl::encoding::Depth,
2216        ) -> fidl::Result<()> {
2217            encoder.debug_check_bounds::<BusInfo>(offset);
2218            // Vector header
2219            let max_ordinal: u64 = self.max_ordinal_present();
2220            encoder.write_num(max_ordinal, offset);
2221            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2222            // Calling encoder.out_of_line_offset(0) is not allowed.
2223            if max_ordinal == 0 {
2224                return Ok(());
2225            }
2226            depth.increment()?;
2227            let envelope_size = 8;
2228            let bytes_len = max_ordinal as usize * envelope_size;
2229            #[allow(unused_variables)]
2230            let offset = encoder.out_of_line_offset(bytes_len);
2231            let mut _prev_end_offset: usize = 0;
2232            if 1 > max_ordinal {
2233                return Ok(());
2234            }
2235
2236            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2237            // are envelope_size bytes.
2238            let cur_offset: usize = (1 - 1) * envelope_size;
2239
2240            // Zero reserved fields.
2241            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2242
2243            // Safety:
2244            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2245            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2246            //   envelope_size bytes, there is always sufficient room.
2247            fidl::encoding::encode_in_envelope_optional::<BusType, D>(
2248                self.bus.as_ref().map(<BusType as fidl::encoding::ValueTypeMarker>::borrow),
2249                encoder,
2250                offset + cur_offset,
2251                depth,
2252            )?;
2253
2254            _prev_end_offset = cur_offset + envelope_size;
2255            if 2 > max_ordinal {
2256                return Ok(());
2257            }
2258
2259            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2260            // are envelope_size bytes.
2261            let cur_offset: usize = (2 - 1) * envelope_size;
2262
2263            // Zero reserved fields.
2264            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2265
2266            // Safety:
2267            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2268            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2269            //   envelope_size bytes, there is always sufficient room.
2270            fidl::encoding::encode_in_envelope_optional::<DeviceAddress, D>(
2271                self.address
2272                    .as_ref()
2273                    .map(<DeviceAddress as fidl::encoding::ValueTypeMarker>::borrow),
2274                encoder,
2275                offset + cur_offset,
2276                depth,
2277            )?;
2278
2279            _prev_end_offset = cur_offset + envelope_size;
2280            if 3 > max_ordinal {
2281                return Ok(());
2282            }
2283
2284            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2285            // are envelope_size bytes.
2286            let cur_offset: usize = (3 - 1) * envelope_size;
2287
2288            // Zero reserved fields.
2289            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2290
2291            // Safety:
2292            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2293            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2294            //   envelope_size bytes, there is always sufficient room.
2295            fidl::encoding::encode_in_envelope_optional::<DeviceAddressStability, D>(
2296                self.address_stability
2297                    .as_ref()
2298                    .map(<DeviceAddressStability as fidl::encoding::ValueTypeMarker>::borrow),
2299                encoder,
2300                offset + cur_offset,
2301                depth,
2302            )?;
2303
2304            _prev_end_offset = cur_offset + envelope_size;
2305
2306            Ok(())
2307        }
2308    }
2309
2310    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BusInfo {
2311        #[inline(always)]
2312        fn new_empty() -> Self {
2313            Self::default()
2314        }
2315
2316        unsafe fn decode(
2317            &mut self,
2318            decoder: &mut fidl::encoding::Decoder<'_, D>,
2319            offset: usize,
2320            mut depth: fidl::encoding::Depth,
2321        ) -> fidl::Result<()> {
2322            decoder.debug_check_bounds::<Self>(offset);
2323            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2324                None => return Err(fidl::Error::NotNullable),
2325                Some(len) => len,
2326            };
2327            // Calling decoder.out_of_line_offset(0) is not allowed.
2328            if len == 0 {
2329                return Ok(());
2330            };
2331            depth.increment()?;
2332            let envelope_size = 8;
2333            let bytes_len = len * envelope_size;
2334            let offset = decoder.out_of_line_offset(bytes_len)?;
2335            // Decode the envelope for each type.
2336            let mut _next_ordinal_to_read = 0;
2337            let mut next_offset = offset;
2338            let end_offset = offset + bytes_len;
2339            _next_ordinal_to_read += 1;
2340            if next_offset >= end_offset {
2341                return Ok(());
2342            }
2343
2344            // Decode unknown envelopes for gaps in ordinals.
2345            while _next_ordinal_to_read < 1 {
2346                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2347                _next_ordinal_to_read += 1;
2348                next_offset += envelope_size;
2349            }
2350
2351            let next_out_of_line = decoder.next_out_of_line();
2352            let handles_before = decoder.remaining_handles();
2353            if let Some((inlined, num_bytes, num_handles)) =
2354                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2355            {
2356                let member_inline_size =
2357                    <BusType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2358                if inlined != (member_inline_size <= 4) {
2359                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2360                }
2361                let inner_offset;
2362                let mut inner_depth = depth.clone();
2363                if inlined {
2364                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2365                    inner_offset = next_offset;
2366                } else {
2367                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2368                    inner_depth.increment()?;
2369                }
2370                let val_ref = self.bus.get_or_insert_with(|| fidl::new_empty!(BusType, D));
2371                fidl::decode!(BusType, D, val_ref, decoder, inner_offset, inner_depth)?;
2372                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2373                {
2374                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2375                }
2376                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2377                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2378                }
2379            }
2380
2381            next_offset += envelope_size;
2382            _next_ordinal_to_read += 1;
2383            if next_offset >= end_offset {
2384                return Ok(());
2385            }
2386
2387            // Decode unknown envelopes for gaps in ordinals.
2388            while _next_ordinal_to_read < 2 {
2389                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2390                _next_ordinal_to_read += 1;
2391                next_offset += envelope_size;
2392            }
2393
2394            let next_out_of_line = decoder.next_out_of_line();
2395            let handles_before = decoder.remaining_handles();
2396            if let Some((inlined, num_bytes, num_handles)) =
2397                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2398            {
2399                let member_inline_size =
2400                    <DeviceAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2401                if inlined != (member_inline_size <= 4) {
2402                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2403                }
2404                let inner_offset;
2405                let mut inner_depth = depth.clone();
2406                if inlined {
2407                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2408                    inner_offset = next_offset;
2409                } else {
2410                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2411                    inner_depth.increment()?;
2412                }
2413                let val_ref =
2414                    self.address.get_or_insert_with(|| fidl::new_empty!(DeviceAddress, D));
2415                fidl::decode!(DeviceAddress, D, val_ref, decoder, inner_offset, inner_depth)?;
2416                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2417                {
2418                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2419                }
2420                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2421                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2422                }
2423            }
2424
2425            next_offset += envelope_size;
2426            _next_ordinal_to_read += 1;
2427            if next_offset >= end_offset {
2428                return Ok(());
2429            }
2430
2431            // Decode unknown envelopes for gaps in ordinals.
2432            while _next_ordinal_to_read < 3 {
2433                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2434                _next_ordinal_to_read += 1;
2435                next_offset += envelope_size;
2436            }
2437
2438            let next_out_of_line = decoder.next_out_of_line();
2439            let handles_before = decoder.remaining_handles();
2440            if let Some((inlined, num_bytes, num_handles)) =
2441                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2442            {
2443                let member_inline_size =
2444                    <DeviceAddressStability as fidl::encoding::TypeMarker>::inline_size(
2445                        decoder.context,
2446                    );
2447                if inlined != (member_inline_size <= 4) {
2448                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2449                }
2450                let inner_offset;
2451                let mut inner_depth = depth.clone();
2452                if inlined {
2453                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2454                    inner_offset = next_offset;
2455                } else {
2456                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2457                    inner_depth.increment()?;
2458                }
2459                let val_ref = self
2460                    .address_stability
2461                    .get_or_insert_with(|| fidl::new_empty!(DeviceAddressStability, D));
2462                fidl::decode!(
2463                    DeviceAddressStability,
2464                    D,
2465                    val_ref,
2466                    decoder,
2467                    inner_offset,
2468                    inner_depth
2469                )?;
2470                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2471                {
2472                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2473                }
2474                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2475                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2476                }
2477            }
2478
2479            next_offset += envelope_size;
2480
2481            // Decode the remaining unknown envelopes.
2482            while next_offset < end_offset {
2483                _next_ordinal_to_read += 1;
2484                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2485                next_offset += envelope_size;
2486            }
2487
2488            Ok(())
2489        }
2490    }
2491
2492    impl CompositeDriverInfo {
2493        #[inline(always)]
2494        fn max_ordinal_present(&self) -> u64 {
2495            if let Some(_) = self.driver_info {
2496                return 2;
2497            }
2498            if let Some(_) = self.composite_name {
2499                return 1;
2500            }
2501            0
2502        }
2503    }
2504
2505    impl fidl::encoding::ValueTypeMarker for CompositeDriverInfo {
2506        type Borrowed<'a> = &'a Self;
2507        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2508            value
2509        }
2510    }
2511
2512    unsafe impl fidl::encoding::TypeMarker for CompositeDriverInfo {
2513        type Owned = Self;
2514
2515        #[inline(always)]
2516        fn inline_align(_context: fidl::encoding::Context) -> usize {
2517            8
2518        }
2519
2520        #[inline(always)]
2521        fn inline_size(_context: fidl::encoding::Context) -> usize {
2522            16
2523        }
2524    }
2525
2526    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeDriverInfo, D>
2527        for &CompositeDriverInfo
2528    {
2529        unsafe fn encode(
2530            self,
2531            encoder: &mut fidl::encoding::Encoder<'_, D>,
2532            offset: usize,
2533            mut depth: fidl::encoding::Depth,
2534        ) -> fidl::Result<()> {
2535            encoder.debug_check_bounds::<CompositeDriverInfo>(offset);
2536            // Vector header
2537            let max_ordinal: u64 = self.max_ordinal_present();
2538            encoder.write_num(max_ordinal, offset);
2539            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2540            // Calling encoder.out_of_line_offset(0) is not allowed.
2541            if max_ordinal == 0 {
2542                return Ok(());
2543            }
2544            depth.increment()?;
2545            let envelope_size = 8;
2546            let bytes_len = max_ordinal as usize * envelope_size;
2547            #[allow(unused_variables)]
2548            let offset = encoder.out_of_line_offset(bytes_len);
2549            let mut _prev_end_offset: usize = 0;
2550            if 1 > max_ordinal {
2551                return Ok(());
2552            }
2553
2554            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2555            // are envelope_size bytes.
2556            let cur_offset: usize = (1 - 1) * envelope_size;
2557
2558            // Zero reserved fields.
2559            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2560
2561            // Safety:
2562            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2563            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2564            //   envelope_size bytes, there is always sufficient room.
2565            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
2566                self.composite_name.as_ref().map(
2567                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
2568                ),
2569                encoder,
2570                offset + cur_offset,
2571                depth,
2572            )?;
2573
2574            _prev_end_offset = cur_offset + envelope_size;
2575            if 2 > max_ordinal {
2576                return Ok(());
2577            }
2578
2579            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2580            // are envelope_size bytes.
2581            let cur_offset: usize = (2 - 1) * envelope_size;
2582
2583            // Zero reserved fields.
2584            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2585
2586            // Safety:
2587            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2588            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2589            //   envelope_size bytes, there is always sufficient room.
2590            fidl::encoding::encode_in_envelope_optional::<DriverInfo, D>(
2591                self.driver_info
2592                    .as_ref()
2593                    .map(<DriverInfo as fidl::encoding::ValueTypeMarker>::borrow),
2594                encoder,
2595                offset + cur_offset,
2596                depth,
2597            )?;
2598
2599            _prev_end_offset = cur_offset + envelope_size;
2600
2601            Ok(())
2602        }
2603    }
2604
2605    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeDriverInfo {
2606        #[inline(always)]
2607        fn new_empty() -> Self {
2608            Self::default()
2609        }
2610
2611        unsafe fn decode(
2612            &mut self,
2613            decoder: &mut fidl::encoding::Decoder<'_, D>,
2614            offset: usize,
2615            mut depth: fidl::encoding::Depth,
2616        ) -> fidl::Result<()> {
2617            decoder.debug_check_bounds::<Self>(offset);
2618            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2619                None => return Err(fidl::Error::NotNullable),
2620                Some(len) => len,
2621            };
2622            // Calling decoder.out_of_line_offset(0) is not allowed.
2623            if len == 0 {
2624                return Ok(());
2625            };
2626            depth.increment()?;
2627            let envelope_size = 8;
2628            let bytes_len = len * envelope_size;
2629            let offset = decoder.out_of_line_offset(bytes_len)?;
2630            // Decode the envelope for each type.
2631            let mut _next_ordinal_to_read = 0;
2632            let mut next_offset = offset;
2633            let end_offset = offset + bytes_len;
2634            _next_ordinal_to_read += 1;
2635            if next_offset >= end_offset {
2636                return Ok(());
2637            }
2638
2639            // Decode unknown envelopes for gaps in ordinals.
2640            while _next_ordinal_to_read < 1 {
2641                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2642                _next_ordinal_to_read += 1;
2643                next_offset += envelope_size;
2644            }
2645
2646            let next_out_of_line = decoder.next_out_of_line();
2647            let handles_before = decoder.remaining_handles();
2648            if let Some((inlined, num_bytes, num_handles)) =
2649                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2650            {
2651                let member_inline_size =
2652                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
2653                        decoder.context,
2654                    );
2655                if inlined != (member_inline_size <= 4) {
2656                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2657                }
2658                let inner_offset;
2659                let mut inner_depth = depth.clone();
2660                if inlined {
2661                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2662                    inner_offset = next_offset;
2663                } else {
2664                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2665                    inner_depth.increment()?;
2666                }
2667                let val_ref = self
2668                    .composite_name
2669                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
2670                fidl::decode!(
2671                    fidl::encoding::UnboundedString,
2672                    D,
2673                    val_ref,
2674                    decoder,
2675                    inner_offset,
2676                    inner_depth
2677                )?;
2678                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2679                {
2680                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2681                }
2682                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2683                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2684                }
2685            }
2686
2687            next_offset += envelope_size;
2688            _next_ordinal_to_read += 1;
2689            if next_offset >= end_offset {
2690                return Ok(());
2691            }
2692
2693            // Decode unknown envelopes for gaps in ordinals.
2694            while _next_ordinal_to_read < 2 {
2695                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2696                _next_ordinal_to_read += 1;
2697                next_offset += envelope_size;
2698            }
2699
2700            let next_out_of_line = decoder.next_out_of_line();
2701            let handles_before = decoder.remaining_handles();
2702            if let Some((inlined, num_bytes, num_handles)) =
2703                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2704            {
2705                let member_inline_size =
2706                    <DriverInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2707                if inlined != (member_inline_size <= 4) {
2708                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2709                }
2710                let inner_offset;
2711                let mut inner_depth = depth.clone();
2712                if inlined {
2713                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2714                    inner_offset = next_offset;
2715                } else {
2716                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2717                    inner_depth.increment()?;
2718                }
2719                let val_ref =
2720                    self.driver_info.get_or_insert_with(|| fidl::new_empty!(DriverInfo, D));
2721                fidl::decode!(DriverInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2722                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2723                {
2724                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2725                }
2726                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2727                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2728                }
2729            }
2730
2731            next_offset += envelope_size;
2732
2733            // Decode the remaining unknown envelopes.
2734            while next_offset < end_offset {
2735                _next_ordinal_to_read += 1;
2736                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2737                next_offset += envelope_size;
2738            }
2739
2740            Ok(())
2741        }
2742    }
2743
2744    impl CompositeDriverMatch {
2745        #[inline(always)]
2746        fn max_ordinal_present(&self) -> u64 {
2747            if let Some(_) = self.primary_parent_index {
2748                return 3;
2749            }
2750            if let Some(_) = self.parent_names {
2751                return 2;
2752            }
2753            if let Some(_) = self.composite_driver {
2754                return 1;
2755            }
2756            0
2757        }
2758    }
2759
2760    impl fidl::encoding::ValueTypeMarker for CompositeDriverMatch {
2761        type Borrowed<'a> = &'a Self;
2762        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2763            value
2764        }
2765    }
2766
2767    unsafe impl fidl::encoding::TypeMarker for CompositeDriverMatch {
2768        type Owned = Self;
2769
2770        #[inline(always)]
2771        fn inline_align(_context: fidl::encoding::Context) -> usize {
2772            8
2773        }
2774
2775        #[inline(always)]
2776        fn inline_size(_context: fidl::encoding::Context) -> usize {
2777            16
2778        }
2779    }
2780
2781    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeDriverMatch, D>
2782        for &CompositeDriverMatch
2783    {
2784        unsafe fn encode(
2785            self,
2786            encoder: &mut fidl::encoding::Encoder<'_, D>,
2787            offset: usize,
2788            mut depth: fidl::encoding::Depth,
2789        ) -> fidl::Result<()> {
2790            encoder.debug_check_bounds::<CompositeDriverMatch>(offset);
2791            // Vector header
2792            let max_ordinal: u64 = self.max_ordinal_present();
2793            encoder.write_num(max_ordinal, offset);
2794            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2795            // Calling encoder.out_of_line_offset(0) is not allowed.
2796            if max_ordinal == 0 {
2797                return Ok(());
2798            }
2799            depth.increment()?;
2800            let envelope_size = 8;
2801            let bytes_len = max_ordinal as usize * envelope_size;
2802            #[allow(unused_variables)]
2803            let offset = encoder.out_of_line_offset(bytes_len);
2804            let mut _prev_end_offset: usize = 0;
2805            if 1 > max_ordinal {
2806                return Ok(());
2807            }
2808
2809            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2810            // are envelope_size bytes.
2811            let cur_offset: usize = (1 - 1) * envelope_size;
2812
2813            // Zero reserved fields.
2814            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2815
2816            // Safety:
2817            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2818            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2819            //   envelope_size bytes, there is always sufficient room.
2820            fidl::encoding::encode_in_envelope_optional::<CompositeDriverInfo, D>(
2821                self.composite_driver
2822                    .as_ref()
2823                    .map(<CompositeDriverInfo as fidl::encoding::ValueTypeMarker>::borrow),
2824                encoder,
2825                offset + cur_offset,
2826                depth,
2827            )?;
2828
2829            _prev_end_offset = cur_offset + envelope_size;
2830            if 2 > max_ordinal {
2831                return Ok(());
2832            }
2833
2834            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2835            // are envelope_size bytes.
2836            let cur_offset: usize = (2 - 1) * envelope_size;
2837
2838            // Zero reserved fields.
2839            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2840
2841            // Safety:
2842            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2843            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2844            //   envelope_size bytes, there is always sufficient room.
2845            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>, D>(
2846            self.parent_names.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow),
2847            encoder, offset + cur_offset, depth
2848        )?;
2849
2850            _prev_end_offset = cur_offset + envelope_size;
2851            if 3 > max_ordinal {
2852                return Ok(());
2853            }
2854
2855            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2856            // are envelope_size bytes.
2857            let cur_offset: usize = (3 - 1) * envelope_size;
2858
2859            // Zero reserved fields.
2860            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2861
2862            // Safety:
2863            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2864            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2865            //   envelope_size bytes, there is always sufficient room.
2866            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2867                self.primary_parent_index
2868                    .as_ref()
2869                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2870                encoder,
2871                offset + cur_offset,
2872                depth,
2873            )?;
2874
2875            _prev_end_offset = cur_offset + envelope_size;
2876
2877            Ok(())
2878        }
2879    }
2880
2881    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeDriverMatch {
2882        #[inline(always)]
2883        fn new_empty() -> Self {
2884            Self::default()
2885        }
2886
2887        unsafe fn decode(
2888            &mut self,
2889            decoder: &mut fidl::encoding::Decoder<'_, D>,
2890            offset: usize,
2891            mut depth: fidl::encoding::Depth,
2892        ) -> fidl::Result<()> {
2893            decoder.debug_check_bounds::<Self>(offset);
2894            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2895                None => return Err(fidl::Error::NotNullable),
2896                Some(len) => len,
2897            };
2898            // Calling decoder.out_of_line_offset(0) is not allowed.
2899            if len == 0 {
2900                return Ok(());
2901            };
2902            depth.increment()?;
2903            let envelope_size = 8;
2904            let bytes_len = len * envelope_size;
2905            let offset = decoder.out_of_line_offset(bytes_len)?;
2906            // Decode the envelope for each type.
2907            let mut _next_ordinal_to_read = 0;
2908            let mut next_offset = offset;
2909            let end_offset = offset + bytes_len;
2910            _next_ordinal_to_read += 1;
2911            if next_offset >= end_offset {
2912                return Ok(());
2913            }
2914
2915            // Decode unknown envelopes for gaps in ordinals.
2916            while _next_ordinal_to_read < 1 {
2917                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2918                _next_ordinal_to_read += 1;
2919                next_offset += envelope_size;
2920            }
2921
2922            let next_out_of_line = decoder.next_out_of_line();
2923            let handles_before = decoder.remaining_handles();
2924            if let Some((inlined, num_bytes, num_handles)) =
2925                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2926            {
2927                let member_inline_size =
2928                    <CompositeDriverInfo as fidl::encoding::TypeMarker>::inline_size(
2929                        decoder.context,
2930                    );
2931                if inlined != (member_inline_size <= 4) {
2932                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2933                }
2934                let inner_offset;
2935                let mut inner_depth = depth.clone();
2936                if inlined {
2937                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2938                    inner_offset = next_offset;
2939                } else {
2940                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2941                    inner_depth.increment()?;
2942                }
2943                let val_ref = self
2944                    .composite_driver
2945                    .get_or_insert_with(|| fidl::new_empty!(CompositeDriverInfo, D));
2946                fidl::decode!(CompositeDriverInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
2947                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2948                {
2949                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2950                }
2951                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2952                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2953                }
2954            }
2955
2956            next_offset += envelope_size;
2957            _next_ordinal_to_read += 1;
2958            if next_offset >= end_offset {
2959                return Ok(());
2960            }
2961
2962            // Decode unknown envelopes for gaps in ordinals.
2963            while _next_ordinal_to_read < 2 {
2964                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2965                _next_ordinal_to_read += 1;
2966                next_offset += envelope_size;
2967            }
2968
2969            let next_out_of_line = decoder.next_out_of_line();
2970            let handles_before = decoder.remaining_handles();
2971            if let Some((inlined, num_bytes, num_handles)) =
2972                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2973            {
2974                let member_inline_size = <fidl::encoding::UnboundedVector<
2975                    fidl::encoding::UnboundedString,
2976                > as fidl::encoding::TypeMarker>::inline_size(
2977                    decoder.context
2978                );
2979                if inlined != (member_inline_size <= 4) {
2980                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2981                }
2982                let inner_offset;
2983                let mut inner_depth = depth.clone();
2984                if inlined {
2985                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2986                    inner_offset = next_offset;
2987                } else {
2988                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2989                    inner_depth.increment()?;
2990                }
2991                let val_ref = self.parent_names.get_or_insert_with(|| {
2992                    fidl::new_empty!(
2993                        fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
2994                        D
2995                    )
2996                });
2997                fidl::decode!(
2998                    fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
2999                    D,
3000                    val_ref,
3001                    decoder,
3002                    inner_offset,
3003                    inner_depth
3004                )?;
3005                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3006                {
3007                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3008                }
3009                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3010                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3011                }
3012            }
3013
3014            next_offset += envelope_size;
3015            _next_ordinal_to_read += 1;
3016            if next_offset >= end_offset {
3017                return Ok(());
3018            }
3019
3020            // Decode unknown envelopes for gaps in ordinals.
3021            while _next_ordinal_to_read < 3 {
3022                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3023                _next_ordinal_to_read += 1;
3024                next_offset += envelope_size;
3025            }
3026
3027            let next_out_of_line = decoder.next_out_of_line();
3028            let handles_before = decoder.remaining_handles();
3029            if let Some((inlined, num_bytes, num_handles)) =
3030                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3031            {
3032                let member_inline_size =
3033                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3034                if inlined != (member_inline_size <= 4) {
3035                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3036                }
3037                let inner_offset;
3038                let mut inner_depth = depth.clone();
3039                if inlined {
3040                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3041                    inner_offset = next_offset;
3042                } else {
3043                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3044                    inner_depth.increment()?;
3045                }
3046                let val_ref =
3047                    self.primary_parent_index.get_or_insert_with(|| fidl::new_empty!(u32, D));
3048                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3049                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3050                {
3051                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3052                }
3053                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3054                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3055                }
3056            }
3057
3058            next_offset += envelope_size;
3059
3060            // Decode the remaining unknown envelopes.
3061            while next_offset < end_offset {
3062                _next_ordinal_to_read += 1;
3063                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3064                next_offset += envelope_size;
3065            }
3066
3067            Ok(())
3068        }
3069    }
3070
3071    impl CompositeInfo {
3072        #[inline(always)]
3073        fn max_ordinal_present(&self) -> u64 {
3074            if let Some(_) = self.matched_driver {
3075                return 2;
3076            }
3077            if let Some(_) = self.spec {
3078                return 1;
3079            }
3080            0
3081        }
3082    }
3083
3084    impl fidl::encoding::ValueTypeMarker for CompositeInfo {
3085        type Borrowed<'a> = &'a Self;
3086        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3087            value
3088        }
3089    }
3090
3091    unsafe impl fidl::encoding::TypeMarker for CompositeInfo {
3092        type Owned = Self;
3093
3094        #[inline(always)]
3095        fn inline_align(_context: fidl::encoding::Context) -> usize {
3096            8
3097        }
3098
3099        #[inline(always)]
3100        fn inline_size(_context: fidl::encoding::Context) -> usize {
3101            16
3102        }
3103    }
3104
3105    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeInfo, D>
3106        for &CompositeInfo
3107    {
3108        unsafe fn encode(
3109            self,
3110            encoder: &mut fidl::encoding::Encoder<'_, D>,
3111            offset: usize,
3112            mut depth: fidl::encoding::Depth,
3113        ) -> fidl::Result<()> {
3114            encoder.debug_check_bounds::<CompositeInfo>(offset);
3115            // Vector header
3116            let max_ordinal: u64 = self.max_ordinal_present();
3117            encoder.write_num(max_ordinal, offset);
3118            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3119            // Calling encoder.out_of_line_offset(0) is not allowed.
3120            if max_ordinal == 0 {
3121                return Ok(());
3122            }
3123            depth.increment()?;
3124            let envelope_size = 8;
3125            let bytes_len = max_ordinal as usize * envelope_size;
3126            #[allow(unused_variables)]
3127            let offset = encoder.out_of_line_offset(bytes_len);
3128            let mut _prev_end_offset: usize = 0;
3129            if 1 > max_ordinal {
3130                return Ok(());
3131            }
3132
3133            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3134            // are envelope_size bytes.
3135            let cur_offset: usize = (1 - 1) * envelope_size;
3136
3137            // Zero reserved fields.
3138            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3139
3140            // Safety:
3141            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3142            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3143            //   envelope_size bytes, there is always sufficient room.
3144            fidl::encoding::encode_in_envelope_optional::<CompositeNodeSpec, D>(
3145                self.spec
3146                    .as_ref()
3147                    .map(<CompositeNodeSpec as fidl::encoding::ValueTypeMarker>::borrow),
3148                encoder,
3149                offset + cur_offset,
3150                depth,
3151            )?;
3152
3153            _prev_end_offset = cur_offset + envelope_size;
3154            if 2 > max_ordinal {
3155                return Ok(());
3156            }
3157
3158            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3159            // are envelope_size bytes.
3160            let cur_offset: usize = (2 - 1) * envelope_size;
3161
3162            // Zero reserved fields.
3163            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3164
3165            // Safety:
3166            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3167            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3168            //   envelope_size bytes, there is always sufficient room.
3169            fidl::encoding::encode_in_envelope_optional::<CompositeDriverMatch, D>(
3170                self.matched_driver
3171                    .as_ref()
3172                    .map(<CompositeDriverMatch as fidl::encoding::ValueTypeMarker>::borrow),
3173                encoder,
3174                offset + cur_offset,
3175                depth,
3176            )?;
3177
3178            _prev_end_offset = cur_offset + envelope_size;
3179
3180            Ok(())
3181        }
3182    }
3183
3184    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeInfo {
3185        #[inline(always)]
3186        fn new_empty() -> Self {
3187            Self::default()
3188        }
3189
3190        unsafe fn decode(
3191            &mut self,
3192            decoder: &mut fidl::encoding::Decoder<'_, D>,
3193            offset: usize,
3194            mut depth: fidl::encoding::Depth,
3195        ) -> fidl::Result<()> {
3196            decoder.debug_check_bounds::<Self>(offset);
3197            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3198                None => return Err(fidl::Error::NotNullable),
3199                Some(len) => len,
3200            };
3201            // Calling decoder.out_of_line_offset(0) is not allowed.
3202            if len == 0 {
3203                return Ok(());
3204            };
3205            depth.increment()?;
3206            let envelope_size = 8;
3207            let bytes_len = len * envelope_size;
3208            let offset = decoder.out_of_line_offset(bytes_len)?;
3209            // Decode the envelope for each type.
3210            let mut _next_ordinal_to_read = 0;
3211            let mut next_offset = offset;
3212            let end_offset = offset + bytes_len;
3213            _next_ordinal_to_read += 1;
3214            if next_offset >= end_offset {
3215                return Ok(());
3216            }
3217
3218            // Decode unknown envelopes for gaps in ordinals.
3219            while _next_ordinal_to_read < 1 {
3220                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3221                _next_ordinal_to_read += 1;
3222                next_offset += envelope_size;
3223            }
3224
3225            let next_out_of_line = decoder.next_out_of_line();
3226            let handles_before = decoder.remaining_handles();
3227            if let Some((inlined, num_bytes, num_handles)) =
3228                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3229            {
3230                let member_inline_size =
3231                    <CompositeNodeSpec as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3232                if inlined != (member_inline_size <= 4) {
3233                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3234                }
3235                let inner_offset;
3236                let mut inner_depth = depth.clone();
3237                if inlined {
3238                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3239                    inner_offset = next_offset;
3240                } else {
3241                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3242                    inner_depth.increment()?;
3243                }
3244                let val_ref =
3245                    self.spec.get_or_insert_with(|| fidl::new_empty!(CompositeNodeSpec, D));
3246                fidl::decode!(CompositeNodeSpec, D, val_ref, decoder, inner_offset, inner_depth)?;
3247                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3248                {
3249                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3250                }
3251                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3252                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3253                }
3254            }
3255
3256            next_offset += envelope_size;
3257            _next_ordinal_to_read += 1;
3258            if next_offset >= end_offset {
3259                return Ok(());
3260            }
3261
3262            // Decode unknown envelopes for gaps in ordinals.
3263            while _next_ordinal_to_read < 2 {
3264                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3265                _next_ordinal_to_read += 1;
3266                next_offset += envelope_size;
3267            }
3268
3269            let next_out_of_line = decoder.next_out_of_line();
3270            let handles_before = decoder.remaining_handles();
3271            if let Some((inlined, num_bytes, num_handles)) =
3272                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3273            {
3274                let member_inline_size =
3275                    <CompositeDriverMatch as fidl::encoding::TypeMarker>::inline_size(
3276                        decoder.context,
3277                    );
3278                if inlined != (member_inline_size <= 4) {
3279                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3280                }
3281                let inner_offset;
3282                let mut inner_depth = depth.clone();
3283                if inlined {
3284                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3285                    inner_offset = next_offset;
3286                } else {
3287                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3288                    inner_depth.increment()?;
3289                }
3290                let val_ref = self
3291                    .matched_driver
3292                    .get_or_insert_with(|| fidl::new_empty!(CompositeDriverMatch, D));
3293                fidl::decode!(
3294                    CompositeDriverMatch,
3295                    D,
3296                    val_ref,
3297                    decoder,
3298                    inner_offset,
3299                    inner_depth
3300                )?;
3301                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3302                {
3303                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3304                }
3305                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3306                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3307                }
3308            }
3309
3310            next_offset += envelope_size;
3311
3312            // Decode the remaining unknown envelopes.
3313            while next_offset < end_offset {
3314                _next_ordinal_to_read += 1;
3315                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3316                next_offset += envelope_size;
3317            }
3318
3319            Ok(())
3320        }
3321    }
3322
3323    impl CompositeNodeSpec {
3324        #[inline(always)]
3325        fn max_ordinal_present(&self) -> u64 {
3326            if let Some(_) = self.parents2 {
3327                return 3;
3328            }
3329            if let Some(_) = self.parents {
3330                return 2;
3331            }
3332            if let Some(_) = self.name {
3333                return 1;
3334            }
3335            0
3336        }
3337    }
3338
3339    impl fidl::encoding::ValueTypeMarker for CompositeNodeSpec {
3340        type Borrowed<'a> = &'a Self;
3341        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3342            value
3343        }
3344    }
3345
3346    unsafe impl fidl::encoding::TypeMarker for CompositeNodeSpec {
3347        type Owned = Self;
3348
3349        #[inline(always)]
3350        fn inline_align(_context: fidl::encoding::Context) -> usize {
3351            8
3352        }
3353
3354        #[inline(always)]
3355        fn inline_size(_context: fidl::encoding::Context) -> usize {
3356            16
3357        }
3358    }
3359
3360    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeNodeSpec, D>
3361        for &CompositeNodeSpec
3362    {
3363        unsafe fn encode(
3364            self,
3365            encoder: &mut fidl::encoding::Encoder<'_, D>,
3366            offset: usize,
3367            mut depth: fidl::encoding::Depth,
3368        ) -> fidl::Result<()> {
3369            encoder.debug_check_bounds::<CompositeNodeSpec>(offset);
3370            // Vector header
3371            let max_ordinal: u64 = self.max_ordinal_present();
3372            encoder.write_num(max_ordinal, offset);
3373            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3374            // Calling encoder.out_of_line_offset(0) is not allowed.
3375            if max_ordinal == 0 {
3376                return Ok(());
3377            }
3378            depth.increment()?;
3379            let envelope_size = 8;
3380            let bytes_len = max_ordinal as usize * envelope_size;
3381            #[allow(unused_variables)]
3382            let offset = encoder.out_of_line_offset(bytes_len);
3383            let mut _prev_end_offset: usize = 0;
3384            if 1 > max_ordinal {
3385                return Ok(());
3386            }
3387
3388            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3389            // are envelope_size bytes.
3390            let cur_offset: usize = (1 - 1) * envelope_size;
3391
3392            // Zero reserved fields.
3393            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3394
3395            // Safety:
3396            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3397            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3398            //   envelope_size bytes, there is always sufficient room.
3399            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
3400                self.name.as_ref().map(
3401                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
3402                ),
3403                encoder,
3404                offset + cur_offset,
3405                depth,
3406            )?;
3407
3408            _prev_end_offset = cur_offset + envelope_size;
3409            if 2 > max_ordinal {
3410                return Ok(());
3411            }
3412
3413            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3414            // are envelope_size bytes.
3415            let cur_offset: usize = (2 - 1) * envelope_size;
3416
3417            // Zero reserved fields.
3418            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3419
3420            // Safety:
3421            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3422            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3423            //   envelope_size bytes, there is always sufficient room.
3424            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ParentSpec>, D>(
3425            self.parents.as_ref().map(<fidl::encoding::UnboundedVector<ParentSpec> as fidl::encoding::ValueTypeMarker>::borrow),
3426            encoder, offset + cur_offset, depth
3427        )?;
3428
3429            _prev_end_offset = cur_offset + envelope_size;
3430            if 3 > max_ordinal {
3431                return Ok(());
3432            }
3433
3434            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3435            // are envelope_size bytes.
3436            let cur_offset: usize = (3 - 1) * envelope_size;
3437
3438            // Zero reserved fields.
3439            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3440
3441            // Safety:
3442            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3443            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3444            //   envelope_size bytes, there is always sufficient room.
3445            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ParentSpec2>, D>(
3446            self.parents2.as_ref().map(<fidl::encoding::UnboundedVector<ParentSpec2> as fidl::encoding::ValueTypeMarker>::borrow),
3447            encoder, offset + cur_offset, depth
3448        )?;
3449
3450            _prev_end_offset = cur_offset + envelope_size;
3451
3452            Ok(())
3453        }
3454    }
3455
3456    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeNodeSpec {
3457        #[inline(always)]
3458        fn new_empty() -> Self {
3459            Self::default()
3460        }
3461
3462        unsafe fn decode(
3463            &mut self,
3464            decoder: &mut fidl::encoding::Decoder<'_, D>,
3465            offset: usize,
3466            mut depth: fidl::encoding::Depth,
3467        ) -> fidl::Result<()> {
3468            decoder.debug_check_bounds::<Self>(offset);
3469            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3470                None => return Err(fidl::Error::NotNullable),
3471                Some(len) => len,
3472            };
3473            // Calling decoder.out_of_line_offset(0) is not allowed.
3474            if len == 0 {
3475                return Ok(());
3476            };
3477            depth.increment()?;
3478            let envelope_size = 8;
3479            let bytes_len = len * envelope_size;
3480            let offset = decoder.out_of_line_offset(bytes_len)?;
3481            // Decode the envelope for each type.
3482            let mut _next_ordinal_to_read = 0;
3483            let mut next_offset = offset;
3484            let end_offset = offset + bytes_len;
3485            _next_ordinal_to_read += 1;
3486            if next_offset >= end_offset {
3487                return Ok(());
3488            }
3489
3490            // Decode unknown envelopes for gaps in ordinals.
3491            while _next_ordinal_to_read < 1 {
3492                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3493                _next_ordinal_to_read += 1;
3494                next_offset += envelope_size;
3495            }
3496
3497            let next_out_of_line = decoder.next_out_of_line();
3498            let handles_before = decoder.remaining_handles();
3499            if let Some((inlined, num_bytes, num_handles)) =
3500                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3501            {
3502                let member_inline_size =
3503                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
3504                        decoder.context,
3505                    );
3506                if inlined != (member_inline_size <= 4) {
3507                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3508                }
3509                let inner_offset;
3510                let mut inner_depth = depth.clone();
3511                if inlined {
3512                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3513                    inner_offset = next_offset;
3514                } else {
3515                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3516                    inner_depth.increment()?;
3517                }
3518                let val_ref = self
3519                    .name
3520                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
3521                fidl::decode!(
3522                    fidl::encoding::UnboundedString,
3523                    D,
3524                    val_ref,
3525                    decoder,
3526                    inner_offset,
3527                    inner_depth
3528                )?;
3529                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3530                {
3531                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3532                }
3533                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3534                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3535                }
3536            }
3537
3538            next_offset += envelope_size;
3539            _next_ordinal_to_read += 1;
3540            if next_offset >= end_offset {
3541                return Ok(());
3542            }
3543
3544            // Decode unknown envelopes for gaps in ordinals.
3545            while _next_ordinal_to_read < 2 {
3546                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3547                _next_ordinal_to_read += 1;
3548                next_offset += envelope_size;
3549            }
3550
3551            let next_out_of_line = decoder.next_out_of_line();
3552            let handles_before = decoder.remaining_handles();
3553            if let Some((inlined, num_bytes, num_handles)) =
3554                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3555            {
3556                let member_inline_size = <fidl::encoding::UnboundedVector<ParentSpec> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3557                if inlined != (member_inline_size <= 4) {
3558                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3559                }
3560                let inner_offset;
3561                let mut inner_depth = depth.clone();
3562                if inlined {
3563                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3564                    inner_offset = next_offset;
3565                } else {
3566                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3567                    inner_depth.increment()?;
3568                }
3569                let val_ref = self.parents.get_or_insert_with(|| {
3570                    fidl::new_empty!(fidl::encoding::UnboundedVector<ParentSpec>, D)
3571                });
3572                fidl::decode!(
3573                    fidl::encoding::UnboundedVector<ParentSpec>,
3574                    D,
3575                    val_ref,
3576                    decoder,
3577                    inner_offset,
3578                    inner_depth
3579                )?;
3580                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3581                {
3582                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3583                }
3584                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3585                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3586                }
3587            }
3588
3589            next_offset += envelope_size;
3590            _next_ordinal_to_read += 1;
3591            if next_offset >= end_offset {
3592                return Ok(());
3593            }
3594
3595            // Decode unknown envelopes for gaps in ordinals.
3596            while _next_ordinal_to_read < 3 {
3597                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3598                _next_ordinal_to_read += 1;
3599                next_offset += envelope_size;
3600            }
3601
3602            let next_out_of_line = decoder.next_out_of_line();
3603            let handles_before = decoder.remaining_handles();
3604            if let Some((inlined, num_bytes, num_handles)) =
3605                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3606            {
3607                let member_inline_size = <fidl::encoding::UnboundedVector<ParentSpec2> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3608                if inlined != (member_inline_size <= 4) {
3609                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3610                }
3611                let inner_offset;
3612                let mut inner_depth = depth.clone();
3613                if inlined {
3614                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3615                    inner_offset = next_offset;
3616                } else {
3617                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3618                    inner_depth.increment()?;
3619                }
3620                let val_ref = self.parents2.get_or_insert_with(|| {
3621                    fidl::new_empty!(fidl::encoding::UnboundedVector<ParentSpec2>, D)
3622                });
3623                fidl::decode!(
3624                    fidl::encoding::UnboundedVector<ParentSpec2>,
3625                    D,
3626                    val_ref,
3627                    decoder,
3628                    inner_offset,
3629                    inner_depth
3630                )?;
3631                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3632                {
3633                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3634                }
3635                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3636                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3637                }
3638            }
3639
3640            next_offset += envelope_size;
3641
3642            // Decode the remaining unknown envelopes.
3643            while next_offset < end_offset {
3644                _next_ordinal_to_read += 1;
3645                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3646                next_offset += envelope_size;
3647            }
3648
3649            Ok(())
3650        }
3651    }
3652
3653    impl CompositeParent {
3654        #[inline(always)]
3655        fn max_ordinal_present(&self) -> u64 {
3656            if let Some(_) = self.index {
3657                return 2;
3658            }
3659            if let Some(_) = self.composite {
3660                return 1;
3661            }
3662            0
3663        }
3664    }
3665
3666    impl fidl::encoding::ValueTypeMarker for CompositeParent {
3667        type Borrowed<'a> = &'a Self;
3668        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3669            value
3670        }
3671    }
3672
3673    unsafe impl fidl::encoding::TypeMarker for CompositeParent {
3674        type Owned = Self;
3675
3676        #[inline(always)]
3677        fn inline_align(_context: fidl::encoding::Context) -> usize {
3678            8
3679        }
3680
3681        #[inline(always)]
3682        fn inline_size(_context: fidl::encoding::Context) -> usize {
3683            16
3684        }
3685    }
3686
3687    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CompositeParent, D>
3688        for &CompositeParent
3689    {
3690        unsafe fn encode(
3691            self,
3692            encoder: &mut fidl::encoding::Encoder<'_, D>,
3693            offset: usize,
3694            mut depth: fidl::encoding::Depth,
3695        ) -> fidl::Result<()> {
3696            encoder.debug_check_bounds::<CompositeParent>(offset);
3697            // Vector header
3698            let max_ordinal: u64 = self.max_ordinal_present();
3699            encoder.write_num(max_ordinal, offset);
3700            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3701            // Calling encoder.out_of_line_offset(0) is not allowed.
3702            if max_ordinal == 0 {
3703                return Ok(());
3704            }
3705            depth.increment()?;
3706            let envelope_size = 8;
3707            let bytes_len = max_ordinal as usize * envelope_size;
3708            #[allow(unused_variables)]
3709            let offset = encoder.out_of_line_offset(bytes_len);
3710            let mut _prev_end_offset: usize = 0;
3711            if 1 > max_ordinal {
3712                return Ok(());
3713            }
3714
3715            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3716            // are envelope_size bytes.
3717            let cur_offset: usize = (1 - 1) * envelope_size;
3718
3719            // Zero reserved fields.
3720            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3721
3722            // Safety:
3723            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3724            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3725            //   envelope_size bytes, there is always sufficient room.
3726            fidl::encoding::encode_in_envelope_optional::<CompositeInfo, D>(
3727                self.composite
3728                    .as_ref()
3729                    .map(<CompositeInfo as fidl::encoding::ValueTypeMarker>::borrow),
3730                encoder,
3731                offset + cur_offset,
3732                depth,
3733            )?;
3734
3735            _prev_end_offset = cur_offset + envelope_size;
3736            if 2 > max_ordinal {
3737                return Ok(());
3738            }
3739
3740            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3741            // are envelope_size bytes.
3742            let cur_offset: usize = (2 - 1) * envelope_size;
3743
3744            // Zero reserved fields.
3745            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3746
3747            // Safety:
3748            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3749            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3750            //   envelope_size bytes, there is always sufficient room.
3751            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3752                self.index.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3753                encoder,
3754                offset + cur_offset,
3755                depth,
3756            )?;
3757
3758            _prev_end_offset = cur_offset + envelope_size;
3759
3760            Ok(())
3761        }
3762    }
3763
3764    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompositeParent {
3765        #[inline(always)]
3766        fn new_empty() -> Self {
3767            Self::default()
3768        }
3769
3770        unsafe fn decode(
3771            &mut self,
3772            decoder: &mut fidl::encoding::Decoder<'_, D>,
3773            offset: usize,
3774            mut depth: fidl::encoding::Depth,
3775        ) -> fidl::Result<()> {
3776            decoder.debug_check_bounds::<Self>(offset);
3777            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3778                None => return Err(fidl::Error::NotNullable),
3779                Some(len) => len,
3780            };
3781            // Calling decoder.out_of_line_offset(0) is not allowed.
3782            if len == 0 {
3783                return Ok(());
3784            };
3785            depth.increment()?;
3786            let envelope_size = 8;
3787            let bytes_len = len * envelope_size;
3788            let offset = decoder.out_of_line_offset(bytes_len)?;
3789            // Decode the envelope for each type.
3790            let mut _next_ordinal_to_read = 0;
3791            let mut next_offset = offset;
3792            let end_offset = offset + bytes_len;
3793            _next_ordinal_to_read += 1;
3794            if next_offset >= end_offset {
3795                return Ok(());
3796            }
3797
3798            // Decode unknown envelopes for gaps in ordinals.
3799            while _next_ordinal_to_read < 1 {
3800                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3801                _next_ordinal_to_read += 1;
3802                next_offset += envelope_size;
3803            }
3804
3805            let next_out_of_line = decoder.next_out_of_line();
3806            let handles_before = decoder.remaining_handles();
3807            if let Some((inlined, num_bytes, num_handles)) =
3808                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3809            {
3810                let member_inline_size =
3811                    <CompositeInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3812                if inlined != (member_inline_size <= 4) {
3813                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3814                }
3815                let inner_offset;
3816                let mut inner_depth = depth.clone();
3817                if inlined {
3818                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3819                    inner_offset = next_offset;
3820                } else {
3821                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3822                    inner_depth.increment()?;
3823                }
3824                let val_ref =
3825                    self.composite.get_or_insert_with(|| fidl::new_empty!(CompositeInfo, D));
3826                fidl::decode!(CompositeInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
3827                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3828                {
3829                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3830                }
3831                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3832                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3833                }
3834            }
3835
3836            next_offset += envelope_size;
3837            _next_ordinal_to_read += 1;
3838            if next_offset >= end_offset {
3839                return Ok(());
3840            }
3841
3842            // Decode unknown envelopes for gaps in ordinals.
3843            while _next_ordinal_to_read < 2 {
3844                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3845                _next_ordinal_to_read += 1;
3846                next_offset += envelope_size;
3847            }
3848
3849            let next_out_of_line = decoder.next_out_of_line();
3850            let handles_before = decoder.remaining_handles();
3851            if let Some((inlined, num_bytes, num_handles)) =
3852                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3853            {
3854                let member_inline_size =
3855                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3856                if inlined != (member_inline_size <= 4) {
3857                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3858                }
3859                let inner_offset;
3860                let mut inner_depth = depth.clone();
3861                if inlined {
3862                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3863                    inner_offset = next_offset;
3864                } else {
3865                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3866                    inner_depth.increment()?;
3867                }
3868                let val_ref = self.index.get_or_insert_with(|| fidl::new_empty!(u32, D));
3869                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3870                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3871                {
3872                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3873                }
3874                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3875                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3876                }
3877            }
3878
3879            next_offset += envelope_size;
3880
3881            // Decode the remaining unknown envelopes.
3882            while next_offset < end_offset {
3883                _next_ordinal_to_read += 1;
3884                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3885                next_offset += envelope_size;
3886            }
3887
3888            Ok(())
3889        }
3890    }
3891
3892    impl DeviceCategory {
3893        #[inline(always)]
3894        fn max_ordinal_present(&self) -> u64 {
3895            if let Some(_) = self.subcategory {
3896                return 2;
3897            }
3898            if let Some(_) = self.category {
3899                return 1;
3900            }
3901            0
3902        }
3903    }
3904
3905    impl fidl::encoding::ValueTypeMarker for DeviceCategory {
3906        type Borrowed<'a> = &'a Self;
3907        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3908            value
3909        }
3910    }
3911
3912    unsafe impl fidl::encoding::TypeMarker for DeviceCategory {
3913        type Owned = Self;
3914
3915        #[inline(always)]
3916        fn inline_align(_context: fidl::encoding::Context) -> usize {
3917            8
3918        }
3919
3920        #[inline(always)]
3921        fn inline_size(_context: fidl::encoding::Context) -> usize {
3922            16
3923        }
3924    }
3925
3926    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceCategory, D>
3927        for &DeviceCategory
3928    {
3929        unsafe fn encode(
3930            self,
3931            encoder: &mut fidl::encoding::Encoder<'_, D>,
3932            offset: usize,
3933            mut depth: fidl::encoding::Depth,
3934        ) -> fidl::Result<()> {
3935            encoder.debug_check_bounds::<DeviceCategory>(offset);
3936            // Vector header
3937            let max_ordinal: u64 = self.max_ordinal_present();
3938            encoder.write_num(max_ordinal, offset);
3939            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3940            // Calling encoder.out_of_line_offset(0) is not allowed.
3941            if max_ordinal == 0 {
3942                return Ok(());
3943            }
3944            depth.increment()?;
3945            let envelope_size = 8;
3946            let bytes_len = max_ordinal as usize * envelope_size;
3947            #[allow(unused_variables)]
3948            let offset = encoder.out_of_line_offset(bytes_len);
3949            let mut _prev_end_offset: usize = 0;
3950            if 1 > max_ordinal {
3951                return Ok(());
3952            }
3953
3954            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3955            // are envelope_size bytes.
3956            let cur_offset: usize = (1 - 1) * envelope_size;
3957
3958            // Zero reserved fields.
3959            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3960
3961            // Safety:
3962            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3963            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3964            //   envelope_size bytes, there is always sufficient room.
3965            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
3966                self.category.as_ref().map(
3967                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
3968                ),
3969                encoder,
3970                offset + cur_offset,
3971                depth,
3972            )?;
3973
3974            _prev_end_offset = cur_offset + envelope_size;
3975            if 2 > max_ordinal {
3976                return Ok(());
3977            }
3978
3979            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3980            // are envelope_size bytes.
3981            let cur_offset: usize = (2 - 1) * envelope_size;
3982
3983            // Zero reserved fields.
3984            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3985
3986            // Safety:
3987            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3988            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3989            //   envelope_size bytes, there is always sufficient room.
3990            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
3991                self.subcategory.as_ref().map(
3992                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
3993                ),
3994                encoder,
3995                offset + cur_offset,
3996                depth,
3997            )?;
3998
3999            _prev_end_offset = cur_offset + envelope_size;
4000
4001            Ok(())
4002        }
4003    }
4004
4005    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceCategory {
4006        #[inline(always)]
4007        fn new_empty() -> Self {
4008            Self::default()
4009        }
4010
4011        unsafe fn decode(
4012            &mut self,
4013            decoder: &mut fidl::encoding::Decoder<'_, D>,
4014            offset: usize,
4015            mut depth: fidl::encoding::Depth,
4016        ) -> fidl::Result<()> {
4017            decoder.debug_check_bounds::<Self>(offset);
4018            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4019                None => return Err(fidl::Error::NotNullable),
4020                Some(len) => len,
4021            };
4022            // Calling decoder.out_of_line_offset(0) is not allowed.
4023            if len == 0 {
4024                return Ok(());
4025            };
4026            depth.increment()?;
4027            let envelope_size = 8;
4028            let bytes_len = len * envelope_size;
4029            let offset = decoder.out_of_line_offset(bytes_len)?;
4030            // Decode the envelope for each type.
4031            let mut _next_ordinal_to_read = 0;
4032            let mut next_offset = offset;
4033            let end_offset = offset + bytes_len;
4034            _next_ordinal_to_read += 1;
4035            if next_offset >= end_offset {
4036                return Ok(());
4037            }
4038
4039            // Decode unknown envelopes for gaps in ordinals.
4040            while _next_ordinal_to_read < 1 {
4041                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4042                _next_ordinal_to_read += 1;
4043                next_offset += envelope_size;
4044            }
4045
4046            let next_out_of_line = decoder.next_out_of_line();
4047            let handles_before = decoder.remaining_handles();
4048            if let Some((inlined, num_bytes, num_handles)) =
4049                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4050            {
4051                let member_inline_size =
4052                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4053                        decoder.context,
4054                    );
4055                if inlined != (member_inline_size <= 4) {
4056                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4057                }
4058                let inner_offset;
4059                let mut inner_depth = depth.clone();
4060                if inlined {
4061                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4062                    inner_offset = next_offset;
4063                } else {
4064                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4065                    inner_depth.increment()?;
4066                }
4067                let val_ref = self
4068                    .category
4069                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4070                fidl::decode!(
4071                    fidl::encoding::UnboundedString,
4072                    D,
4073                    val_ref,
4074                    decoder,
4075                    inner_offset,
4076                    inner_depth
4077                )?;
4078                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4079                {
4080                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4081                }
4082                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4083                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4084                }
4085            }
4086
4087            next_offset += envelope_size;
4088            _next_ordinal_to_read += 1;
4089            if next_offset >= end_offset {
4090                return Ok(());
4091            }
4092
4093            // Decode unknown envelopes for gaps in ordinals.
4094            while _next_ordinal_to_read < 2 {
4095                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4096                _next_ordinal_to_read += 1;
4097                next_offset += envelope_size;
4098            }
4099
4100            let next_out_of_line = decoder.next_out_of_line();
4101            let handles_before = decoder.remaining_handles();
4102            if let Some((inlined, num_bytes, num_handles)) =
4103                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4104            {
4105                let member_inline_size =
4106                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4107                        decoder.context,
4108                    );
4109                if inlined != (member_inline_size <= 4) {
4110                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4111                }
4112                let inner_offset;
4113                let mut inner_depth = depth.clone();
4114                if inlined {
4115                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4116                    inner_offset = next_offset;
4117                } else {
4118                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4119                    inner_depth.increment()?;
4120                }
4121                let val_ref = self
4122                    .subcategory
4123                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4124                fidl::decode!(
4125                    fidl::encoding::UnboundedString,
4126                    D,
4127                    val_ref,
4128                    decoder,
4129                    inner_offset,
4130                    inner_depth
4131                )?;
4132                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4133                {
4134                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4135                }
4136                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4137                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4138                }
4139            }
4140
4141            next_offset += envelope_size;
4142
4143            // Decode the remaining unknown envelopes.
4144            while next_offset < end_offset {
4145                _next_ordinal_to_read += 1;
4146                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4147                next_offset += envelope_size;
4148            }
4149
4150            Ok(())
4151        }
4152    }
4153
4154    impl DriverInfo {
4155        #[inline(always)]
4156        fn max_ordinal_present(&self) -> u64 {
4157            if let Some(_) = self.is_disabled {
4158                return 9;
4159            }
4160            if let Some(_) = self.driver_framework_version {
4161                return 8;
4162            }
4163            if let Some(_) = self.bind_rules_bytecode {
4164                return 7;
4165            }
4166            if let Some(_) = self.device_categories {
4167                return 6;
4168            }
4169            if let Some(_) = self.is_fallback {
4170                return 5;
4171            }
4172            if let Some(_) = self.package_type {
4173                return 4;
4174            }
4175            if let Some(_) = self.colocate {
4176                return 3;
4177            }
4178            if let Some(_) = self.name {
4179                return 2;
4180            }
4181            if let Some(_) = self.url {
4182                return 1;
4183            }
4184            0
4185        }
4186    }
4187
4188    impl fidl::encoding::ValueTypeMarker for DriverInfo {
4189        type Borrowed<'a> = &'a Self;
4190        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4191            value
4192        }
4193    }
4194
4195    unsafe impl fidl::encoding::TypeMarker for DriverInfo {
4196        type Owned = Self;
4197
4198        #[inline(always)]
4199        fn inline_align(_context: fidl::encoding::Context) -> usize {
4200            8
4201        }
4202
4203        #[inline(always)]
4204        fn inline_size(_context: fidl::encoding::Context) -> usize {
4205            16
4206        }
4207    }
4208
4209    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DriverInfo, D>
4210        for &DriverInfo
4211    {
4212        unsafe fn encode(
4213            self,
4214            encoder: &mut fidl::encoding::Encoder<'_, D>,
4215            offset: usize,
4216            mut depth: fidl::encoding::Depth,
4217        ) -> fidl::Result<()> {
4218            encoder.debug_check_bounds::<DriverInfo>(offset);
4219            // Vector header
4220            let max_ordinal: u64 = self.max_ordinal_present();
4221            encoder.write_num(max_ordinal, offset);
4222            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4223            // Calling encoder.out_of_line_offset(0) is not allowed.
4224            if max_ordinal == 0 {
4225                return Ok(());
4226            }
4227            depth.increment()?;
4228            let envelope_size = 8;
4229            let bytes_len = max_ordinal as usize * envelope_size;
4230            #[allow(unused_variables)]
4231            let offset = encoder.out_of_line_offset(bytes_len);
4232            let mut _prev_end_offset: usize = 0;
4233            if 1 > max_ordinal {
4234                return Ok(());
4235            }
4236
4237            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4238            // are envelope_size bytes.
4239            let cur_offset: usize = (1 - 1) * envelope_size;
4240
4241            // Zero reserved fields.
4242            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4243
4244            // Safety:
4245            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4246            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4247            //   envelope_size bytes, there is always sufficient room.
4248            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
4249            self.url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
4250            encoder, offset + cur_offset, depth
4251        )?;
4252
4253            _prev_end_offset = cur_offset + envelope_size;
4254            if 2 > max_ordinal {
4255                return Ok(());
4256            }
4257
4258            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4259            // are envelope_size bytes.
4260            let cur_offset: usize = (2 - 1) * envelope_size;
4261
4262            // Zero reserved fields.
4263            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4264
4265            // Safety:
4266            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4267            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4268            //   envelope_size bytes, there is always sufficient room.
4269            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
4270                self.name.as_ref().map(
4271                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
4272                ),
4273                encoder,
4274                offset + cur_offset,
4275                depth,
4276            )?;
4277
4278            _prev_end_offset = cur_offset + envelope_size;
4279            if 3 > max_ordinal {
4280                return Ok(());
4281            }
4282
4283            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4284            // are envelope_size bytes.
4285            let cur_offset: usize = (3 - 1) * envelope_size;
4286
4287            // Zero reserved fields.
4288            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4289
4290            // Safety:
4291            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4292            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4293            //   envelope_size bytes, there is always sufficient room.
4294            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4295                self.colocate.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4296                encoder,
4297                offset + cur_offset,
4298                depth,
4299            )?;
4300
4301            _prev_end_offset = cur_offset + envelope_size;
4302            if 4 > max_ordinal {
4303                return Ok(());
4304            }
4305
4306            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4307            // are envelope_size bytes.
4308            let cur_offset: usize = (4 - 1) * envelope_size;
4309
4310            // Zero reserved fields.
4311            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4312
4313            // Safety:
4314            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4315            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4316            //   envelope_size bytes, there is always sufficient room.
4317            fidl::encoding::encode_in_envelope_optional::<DriverPackageType, D>(
4318                self.package_type
4319                    .as_ref()
4320                    .map(<DriverPackageType as fidl::encoding::ValueTypeMarker>::borrow),
4321                encoder,
4322                offset + cur_offset,
4323                depth,
4324            )?;
4325
4326            _prev_end_offset = cur_offset + envelope_size;
4327            if 5 > max_ordinal {
4328                return Ok(());
4329            }
4330
4331            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4332            // are envelope_size bytes.
4333            let cur_offset: usize = (5 - 1) * envelope_size;
4334
4335            // Zero reserved fields.
4336            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4337
4338            // Safety:
4339            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4340            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4341            //   envelope_size bytes, there is always sufficient room.
4342            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4343                self.is_fallback.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4344                encoder,
4345                offset + cur_offset,
4346                depth,
4347            )?;
4348
4349            _prev_end_offset = cur_offset + envelope_size;
4350            if 6 > max_ordinal {
4351                return Ok(());
4352            }
4353
4354            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4355            // are envelope_size bytes.
4356            let cur_offset: usize = (6 - 1) * envelope_size;
4357
4358            // Zero reserved fields.
4359            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4360
4361            // Safety:
4362            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4363            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4364            //   envelope_size bytes, there is always sufficient room.
4365            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<DeviceCategory>, D>(
4366            self.device_categories.as_ref().map(<fidl::encoding::UnboundedVector<DeviceCategory> as fidl::encoding::ValueTypeMarker>::borrow),
4367            encoder, offset + cur_offset, depth
4368        )?;
4369
4370            _prev_end_offset = cur_offset + envelope_size;
4371            if 7 > max_ordinal {
4372                return Ok(());
4373            }
4374
4375            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4376            // are envelope_size bytes.
4377            let cur_offset: usize = (7 - 1) * envelope_size;
4378
4379            // Zero reserved fields.
4380            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4381
4382            // Safety:
4383            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4384            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4385            //   envelope_size bytes, there is always sufficient room.
4386            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
4387            self.bind_rules_bytecode.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
4388            encoder, offset + cur_offset, depth
4389        )?;
4390
4391            _prev_end_offset = cur_offset + envelope_size;
4392            if 8 > max_ordinal {
4393                return Ok(());
4394            }
4395
4396            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4397            // are envelope_size bytes.
4398            let cur_offset: usize = (8 - 1) * envelope_size;
4399
4400            // Zero reserved fields.
4401            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4402
4403            // Safety:
4404            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4405            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4406            //   envelope_size bytes, there is always sufficient room.
4407            fidl::encoding::encode_in_envelope_optional::<u8, D>(
4408                self.driver_framework_version
4409                    .as_ref()
4410                    .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
4411                encoder,
4412                offset + cur_offset,
4413                depth,
4414            )?;
4415
4416            _prev_end_offset = cur_offset + envelope_size;
4417            if 9 > max_ordinal {
4418                return Ok(());
4419            }
4420
4421            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4422            // are envelope_size bytes.
4423            let cur_offset: usize = (9 - 1) * envelope_size;
4424
4425            // Zero reserved fields.
4426            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4427
4428            // Safety:
4429            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4430            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4431            //   envelope_size bytes, there is always sufficient room.
4432            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4433                self.is_disabled.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4434                encoder,
4435                offset + cur_offset,
4436                depth,
4437            )?;
4438
4439            _prev_end_offset = cur_offset + envelope_size;
4440
4441            Ok(())
4442        }
4443    }
4444
4445    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DriverInfo {
4446        #[inline(always)]
4447        fn new_empty() -> Self {
4448            Self::default()
4449        }
4450
4451        unsafe fn decode(
4452            &mut self,
4453            decoder: &mut fidl::encoding::Decoder<'_, D>,
4454            offset: usize,
4455            mut depth: fidl::encoding::Depth,
4456        ) -> fidl::Result<()> {
4457            decoder.debug_check_bounds::<Self>(offset);
4458            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4459                None => return Err(fidl::Error::NotNullable),
4460                Some(len) => len,
4461            };
4462            // Calling decoder.out_of_line_offset(0) is not allowed.
4463            if len == 0 {
4464                return Ok(());
4465            };
4466            depth.increment()?;
4467            let envelope_size = 8;
4468            let bytes_len = len * envelope_size;
4469            let offset = decoder.out_of_line_offset(bytes_len)?;
4470            // Decode the envelope for each type.
4471            let mut _next_ordinal_to_read = 0;
4472            let mut next_offset = offset;
4473            let end_offset = offset + bytes_len;
4474            _next_ordinal_to_read += 1;
4475            if next_offset >= end_offset {
4476                return Ok(());
4477            }
4478
4479            // Decode unknown envelopes for gaps in ordinals.
4480            while _next_ordinal_to_read < 1 {
4481                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4482                _next_ordinal_to_read += 1;
4483                next_offset += envelope_size;
4484            }
4485
4486            let next_out_of_line = decoder.next_out_of_line();
4487            let handles_before = decoder.remaining_handles();
4488            if let Some((inlined, num_bytes, num_handles)) =
4489                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4490            {
4491                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4492                if inlined != (member_inline_size <= 4) {
4493                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4494                }
4495                let inner_offset;
4496                let mut inner_depth = depth.clone();
4497                if inlined {
4498                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4499                    inner_offset = next_offset;
4500                } else {
4501                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4502                    inner_depth.increment()?;
4503                }
4504                let val_ref = self.url.get_or_insert_with(|| {
4505                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
4506                });
4507                fidl::decode!(
4508                    fidl::encoding::BoundedString<4096>,
4509                    D,
4510                    val_ref,
4511                    decoder,
4512                    inner_offset,
4513                    inner_depth
4514                )?;
4515                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4516                {
4517                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4518                }
4519                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4520                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4521                }
4522            }
4523
4524            next_offset += envelope_size;
4525            _next_ordinal_to_read += 1;
4526            if next_offset >= end_offset {
4527                return Ok(());
4528            }
4529
4530            // Decode unknown envelopes for gaps in ordinals.
4531            while _next_ordinal_to_read < 2 {
4532                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4533                _next_ordinal_to_read += 1;
4534                next_offset += envelope_size;
4535            }
4536
4537            let next_out_of_line = decoder.next_out_of_line();
4538            let handles_before = decoder.remaining_handles();
4539            if let Some((inlined, num_bytes, num_handles)) =
4540                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4541            {
4542                let member_inline_size =
4543                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4544                        decoder.context,
4545                    );
4546                if inlined != (member_inline_size <= 4) {
4547                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4548                }
4549                let inner_offset;
4550                let mut inner_depth = depth.clone();
4551                if inlined {
4552                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4553                    inner_offset = next_offset;
4554                } else {
4555                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4556                    inner_depth.increment()?;
4557                }
4558                let val_ref = self
4559                    .name
4560                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4561                fidl::decode!(
4562                    fidl::encoding::UnboundedString,
4563                    D,
4564                    val_ref,
4565                    decoder,
4566                    inner_offset,
4567                    inner_depth
4568                )?;
4569                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4570                {
4571                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4572                }
4573                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4574                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4575                }
4576            }
4577
4578            next_offset += envelope_size;
4579            _next_ordinal_to_read += 1;
4580            if next_offset >= end_offset {
4581                return Ok(());
4582            }
4583
4584            // Decode unknown envelopes for gaps in ordinals.
4585            while _next_ordinal_to_read < 3 {
4586                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4587                _next_ordinal_to_read += 1;
4588                next_offset += envelope_size;
4589            }
4590
4591            let next_out_of_line = decoder.next_out_of_line();
4592            let handles_before = decoder.remaining_handles();
4593            if let Some((inlined, num_bytes, num_handles)) =
4594                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4595            {
4596                let member_inline_size =
4597                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4598                if inlined != (member_inline_size <= 4) {
4599                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4600                }
4601                let inner_offset;
4602                let mut inner_depth = depth.clone();
4603                if inlined {
4604                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4605                    inner_offset = next_offset;
4606                } else {
4607                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4608                    inner_depth.increment()?;
4609                }
4610                let val_ref = self.colocate.get_or_insert_with(|| fidl::new_empty!(bool, D));
4611                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4612                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4613                {
4614                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4615                }
4616                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4617                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4618                }
4619            }
4620
4621            next_offset += envelope_size;
4622            _next_ordinal_to_read += 1;
4623            if next_offset >= end_offset {
4624                return Ok(());
4625            }
4626
4627            // Decode unknown envelopes for gaps in ordinals.
4628            while _next_ordinal_to_read < 4 {
4629                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4630                _next_ordinal_to_read += 1;
4631                next_offset += envelope_size;
4632            }
4633
4634            let next_out_of_line = decoder.next_out_of_line();
4635            let handles_before = decoder.remaining_handles();
4636            if let Some((inlined, num_bytes, num_handles)) =
4637                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4638            {
4639                let member_inline_size =
4640                    <DriverPackageType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4641                if inlined != (member_inline_size <= 4) {
4642                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4643                }
4644                let inner_offset;
4645                let mut inner_depth = depth.clone();
4646                if inlined {
4647                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4648                    inner_offset = next_offset;
4649                } else {
4650                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4651                    inner_depth.increment()?;
4652                }
4653                let val_ref =
4654                    self.package_type.get_or_insert_with(|| fidl::new_empty!(DriverPackageType, D));
4655                fidl::decode!(DriverPackageType, D, val_ref, decoder, inner_offset, inner_depth)?;
4656                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4657                {
4658                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4659                }
4660                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4661                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4662                }
4663            }
4664
4665            next_offset += envelope_size;
4666            _next_ordinal_to_read += 1;
4667            if next_offset >= end_offset {
4668                return Ok(());
4669            }
4670
4671            // Decode unknown envelopes for gaps in ordinals.
4672            while _next_ordinal_to_read < 5 {
4673                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4674                _next_ordinal_to_read += 1;
4675                next_offset += envelope_size;
4676            }
4677
4678            let next_out_of_line = decoder.next_out_of_line();
4679            let handles_before = decoder.remaining_handles();
4680            if let Some((inlined, num_bytes, num_handles)) =
4681                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4682            {
4683                let member_inline_size =
4684                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4685                if inlined != (member_inline_size <= 4) {
4686                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4687                }
4688                let inner_offset;
4689                let mut inner_depth = depth.clone();
4690                if inlined {
4691                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4692                    inner_offset = next_offset;
4693                } else {
4694                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4695                    inner_depth.increment()?;
4696                }
4697                let val_ref = self.is_fallback.get_or_insert_with(|| fidl::new_empty!(bool, D));
4698                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4699                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4700                {
4701                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4702                }
4703                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4704                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4705                }
4706            }
4707
4708            next_offset += envelope_size;
4709            _next_ordinal_to_read += 1;
4710            if next_offset >= end_offset {
4711                return Ok(());
4712            }
4713
4714            // Decode unknown envelopes for gaps in ordinals.
4715            while _next_ordinal_to_read < 6 {
4716                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4717                _next_ordinal_to_read += 1;
4718                next_offset += envelope_size;
4719            }
4720
4721            let next_out_of_line = decoder.next_out_of_line();
4722            let handles_before = decoder.remaining_handles();
4723            if let Some((inlined, num_bytes, num_handles)) =
4724                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4725            {
4726                let member_inline_size = <fidl::encoding::UnboundedVector<DeviceCategory> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4727                if inlined != (member_inline_size <= 4) {
4728                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4729                }
4730                let inner_offset;
4731                let mut inner_depth = depth.clone();
4732                if inlined {
4733                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4734                    inner_offset = next_offset;
4735                } else {
4736                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4737                    inner_depth.increment()?;
4738                }
4739                let val_ref = self.device_categories.get_or_insert_with(|| {
4740                    fidl::new_empty!(fidl::encoding::UnboundedVector<DeviceCategory>, D)
4741                });
4742                fidl::decode!(
4743                    fidl::encoding::UnboundedVector<DeviceCategory>,
4744                    D,
4745                    val_ref,
4746                    decoder,
4747                    inner_offset,
4748                    inner_depth
4749                )?;
4750                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4751                {
4752                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4753                }
4754                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4755                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4756                }
4757            }
4758
4759            next_offset += envelope_size;
4760            _next_ordinal_to_read += 1;
4761            if next_offset >= end_offset {
4762                return Ok(());
4763            }
4764
4765            // Decode unknown envelopes for gaps in ordinals.
4766            while _next_ordinal_to_read < 7 {
4767                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4768                _next_ordinal_to_read += 1;
4769                next_offset += envelope_size;
4770            }
4771
4772            let next_out_of_line = decoder.next_out_of_line();
4773            let handles_before = decoder.remaining_handles();
4774            if let Some((inlined, num_bytes, num_handles)) =
4775                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4776            {
4777                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4778                if inlined != (member_inline_size <= 4) {
4779                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4780                }
4781                let inner_offset;
4782                let mut inner_depth = depth.clone();
4783                if inlined {
4784                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4785                    inner_offset = next_offset;
4786                } else {
4787                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4788                    inner_depth.increment()?;
4789                }
4790                let val_ref = self.bind_rules_bytecode.get_or_insert_with(|| {
4791                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
4792                });
4793                fidl::decode!(
4794                    fidl::encoding::UnboundedVector<u8>,
4795                    D,
4796                    val_ref,
4797                    decoder,
4798                    inner_offset,
4799                    inner_depth
4800                )?;
4801                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4802                {
4803                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4804                }
4805                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4806                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4807                }
4808            }
4809
4810            next_offset += envelope_size;
4811            _next_ordinal_to_read += 1;
4812            if next_offset >= end_offset {
4813                return Ok(());
4814            }
4815
4816            // Decode unknown envelopes for gaps in ordinals.
4817            while _next_ordinal_to_read < 8 {
4818                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4819                _next_ordinal_to_read += 1;
4820                next_offset += envelope_size;
4821            }
4822
4823            let next_out_of_line = decoder.next_out_of_line();
4824            let handles_before = decoder.remaining_handles();
4825            if let Some((inlined, num_bytes, num_handles)) =
4826                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4827            {
4828                let member_inline_size =
4829                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4830                if inlined != (member_inline_size <= 4) {
4831                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4832                }
4833                let inner_offset;
4834                let mut inner_depth = depth.clone();
4835                if inlined {
4836                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4837                    inner_offset = next_offset;
4838                } else {
4839                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4840                    inner_depth.increment()?;
4841                }
4842                let val_ref =
4843                    self.driver_framework_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
4844                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
4845                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4846                {
4847                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4848                }
4849                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4850                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4851                }
4852            }
4853
4854            next_offset += envelope_size;
4855            _next_ordinal_to_read += 1;
4856            if next_offset >= end_offset {
4857                return Ok(());
4858            }
4859
4860            // Decode unknown envelopes for gaps in ordinals.
4861            while _next_ordinal_to_read < 9 {
4862                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4863                _next_ordinal_to_read += 1;
4864                next_offset += envelope_size;
4865            }
4866
4867            let next_out_of_line = decoder.next_out_of_line();
4868            let handles_before = decoder.remaining_handles();
4869            if let Some((inlined, num_bytes, num_handles)) =
4870                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4871            {
4872                let member_inline_size =
4873                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4874                if inlined != (member_inline_size <= 4) {
4875                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4876                }
4877                let inner_offset;
4878                let mut inner_depth = depth.clone();
4879                if inlined {
4880                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4881                    inner_offset = next_offset;
4882                } else {
4883                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4884                    inner_depth.increment()?;
4885                }
4886                let val_ref = self.is_disabled.get_or_insert_with(|| fidl::new_empty!(bool, D));
4887                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4888                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4889                {
4890                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4891                }
4892                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4893                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4894                }
4895            }
4896
4897            next_offset += envelope_size;
4898
4899            // Decode the remaining unknown envelopes.
4900            while next_offset < end_offset {
4901                _next_ordinal_to_read += 1;
4902                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4903                next_offset += envelope_size;
4904            }
4905
4906            Ok(())
4907        }
4908    }
4909
4910    impl NodeControllerRequestBindRequest {
4911        #[inline(always)]
4912        fn max_ordinal_present(&self) -> u64 {
4913            if let Some(_) = self.driver_url_suffix {
4914                return 2;
4915            }
4916            if let Some(_) = self.force_rebind {
4917                return 1;
4918            }
4919            0
4920        }
4921    }
4922
4923    impl fidl::encoding::ValueTypeMarker for NodeControllerRequestBindRequest {
4924        type Borrowed<'a> = &'a Self;
4925        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4926            value
4927        }
4928    }
4929
4930    unsafe impl fidl::encoding::TypeMarker for NodeControllerRequestBindRequest {
4931        type Owned = Self;
4932
4933        #[inline(always)]
4934        fn inline_align(_context: fidl::encoding::Context) -> usize {
4935            8
4936        }
4937
4938        #[inline(always)]
4939        fn inline_size(_context: fidl::encoding::Context) -> usize {
4940            16
4941        }
4942    }
4943
4944    unsafe impl<D: fidl::encoding::ResourceDialect>
4945        fidl::encoding::Encode<NodeControllerRequestBindRequest, D>
4946        for &NodeControllerRequestBindRequest
4947    {
4948        unsafe fn encode(
4949            self,
4950            encoder: &mut fidl::encoding::Encoder<'_, D>,
4951            offset: usize,
4952            mut depth: fidl::encoding::Depth,
4953        ) -> fidl::Result<()> {
4954            encoder.debug_check_bounds::<NodeControllerRequestBindRequest>(offset);
4955            // Vector header
4956            let max_ordinal: u64 = self.max_ordinal_present();
4957            encoder.write_num(max_ordinal, offset);
4958            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4959            // Calling encoder.out_of_line_offset(0) is not allowed.
4960            if max_ordinal == 0 {
4961                return Ok(());
4962            }
4963            depth.increment()?;
4964            let envelope_size = 8;
4965            let bytes_len = max_ordinal as usize * envelope_size;
4966            #[allow(unused_variables)]
4967            let offset = encoder.out_of_line_offset(bytes_len);
4968            let mut _prev_end_offset: usize = 0;
4969            if 1 > max_ordinal {
4970                return Ok(());
4971            }
4972
4973            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4974            // are envelope_size bytes.
4975            let cur_offset: usize = (1 - 1) * envelope_size;
4976
4977            // Zero reserved fields.
4978            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4979
4980            // Safety:
4981            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4982            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4983            //   envelope_size bytes, there is always sufficient room.
4984            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4985                self.force_rebind.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4986                encoder,
4987                offset + cur_offset,
4988                depth,
4989            )?;
4990
4991            _prev_end_offset = cur_offset + envelope_size;
4992            if 2 > max_ordinal {
4993                return Ok(());
4994            }
4995
4996            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4997            // are envelope_size bytes.
4998            let cur_offset: usize = (2 - 1) * envelope_size;
4999
5000            // Zero reserved fields.
5001            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5002
5003            // Safety:
5004            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5005            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5006            //   envelope_size bytes, there is always sufficient room.
5007            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
5008                self.driver_url_suffix.as_ref().map(
5009                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
5010                ),
5011                encoder,
5012                offset + cur_offset,
5013                depth,
5014            )?;
5015
5016            _prev_end_offset = cur_offset + envelope_size;
5017
5018            Ok(())
5019        }
5020    }
5021
5022    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5023        for NodeControllerRequestBindRequest
5024    {
5025        #[inline(always)]
5026        fn new_empty() -> Self {
5027            Self::default()
5028        }
5029
5030        unsafe fn decode(
5031            &mut self,
5032            decoder: &mut fidl::encoding::Decoder<'_, D>,
5033            offset: usize,
5034            mut depth: fidl::encoding::Depth,
5035        ) -> fidl::Result<()> {
5036            decoder.debug_check_bounds::<Self>(offset);
5037            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5038                None => return Err(fidl::Error::NotNullable),
5039                Some(len) => len,
5040            };
5041            // Calling decoder.out_of_line_offset(0) is not allowed.
5042            if len == 0 {
5043                return Ok(());
5044            };
5045            depth.increment()?;
5046            let envelope_size = 8;
5047            let bytes_len = len * envelope_size;
5048            let offset = decoder.out_of_line_offset(bytes_len)?;
5049            // Decode the envelope for each type.
5050            let mut _next_ordinal_to_read = 0;
5051            let mut next_offset = offset;
5052            let end_offset = offset + bytes_len;
5053            _next_ordinal_to_read += 1;
5054            if next_offset >= end_offset {
5055                return Ok(());
5056            }
5057
5058            // Decode unknown envelopes for gaps in ordinals.
5059            while _next_ordinal_to_read < 1 {
5060                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5061                _next_ordinal_to_read += 1;
5062                next_offset += envelope_size;
5063            }
5064
5065            let next_out_of_line = decoder.next_out_of_line();
5066            let handles_before = decoder.remaining_handles();
5067            if let Some((inlined, num_bytes, num_handles)) =
5068                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5069            {
5070                let member_inline_size =
5071                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5072                if inlined != (member_inline_size <= 4) {
5073                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5074                }
5075                let inner_offset;
5076                let mut inner_depth = depth.clone();
5077                if inlined {
5078                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5079                    inner_offset = next_offset;
5080                } else {
5081                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5082                    inner_depth.increment()?;
5083                }
5084                let val_ref = self.force_rebind.get_or_insert_with(|| fidl::new_empty!(bool, D));
5085                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5086                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5087                {
5088                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5089                }
5090                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5091                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5092                }
5093            }
5094
5095            next_offset += envelope_size;
5096            _next_ordinal_to_read += 1;
5097            if next_offset >= end_offset {
5098                return Ok(());
5099            }
5100
5101            // Decode unknown envelopes for gaps in ordinals.
5102            while _next_ordinal_to_read < 2 {
5103                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5104                _next_ordinal_to_read += 1;
5105                next_offset += envelope_size;
5106            }
5107
5108            let next_out_of_line = decoder.next_out_of_line();
5109            let handles_before = decoder.remaining_handles();
5110            if let Some((inlined, num_bytes, num_handles)) =
5111                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5112            {
5113                let member_inline_size =
5114                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
5115                        decoder.context,
5116                    );
5117                if inlined != (member_inline_size <= 4) {
5118                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5119                }
5120                let inner_offset;
5121                let mut inner_depth = depth.clone();
5122                if inlined {
5123                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5124                    inner_offset = next_offset;
5125                } else {
5126                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5127                    inner_depth.increment()?;
5128                }
5129                let val_ref = self
5130                    .driver_url_suffix
5131                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
5132                fidl::decode!(
5133                    fidl::encoding::UnboundedString,
5134                    D,
5135                    val_ref,
5136                    decoder,
5137                    inner_offset,
5138                    inner_depth
5139                )?;
5140                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5141                {
5142                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5143                }
5144                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5145                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5146                }
5147            }
5148
5149            next_offset += envelope_size;
5150
5151            // Decode the remaining unknown envelopes.
5152            while next_offset < end_offset {
5153                _next_ordinal_to_read += 1;
5154                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5155                next_offset += envelope_size;
5156            }
5157
5158            Ok(())
5159        }
5160    }
5161
5162    impl NodeSymbol {
5163        #[inline(always)]
5164        fn max_ordinal_present(&self) -> u64 {
5165            if let Some(_) = self.module_name {
5166                return 3;
5167            }
5168            if let Some(_) = self.address {
5169                return 2;
5170            }
5171            if let Some(_) = self.name {
5172                return 1;
5173            }
5174            0
5175        }
5176    }
5177
5178    impl fidl::encoding::ValueTypeMarker for NodeSymbol {
5179        type Borrowed<'a> = &'a Self;
5180        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5181            value
5182        }
5183    }
5184
5185    unsafe impl fidl::encoding::TypeMarker for NodeSymbol {
5186        type Owned = Self;
5187
5188        #[inline(always)]
5189        fn inline_align(_context: fidl::encoding::Context) -> usize {
5190            8
5191        }
5192
5193        #[inline(always)]
5194        fn inline_size(_context: fidl::encoding::Context) -> usize {
5195            16
5196        }
5197    }
5198
5199    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodeSymbol, D>
5200        for &NodeSymbol
5201    {
5202        unsafe fn encode(
5203            self,
5204            encoder: &mut fidl::encoding::Encoder<'_, D>,
5205            offset: usize,
5206            mut depth: fidl::encoding::Depth,
5207        ) -> fidl::Result<()> {
5208            encoder.debug_check_bounds::<NodeSymbol>(offset);
5209            // Vector header
5210            let max_ordinal: u64 = self.max_ordinal_present();
5211            encoder.write_num(max_ordinal, offset);
5212            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5213            // Calling encoder.out_of_line_offset(0) is not allowed.
5214            if max_ordinal == 0 {
5215                return Ok(());
5216            }
5217            depth.increment()?;
5218            let envelope_size = 8;
5219            let bytes_len = max_ordinal as usize * envelope_size;
5220            #[allow(unused_variables)]
5221            let offset = encoder.out_of_line_offset(bytes_len);
5222            let mut _prev_end_offset: usize = 0;
5223            if 1 > max_ordinal {
5224                return Ok(());
5225            }
5226
5227            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5228            // are envelope_size bytes.
5229            let cur_offset: usize = (1 - 1) * envelope_size;
5230
5231            // Zero reserved fields.
5232            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5233
5234            // Safety:
5235            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5236            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5237            //   envelope_size bytes, there is always sufficient room.
5238            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<128>, D>(
5239                self.name.as_ref().map(
5240                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
5241                ),
5242                encoder,
5243                offset + cur_offset,
5244                depth,
5245            )?;
5246
5247            _prev_end_offset = cur_offset + envelope_size;
5248            if 2 > max_ordinal {
5249                return Ok(());
5250            }
5251
5252            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5253            // are envelope_size bytes.
5254            let cur_offset: usize = (2 - 1) * envelope_size;
5255
5256            // Zero reserved fields.
5257            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5258
5259            // Safety:
5260            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5261            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5262            //   envelope_size bytes, there is always sufficient room.
5263            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5264                self.address.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5265                encoder,
5266                offset + cur_offset,
5267                depth,
5268            )?;
5269
5270            _prev_end_offset = cur_offset + envelope_size;
5271            if 3 > max_ordinal {
5272                return Ok(());
5273            }
5274
5275            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5276            // are envelope_size bytes.
5277            let cur_offset: usize = (3 - 1) * envelope_size;
5278
5279            // Zero reserved fields.
5280            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5281
5282            // Safety:
5283            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5284            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5285            //   envelope_size bytes, there is always sufficient room.
5286            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<128>, D>(
5287                self.module_name.as_ref().map(
5288                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
5289                ),
5290                encoder,
5291                offset + cur_offset,
5292                depth,
5293            )?;
5294
5295            _prev_end_offset = cur_offset + envelope_size;
5296
5297            Ok(())
5298        }
5299    }
5300
5301    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeSymbol {
5302        #[inline(always)]
5303        fn new_empty() -> Self {
5304            Self::default()
5305        }
5306
5307        unsafe fn decode(
5308            &mut self,
5309            decoder: &mut fidl::encoding::Decoder<'_, D>,
5310            offset: usize,
5311            mut depth: fidl::encoding::Depth,
5312        ) -> fidl::Result<()> {
5313            decoder.debug_check_bounds::<Self>(offset);
5314            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5315                None => return Err(fidl::Error::NotNullable),
5316                Some(len) => len,
5317            };
5318            // Calling decoder.out_of_line_offset(0) is not allowed.
5319            if len == 0 {
5320                return Ok(());
5321            };
5322            depth.increment()?;
5323            let envelope_size = 8;
5324            let bytes_len = len * envelope_size;
5325            let offset = decoder.out_of_line_offset(bytes_len)?;
5326            // Decode the envelope for each type.
5327            let mut _next_ordinal_to_read = 0;
5328            let mut next_offset = offset;
5329            let end_offset = offset + bytes_len;
5330            _next_ordinal_to_read += 1;
5331            if next_offset >= end_offset {
5332                return Ok(());
5333            }
5334
5335            // Decode unknown envelopes for gaps in ordinals.
5336            while _next_ordinal_to_read < 1 {
5337                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5338                _next_ordinal_to_read += 1;
5339                next_offset += envelope_size;
5340            }
5341
5342            let next_out_of_line = decoder.next_out_of_line();
5343            let handles_before = decoder.remaining_handles();
5344            if let Some((inlined, num_bytes, num_handles)) =
5345                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5346            {
5347                let member_inline_size =
5348                    <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
5349                        decoder.context,
5350                    );
5351                if inlined != (member_inline_size <= 4) {
5352                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5353                }
5354                let inner_offset;
5355                let mut inner_depth = depth.clone();
5356                if inlined {
5357                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5358                    inner_offset = next_offset;
5359                } else {
5360                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5361                    inner_depth.increment()?;
5362                }
5363                let val_ref = self
5364                    .name
5365                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
5366                fidl::decode!(
5367                    fidl::encoding::BoundedString<128>,
5368                    D,
5369                    val_ref,
5370                    decoder,
5371                    inner_offset,
5372                    inner_depth
5373                )?;
5374                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5375                {
5376                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5377                }
5378                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5379                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5380                }
5381            }
5382
5383            next_offset += envelope_size;
5384            _next_ordinal_to_read += 1;
5385            if next_offset >= end_offset {
5386                return Ok(());
5387            }
5388
5389            // Decode unknown envelopes for gaps in ordinals.
5390            while _next_ordinal_to_read < 2 {
5391                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5392                _next_ordinal_to_read += 1;
5393                next_offset += envelope_size;
5394            }
5395
5396            let next_out_of_line = decoder.next_out_of_line();
5397            let handles_before = decoder.remaining_handles();
5398            if let Some((inlined, num_bytes, num_handles)) =
5399                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5400            {
5401                let member_inline_size =
5402                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5403                if inlined != (member_inline_size <= 4) {
5404                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5405                }
5406                let inner_offset;
5407                let mut inner_depth = depth.clone();
5408                if inlined {
5409                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5410                    inner_offset = next_offset;
5411                } else {
5412                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5413                    inner_depth.increment()?;
5414                }
5415                let val_ref = self.address.get_or_insert_with(|| fidl::new_empty!(u64, D));
5416                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5417                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5418                {
5419                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5420                }
5421                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5422                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5423                }
5424            }
5425
5426            next_offset += envelope_size;
5427            _next_ordinal_to_read += 1;
5428            if next_offset >= end_offset {
5429                return Ok(());
5430            }
5431
5432            // Decode unknown envelopes for gaps in ordinals.
5433            while _next_ordinal_to_read < 3 {
5434                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5435                _next_ordinal_to_read += 1;
5436                next_offset += envelope_size;
5437            }
5438
5439            let next_out_of_line = decoder.next_out_of_line();
5440            let handles_before = decoder.remaining_handles();
5441            if let Some((inlined, num_bytes, num_handles)) =
5442                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5443            {
5444                let member_inline_size =
5445                    <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
5446                        decoder.context,
5447                    );
5448                if inlined != (member_inline_size <= 4) {
5449                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5450                }
5451                let inner_offset;
5452                let mut inner_depth = depth.clone();
5453                if inlined {
5454                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5455                    inner_offset = next_offset;
5456                } else {
5457                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5458                    inner_depth.increment()?;
5459                }
5460                let val_ref = self
5461                    .module_name
5462                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
5463                fidl::decode!(
5464                    fidl::encoding::BoundedString<128>,
5465                    D,
5466                    val_ref,
5467                    decoder,
5468                    inner_offset,
5469                    inner_depth
5470                )?;
5471                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5472                {
5473                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5474                }
5475                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5476                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5477                }
5478            }
5479
5480            next_offset += envelope_size;
5481
5482            // Decode the remaining unknown envelopes.
5483            while next_offset < end_offset {
5484                _next_ordinal_to_read += 1;
5485                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5486                next_offset += envelope_size;
5487            }
5488
5489            Ok(())
5490        }
5491    }
5492
5493    impl fidl::encoding::ValueTypeMarker for DeviceAddress {
5494        type Borrowed<'a> = &'a Self;
5495        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5496            value
5497        }
5498    }
5499
5500    unsafe impl fidl::encoding::TypeMarker for DeviceAddress {
5501        type Owned = Self;
5502
5503        #[inline(always)]
5504        fn inline_align(_context: fidl::encoding::Context) -> usize {
5505            8
5506        }
5507
5508        #[inline(always)]
5509        fn inline_size(_context: fidl::encoding::Context) -> usize {
5510            16
5511        }
5512    }
5513
5514    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceAddress, D>
5515        for &DeviceAddress
5516    {
5517        #[inline]
5518        unsafe fn encode(
5519            self,
5520            encoder: &mut fidl::encoding::Encoder<'_, D>,
5521            offset: usize,
5522            _depth: fidl::encoding::Depth,
5523        ) -> fidl::Result<()> {
5524            encoder.debug_check_bounds::<DeviceAddress>(offset);
5525            encoder.write_num::<u64>(self.ordinal(), offset);
5526            match self {
5527            DeviceAddress::IntValue(ref val) => {
5528                fidl::encoding::encode_in_envelope::<u8, D>(
5529                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
5530                    encoder, offset + 8, _depth
5531                )
5532            }
5533            DeviceAddress::ArrayIntValue(ref val) => {
5534                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u8, 10>, D>(
5535                    <fidl::encoding::Vector<u8, 10> as fidl::encoding::ValueTypeMarker>::borrow(val),
5536                    encoder, offset + 8, _depth
5537                )
5538            }
5539            DeviceAddress::CharIntValue(ref val) => {
5540                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<4>, D>(
5541                    <fidl::encoding::BoundedString<4> as fidl::encoding::ValueTypeMarker>::borrow(val),
5542                    encoder, offset + 8, _depth
5543                )
5544            }
5545            DeviceAddress::ArrayCharIntValue(ref val) => {
5546                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10>, D>(
5547                    <fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10> as fidl::encoding::ValueTypeMarker>::borrow(val),
5548                    encoder, offset + 8, _depth
5549                )
5550            }
5551            DeviceAddress::StringValue(ref val) => {
5552                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<32>, D>(
5553                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow(val),
5554                    encoder, offset + 8, _depth
5555                )
5556            }
5557            DeviceAddress::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
5558        }
5559        }
5560    }
5561
5562    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceAddress {
5563        #[inline(always)]
5564        fn new_empty() -> Self {
5565            Self::__SourceBreaking { unknown_ordinal: 0 }
5566        }
5567
5568        #[inline]
5569        unsafe fn decode(
5570            &mut self,
5571            decoder: &mut fidl::encoding::Decoder<'_, D>,
5572            offset: usize,
5573            mut depth: fidl::encoding::Depth,
5574        ) -> fidl::Result<()> {
5575            decoder.debug_check_bounds::<Self>(offset);
5576            #[allow(unused_variables)]
5577            let next_out_of_line = decoder.next_out_of_line();
5578            let handles_before = decoder.remaining_handles();
5579            let (ordinal, inlined, num_bytes, num_handles) =
5580                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
5581
5582            let member_inline_size = match ordinal {
5583            1 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5584            2 => <fidl::encoding::Vector<u8, 10> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5585            3 => <fidl::encoding::BoundedString<4> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5586            4 => <fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5587            5 => <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5588            0 => return Err(fidl::Error::UnknownUnionTag),
5589            _ => num_bytes as usize,
5590        };
5591
5592            if inlined != (member_inline_size <= 4) {
5593                return Err(fidl::Error::InvalidInlineBitInEnvelope);
5594            }
5595            let _inner_offset;
5596            if inlined {
5597                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
5598                _inner_offset = offset + 8;
5599            } else {
5600                depth.increment()?;
5601                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5602            }
5603            match ordinal {
5604                1 => {
5605                    #[allow(irrefutable_let_patterns)]
5606                    if let DeviceAddress::IntValue(_) = self {
5607                        // Do nothing, read the value into the object
5608                    } else {
5609                        // Initialize `self` to the right variant
5610                        *self = DeviceAddress::IntValue(fidl::new_empty!(u8, D));
5611                    }
5612                    #[allow(irrefutable_let_patterns)]
5613                    if let DeviceAddress::IntValue(ref mut val) = self {
5614                        fidl::decode!(u8, D, val, decoder, _inner_offset, depth)?;
5615                    } else {
5616                        unreachable!()
5617                    }
5618                }
5619                2 => {
5620                    #[allow(irrefutable_let_patterns)]
5621                    if let DeviceAddress::ArrayIntValue(_) = self {
5622                        // Do nothing, read the value into the object
5623                    } else {
5624                        // Initialize `self` to the right variant
5625                        *self = DeviceAddress::ArrayIntValue(
5626                            fidl::new_empty!(fidl::encoding::Vector<u8, 10>, D),
5627                        );
5628                    }
5629                    #[allow(irrefutable_let_patterns)]
5630                    if let DeviceAddress::ArrayIntValue(ref mut val) = self {
5631                        fidl::decode!(fidl::encoding::Vector<u8, 10>, D, val, decoder, _inner_offset, depth)?;
5632                    } else {
5633                        unreachable!()
5634                    }
5635                }
5636                3 => {
5637                    #[allow(irrefutable_let_patterns)]
5638                    if let DeviceAddress::CharIntValue(_) = self {
5639                        // Do nothing, read the value into the object
5640                    } else {
5641                        // Initialize `self` to the right variant
5642                        *self = DeviceAddress::CharIntValue(fidl::new_empty!(
5643                            fidl::encoding::BoundedString<4>,
5644                            D
5645                        ));
5646                    }
5647                    #[allow(irrefutable_let_patterns)]
5648                    if let DeviceAddress::CharIntValue(ref mut val) = self {
5649                        fidl::decode!(
5650                            fidl::encoding::BoundedString<4>,
5651                            D,
5652                            val,
5653                            decoder,
5654                            _inner_offset,
5655                            depth
5656                        )?;
5657                    } else {
5658                        unreachable!()
5659                    }
5660                }
5661                4 => {
5662                    #[allow(irrefutable_let_patterns)]
5663                    if let DeviceAddress::ArrayCharIntValue(_) = self {
5664                        // Do nothing, read the value into the object
5665                    } else {
5666                        // Initialize `self` to the right variant
5667                        *self = DeviceAddress::ArrayCharIntValue(fidl::new_empty!(
5668                            fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10>,
5669                            D
5670                        ));
5671                    }
5672                    #[allow(irrefutable_let_patterns)]
5673                    if let DeviceAddress::ArrayCharIntValue(ref mut val) = self {
5674                        fidl::decode!(
5675                            fidl::encoding::Vector<fidl::encoding::BoundedString<4>, 10>,
5676                            D,
5677                            val,
5678                            decoder,
5679                            _inner_offset,
5680                            depth
5681                        )?;
5682                    } else {
5683                        unreachable!()
5684                    }
5685                }
5686                5 => {
5687                    #[allow(irrefutable_let_patterns)]
5688                    if let DeviceAddress::StringValue(_) = self {
5689                        // Do nothing, read the value into the object
5690                    } else {
5691                        // Initialize `self` to the right variant
5692                        *self = DeviceAddress::StringValue(fidl::new_empty!(
5693                            fidl::encoding::BoundedString<32>,
5694                            D
5695                        ));
5696                    }
5697                    #[allow(irrefutable_let_patterns)]
5698                    if let DeviceAddress::StringValue(ref mut val) = self {
5699                        fidl::decode!(
5700                            fidl::encoding::BoundedString<32>,
5701                            D,
5702                            val,
5703                            decoder,
5704                            _inner_offset,
5705                            depth
5706                        )?;
5707                    } else {
5708                        unreachable!()
5709                    }
5710                }
5711                #[allow(deprecated)]
5712                ordinal => {
5713                    for _ in 0..num_handles {
5714                        decoder.drop_next_handle()?;
5715                    }
5716                    *self = DeviceAddress::__SourceBreaking { unknown_ordinal: ordinal };
5717                }
5718            }
5719            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5720                return Err(fidl::Error::InvalidNumBytesInEnvelope);
5721            }
5722            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5723                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5724            }
5725            Ok(())
5726        }
5727    }
5728
5729    impl fidl::encoding::ValueTypeMarker for NodePropertyKey {
5730        type Borrowed<'a> = &'a Self;
5731        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5732            value
5733        }
5734    }
5735
5736    unsafe impl fidl::encoding::TypeMarker for NodePropertyKey {
5737        type Owned = Self;
5738
5739        #[inline(always)]
5740        fn inline_align(_context: fidl::encoding::Context) -> usize {
5741            8
5742        }
5743
5744        #[inline(always)]
5745        fn inline_size(_context: fidl::encoding::Context) -> usize {
5746            16
5747        }
5748    }
5749
5750    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodePropertyKey, D>
5751        for &NodePropertyKey
5752    {
5753        #[inline]
5754        unsafe fn encode(
5755            self,
5756            encoder: &mut fidl::encoding::Encoder<'_, D>,
5757            offset: usize,
5758            _depth: fidl::encoding::Depth,
5759        ) -> fidl::Result<()> {
5760            encoder.debug_check_bounds::<NodePropertyKey>(offset);
5761            encoder.write_num::<u64>(self.ordinal(), offset);
5762            match self {
5763                NodePropertyKey::IntValue(ref val) => fidl::encoding::encode_in_envelope::<u32, D>(
5764                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
5765                    encoder,
5766                    offset + 8,
5767                    _depth,
5768                ),
5769                NodePropertyKey::StringValue(ref val) => fidl::encoding::encode_in_envelope::<
5770                    fidl::encoding::BoundedString<256>,
5771                    D,
5772                >(
5773                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
5774                        val,
5775                    ),
5776                    encoder,
5777                    offset + 8,
5778                    _depth,
5779                ),
5780            }
5781        }
5782    }
5783
5784    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodePropertyKey {
5785        #[inline(always)]
5786        fn new_empty() -> Self {
5787            Self::IntValue(fidl::new_empty!(u32, D))
5788        }
5789
5790        #[inline]
5791        unsafe fn decode(
5792            &mut self,
5793            decoder: &mut fidl::encoding::Decoder<'_, D>,
5794            offset: usize,
5795            mut depth: fidl::encoding::Depth,
5796        ) -> fidl::Result<()> {
5797            decoder.debug_check_bounds::<Self>(offset);
5798            #[allow(unused_variables)]
5799            let next_out_of_line = decoder.next_out_of_line();
5800            let handles_before = decoder.remaining_handles();
5801            let (ordinal, inlined, num_bytes, num_handles) =
5802                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
5803
5804            let member_inline_size = match ordinal {
5805                1 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5806                2 => {
5807                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5808                        decoder.context,
5809                    )
5810                }
5811                _ => return Err(fidl::Error::UnknownUnionTag),
5812            };
5813
5814            if inlined != (member_inline_size <= 4) {
5815                return Err(fidl::Error::InvalidInlineBitInEnvelope);
5816            }
5817            let _inner_offset;
5818            if inlined {
5819                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
5820                _inner_offset = offset + 8;
5821            } else {
5822                depth.increment()?;
5823                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5824            }
5825            match ordinal {
5826                1 => {
5827                    #[allow(irrefutable_let_patterns)]
5828                    if let NodePropertyKey::IntValue(_) = self {
5829                        // Do nothing, read the value into the object
5830                    } else {
5831                        // Initialize `self` to the right variant
5832                        *self = NodePropertyKey::IntValue(fidl::new_empty!(u32, D));
5833                    }
5834                    #[allow(irrefutable_let_patterns)]
5835                    if let NodePropertyKey::IntValue(ref mut val) = self {
5836                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
5837                    } else {
5838                        unreachable!()
5839                    }
5840                }
5841                2 => {
5842                    #[allow(irrefutable_let_patterns)]
5843                    if let NodePropertyKey::StringValue(_) = self {
5844                        // Do nothing, read the value into the object
5845                    } else {
5846                        // Initialize `self` to the right variant
5847                        *self = NodePropertyKey::StringValue(fidl::new_empty!(
5848                            fidl::encoding::BoundedString<256>,
5849                            D
5850                        ));
5851                    }
5852                    #[allow(irrefutable_let_patterns)]
5853                    if let NodePropertyKey::StringValue(ref mut val) = self {
5854                        fidl::decode!(
5855                            fidl::encoding::BoundedString<256>,
5856                            D,
5857                            val,
5858                            decoder,
5859                            _inner_offset,
5860                            depth
5861                        )?;
5862                    } else {
5863                        unreachable!()
5864                    }
5865                }
5866                ordinal => panic!("unexpected ordinal {:?}", ordinal),
5867            }
5868            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5869                return Err(fidl::Error::InvalidNumBytesInEnvelope);
5870            }
5871            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5872                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5873            }
5874            Ok(())
5875        }
5876    }
5877
5878    impl fidl::encoding::ValueTypeMarker for NodePropertyValue {
5879        type Borrowed<'a> = &'a Self;
5880        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5881            value
5882        }
5883    }
5884
5885    unsafe impl fidl::encoding::TypeMarker for NodePropertyValue {
5886        type Owned = Self;
5887
5888        #[inline(always)]
5889        fn inline_align(_context: fidl::encoding::Context) -> usize {
5890            8
5891        }
5892
5893        #[inline(always)]
5894        fn inline_size(_context: fidl::encoding::Context) -> usize {
5895            16
5896        }
5897    }
5898
5899    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NodePropertyValue, D>
5900        for &NodePropertyValue
5901    {
5902        #[inline]
5903        unsafe fn encode(
5904            self,
5905            encoder: &mut fidl::encoding::Encoder<'_, D>,
5906            offset: usize,
5907            _depth: fidl::encoding::Depth,
5908        ) -> fidl::Result<()> {
5909            encoder.debug_check_bounds::<NodePropertyValue>(offset);
5910            encoder.write_num::<u64>(self.ordinal(), offset);
5911            match self {
5912                NodePropertyValue::IntValue(ref val) => {
5913                    fidl::encoding::encode_in_envelope::<u32, D>(
5914                        <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
5915                        encoder,
5916                        offset + 8,
5917                        _depth,
5918                    )
5919                }
5920                NodePropertyValue::StringValue(ref val) => fidl::encoding::encode_in_envelope::<
5921                    fidl::encoding::BoundedString<256>,
5922                    D,
5923                >(
5924                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
5925                        val,
5926                    ),
5927                    encoder,
5928                    offset + 8,
5929                    _depth,
5930                ),
5931                NodePropertyValue::BoolValue(ref val) => {
5932                    fidl::encoding::encode_in_envelope::<bool, D>(
5933                        <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
5934                        encoder,
5935                        offset + 8,
5936                        _depth,
5937                    )
5938                }
5939                NodePropertyValue::EnumValue(ref val) => fidl::encoding::encode_in_envelope::<
5940                    fidl::encoding::BoundedString<256>,
5941                    D,
5942                >(
5943                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow(
5944                        val,
5945                    ),
5946                    encoder,
5947                    offset + 8,
5948                    _depth,
5949                ),
5950                NodePropertyValue::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
5951            }
5952        }
5953    }
5954
5955    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodePropertyValue {
5956        #[inline(always)]
5957        fn new_empty() -> Self {
5958            Self::__SourceBreaking { unknown_ordinal: 0 }
5959        }
5960
5961        #[inline]
5962        unsafe fn decode(
5963            &mut self,
5964            decoder: &mut fidl::encoding::Decoder<'_, D>,
5965            offset: usize,
5966            mut depth: fidl::encoding::Depth,
5967        ) -> fidl::Result<()> {
5968            decoder.debug_check_bounds::<Self>(offset);
5969            #[allow(unused_variables)]
5970            let next_out_of_line = decoder.next_out_of_line();
5971            let handles_before = decoder.remaining_handles();
5972            let (ordinal, inlined, num_bytes, num_handles) =
5973                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
5974
5975            let member_inline_size = match ordinal {
5976                1 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5977                2 => {
5978                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5979                        decoder.context,
5980                    )
5981                }
5982                3 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5983                4 => {
5984                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5985                        decoder.context,
5986                    )
5987                }
5988                0 => return Err(fidl::Error::UnknownUnionTag),
5989                _ => num_bytes as usize,
5990            };
5991
5992            if inlined != (member_inline_size <= 4) {
5993                return Err(fidl::Error::InvalidInlineBitInEnvelope);
5994            }
5995            let _inner_offset;
5996            if inlined {
5997                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
5998                _inner_offset = offset + 8;
5999            } else {
6000                depth.increment()?;
6001                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6002            }
6003            match ordinal {
6004                1 => {
6005                    #[allow(irrefutable_let_patterns)]
6006                    if let NodePropertyValue::IntValue(_) = self {
6007                        // Do nothing, read the value into the object
6008                    } else {
6009                        // Initialize `self` to the right variant
6010                        *self = NodePropertyValue::IntValue(fidl::new_empty!(u32, D));
6011                    }
6012                    #[allow(irrefutable_let_patterns)]
6013                    if let NodePropertyValue::IntValue(ref mut val) = self {
6014                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
6015                    } else {
6016                        unreachable!()
6017                    }
6018                }
6019                2 => {
6020                    #[allow(irrefutable_let_patterns)]
6021                    if let NodePropertyValue::StringValue(_) = self {
6022                        // Do nothing, read the value into the object
6023                    } else {
6024                        // Initialize `self` to the right variant
6025                        *self = NodePropertyValue::StringValue(fidl::new_empty!(
6026                            fidl::encoding::BoundedString<256>,
6027                            D
6028                        ));
6029                    }
6030                    #[allow(irrefutable_let_patterns)]
6031                    if let NodePropertyValue::StringValue(ref mut val) = self {
6032                        fidl::decode!(
6033                            fidl::encoding::BoundedString<256>,
6034                            D,
6035                            val,
6036                            decoder,
6037                            _inner_offset,
6038                            depth
6039                        )?;
6040                    } else {
6041                        unreachable!()
6042                    }
6043                }
6044                3 => {
6045                    #[allow(irrefutable_let_patterns)]
6046                    if let NodePropertyValue::BoolValue(_) = self {
6047                        // Do nothing, read the value into the object
6048                    } else {
6049                        // Initialize `self` to the right variant
6050                        *self = NodePropertyValue::BoolValue(fidl::new_empty!(bool, D));
6051                    }
6052                    #[allow(irrefutable_let_patterns)]
6053                    if let NodePropertyValue::BoolValue(ref mut val) = self {
6054                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
6055                    } else {
6056                        unreachable!()
6057                    }
6058                }
6059                4 => {
6060                    #[allow(irrefutable_let_patterns)]
6061                    if let NodePropertyValue::EnumValue(_) = self {
6062                        // Do nothing, read the value into the object
6063                    } else {
6064                        // Initialize `self` to the right variant
6065                        *self = NodePropertyValue::EnumValue(fidl::new_empty!(
6066                            fidl::encoding::BoundedString<256>,
6067                            D
6068                        ));
6069                    }
6070                    #[allow(irrefutable_let_patterns)]
6071                    if let NodePropertyValue::EnumValue(ref mut val) = self {
6072                        fidl::decode!(
6073                            fidl::encoding::BoundedString<256>,
6074                            D,
6075                            val,
6076                            decoder,
6077                            _inner_offset,
6078                            depth
6079                        )?;
6080                    } else {
6081                        unreachable!()
6082                    }
6083                }
6084                #[allow(deprecated)]
6085                ordinal => {
6086                    for _ in 0..num_handles {
6087                        decoder.drop_next_handle()?;
6088                    }
6089                    *self = NodePropertyValue::__SourceBreaking { unknown_ordinal: ordinal };
6090                }
6091            }
6092            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
6093                return Err(fidl::Error::InvalidNumBytesInEnvelope);
6094            }
6095            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6096                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6097            }
6098            Ok(())
6099        }
6100    }
6101
6102    impl fidl::encoding::ValueTypeMarker for Offer {
6103        type Borrowed<'a> = &'a Self;
6104        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6105            value
6106        }
6107    }
6108
6109    unsafe impl fidl::encoding::TypeMarker for Offer {
6110        type Owned = Self;
6111
6112        #[inline(always)]
6113        fn inline_align(_context: fidl::encoding::Context) -> usize {
6114            8
6115        }
6116
6117        #[inline(always)]
6118        fn inline_size(_context: fidl::encoding::Context) -> usize {
6119            16
6120        }
6121    }
6122
6123    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Offer, D> for &Offer {
6124        #[inline]
6125        unsafe fn encode(
6126            self,
6127            encoder: &mut fidl::encoding::Encoder<'_, D>,
6128            offset: usize,
6129            _depth: fidl::encoding::Depth,
6130        ) -> fidl::Result<()> {
6131            encoder.debug_check_bounds::<Offer>(offset);
6132            encoder.write_num::<u64>(self.ordinal(), offset);
6133            match self {
6134            Offer::ZirconTransport(ref val) => {
6135                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Offer, D>(
6136                    <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::ValueTypeMarker>::borrow(val),
6137                    encoder, offset + 8, _depth
6138                )
6139            }
6140            Offer::DriverTransport(ref val) => {
6141                fidl::encoding::encode_in_envelope::<fidl_fuchsia_component_decl__common::Offer, D>(
6142                    <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::ValueTypeMarker>::borrow(val),
6143                    encoder, offset + 8, _depth
6144                )
6145            }
6146            Offer::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
6147        }
6148        }
6149    }
6150
6151    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Offer {
6152        #[inline(always)]
6153        fn new_empty() -> Self {
6154            Self::__SourceBreaking { unknown_ordinal: 0 }
6155        }
6156
6157        #[inline]
6158        unsafe fn decode(
6159            &mut self,
6160            decoder: &mut fidl::encoding::Decoder<'_, D>,
6161            offset: usize,
6162            mut depth: fidl::encoding::Depth,
6163        ) -> fidl::Result<()> {
6164            decoder.debug_check_bounds::<Self>(offset);
6165            #[allow(unused_variables)]
6166            let next_out_of_line = decoder.next_out_of_line();
6167            let handles_before = decoder.remaining_handles();
6168            let (ordinal, inlined, num_bytes, num_handles) =
6169                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
6170
6171            let member_inline_size = match ordinal {
6172            1 => <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::TypeMarker>::inline_size(decoder.context),
6173            2 => <fidl_fuchsia_component_decl__common::Offer as fidl::encoding::TypeMarker>::inline_size(decoder.context),
6174            0 => return Err(fidl::Error::UnknownUnionTag),
6175            _ => num_bytes as usize,
6176        };
6177
6178            if inlined != (member_inline_size <= 4) {
6179                return Err(fidl::Error::InvalidInlineBitInEnvelope);
6180            }
6181            let _inner_offset;
6182            if inlined {
6183                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
6184                _inner_offset = offset + 8;
6185            } else {
6186                depth.increment()?;
6187                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6188            }
6189            match ordinal {
6190                1 => {
6191                    #[allow(irrefutable_let_patterns)]
6192                    if let Offer::ZirconTransport(_) = self {
6193                        // Do nothing, read the value into the object
6194                    } else {
6195                        // Initialize `self` to the right variant
6196                        *self = Offer::ZirconTransport(fidl::new_empty!(
6197                            fidl_fuchsia_component_decl__common::Offer,
6198                            D
6199                        ));
6200                    }
6201                    #[allow(irrefutable_let_patterns)]
6202                    if let Offer::ZirconTransport(ref mut val) = self {
6203                        fidl::decode!(
6204                            fidl_fuchsia_component_decl__common::Offer,
6205                            D,
6206                            val,
6207                            decoder,
6208                            _inner_offset,
6209                            depth
6210                        )?;
6211                    } else {
6212                        unreachable!()
6213                    }
6214                }
6215                2 => {
6216                    #[allow(irrefutable_let_patterns)]
6217                    if let Offer::DriverTransport(_) = self {
6218                        // Do nothing, read the value into the object
6219                    } else {
6220                        // Initialize `self` to the right variant
6221                        *self = Offer::DriverTransport(fidl::new_empty!(
6222                            fidl_fuchsia_component_decl__common::Offer,
6223                            D
6224                        ));
6225                    }
6226                    #[allow(irrefutable_let_patterns)]
6227                    if let Offer::DriverTransport(ref mut val) = self {
6228                        fidl::decode!(
6229                            fidl_fuchsia_component_decl__common::Offer,
6230                            D,
6231                            val,
6232                            decoder,
6233                            _inner_offset,
6234                            depth
6235                        )?;
6236                    } else {
6237                        unreachable!()
6238                    }
6239                }
6240                #[allow(deprecated)]
6241                ordinal => {
6242                    for _ in 0..num_handles {
6243                        decoder.drop_next_handle()?;
6244                    }
6245                    *self = Offer::__SourceBreaking { unknown_ordinal: ordinal };
6246                }
6247            }
6248            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
6249                return Err(fidl::Error::InvalidNumBytesInEnvelope);
6250            }
6251            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6252                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6253            }
6254            Ok(())
6255        }
6256    }
6257}