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