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