fidl_fuchsia_hardware_audio_signalprocessing__common/
fidl_fuchsia_hardware_audio_signalprocessing__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 ElementId = u64;
12
13pub type TopologyId = u64;
14
15pub const MAX_BYTES_ELEMENT_VENDOR_SPECIFIC: u32 = 4096;
16
17pub const MAX_COUNT_DYNAMICS_BANDS: u32 = 64;
18
19pub const MAX_COUNT_EQUALIZER_BANDS: u32 = 64;
20
21pub const MAX_COUNT_PROCESSING_ELEMENTS: u32 = 64;
22
23pub const MAX_COUNT_PROCESSING_ELEMENTS_EDGE_PAIRS: u32 = 64;
24
25pub const MAX_COUNT_TOPOLOGIES: u32 = 64;
26
27pub const MAX_STRING_SIZE: u32 = 256;
28
29bitflags! {
30    /// Supported controls for `Dynamics`.
31    /// If included, each bit representing a parameter of the dynamics processing bands can be changed
32    /// with `SetElementState`.
33    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
34    pub struct DynamicsSupportedControls: u64 {
35        /// If set, `SetElementState` can change a dynamics band's `knee_width_db` parameter.
36        const KNEE_WIDTH = 1;
37        /// If set, `SetElementState` can change a dynamics band's `attack` parameter.
38        const ATTACK = 2;
39        /// If set, `SetElementState` can change a dynamics band's `release` parameter.
40        const RELEASE = 4;
41        /// If set, `SetElementState` can change a dynamics band's `output_gain_db` parameter.
42        const OUTPUT_GAIN = 8;
43        /// If set, `SetElementState` can change a dynamics band's `input_gain_db` parameter.
44        const INPUT_GAIN = 16;
45        /// If set, `SetElementState` can change a dynamics band's `lookahead` parameter.
46        const LOOKAHEAD = 32;
47        /// If set, `SetElementState` can change a dynamics band's `level_type` parameter.
48        const LEVEL_TYPE = 64;
49        /// If set, `SetElementState` can change a dynamics band's `linked_channels` parameter.
50        const LINKED_CHANNELS = 128;
51        /// If set, `SetElementState` can change a dynamics band's `threshold_type` parameter.
52        const THRESHOLD_TYPE = 256;
53    }
54}
55
56impl DynamicsSupportedControls {
57    #[inline(always)]
58    pub fn from_bits_allow_unknown(bits: u64) -> Self {
59        Self::from_bits_retain(bits)
60    }
61
62    #[inline(always)]
63    pub fn has_unknown_bits(&self) -> bool {
64        self.get_unknown_bits() != 0
65    }
66
67    #[inline(always)]
68    pub fn get_unknown_bits(&self) -> u64 {
69        self.bits() & !Self::all().bits()
70    }
71}
72
73bitflags! {
74    /// Equalizer supported controls specified in `Equalizer`.
75    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
76    pub struct EqualizerSupportedControls: u64 {
77        /// If set, `SetElementState` can change an equalizer band's `frequency`.
78        const CAN_CONTROL_FREQUENCY = 1;
79        /// If set, `SetElementState` can change an equalizer band's `q`.
80        const CAN_CONTROL_Q = 2;
81        /// If set, `SetElementState` can change a band's `type` to `EqualizerBandType.PEAK`.
82        const SUPPORTS_TYPE_PEAK = 4;
83        /// If set, `SetElementState` can change a band's `type` to `EqualizerBandType.NOTCH`.
84        const SUPPORTS_TYPE_NOTCH = 8;
85        /// If set, `SetElementState` can change a band's `type` to `EqualizerBandType.LOW_CUT`.
86        const SUPPORTS_TYPE_LOW_CUT = 16;
87        /// If set, `SetElementState` can change a band's `type` to `EqualizerBandType.HIGH_CUT`.
88        const SUPPORTS_TYPE_HIGH_CUT = 32;
89        /// If set, `SetElementState` can change a band's `type` `EqualizerBandType.LOW_SHELF`.
90        const SUPPORTS_TYPE_LOW_SHELF = 64;
91        /// If set, `SetElementState` can change a band's `type` to `EqualizerBandType.HIGH_SHELF`.
92        const SUPPORTS_TYPE_HIGH_SHELF = 128;
93    }
94}
95
96impl EqualizerSupportedControls {
97    #[inline(always)]
98    pub fn from_bits_allow_unknown(bits: u64) -> Self {
99        Self::from_bits_retain(bits)
100    }
101
102    #[inline(always)]
103    pub fn has_unknown_bits(&self) -> bool {
104        self.get_unknown_bits() != 0
105    }
106
107    #[inline(always)]
108    pub fn get_unknown_bits(&self) -> u64 {
109        self.bits() & !Self::all().bits()
110    }
111}
112
113#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
114pub enum ElementType {
115    /// Vendor Specific. A type of processing element not covered by any subsequent type definition.
116    VendorSpecific,
117    /// Controls pipelines channel mixing and routing.
118    ConnectionPoint,
119    /// Gain control, a.k.a. Volume control.
120    Gain,
121    /// Automatic Gain Control.
122    /// Automatically maintains a suitable signal level regardless of variation of its input.
123    AutomaticGainControl,
124    /// Automatic Gain Limiter.
125    /// Automatically maintains a signal level below a level specified.
126    /// Input below the level is unaffected, and peaks above the level are attenuated.
127    AutomaticGainLimiter,
128    /// Alters the dynamic range of the signal, e.g. dynamic range compression.
129    Dynamics,
130    /// Mute.
131    Mute,
132    /// Delay.
133    Delay,
134    /// Equalizer.
135    Equalizer,
136    /// Sample Rate Conversion.
137    SampleRateConversion,
138    /// The start/end of a pipeline.
139    ///
140    /// # Deprecation
141    ///
142    /// Use `RING_BUFFER` or `DAI_INTERCONNECT` instead.
143    Endpoint,
144    /// Ring Buffer.
145    /// This is the first of two types of elements that can start/end processing pipelines.
146    RingBuffer,
147    /// Digital Audio Interface Interconnect.
148    /// This is the second of two types of elements that can start/end processing pipelines.
149    DaiInterconnect,
150    #[doc(hidden)]
151    __SourceBreaking { unknown_ordinal: u32 },
152}
153
154/// Pattern that matches an unknown `ElementType` member.
155#[macro_export]
156macro_rules! ElementTypeUnknown {
157    () => {
158        _
159    };
160}
161
162impl ElementType {
163    #[inline]
164    pub fn from_primitive(prim: u32) -> Option<Self> {
165        match prim {
166            1 => Some(Self::VendorSpecific),
167            3 => Some(Self::ConnectionPoint),
168            4 => Some(Self::Gain),
169            5 => Some(Self::AutomaticGainControl),
170            6 => Some(Self::AutomaticGainLimiter),
171            7 => Some(Self::Dynamics),
172            8 => Some(Self::Mute),
173            9 => Some(Self::Delay),
174            10 => Some(Self::Equalizer),
175            11 => Some(Self::SampleRateConversion),
176            12 => Some(Self::Endpoint),
177            13 => Some(Self::RingBuffer),
178            14 => Some(Self::DaiInterconnect),
179            _ => None,
180        }
181    }
182
183    #[inline]
184    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
185        match prim {
186            1 => Self::VendorSpecific,
187            3 => Self::ConnectionPoint,
188            4 => Self::Gain,
189            5 => Self::AutomaticGainControl,
190            6 => Self::AutomaticGainLimiter,
191            7 => Self::Dynamics,
192            8 => Self::Mute,
193            9 => Self::Delay,
194            10 => Self::Equalizer,
195            11 => Self::SampleRateConversion,
196            12 => Self::Endpoint,
197            13 => Self::RingBuffer,
198            14 => Self::DaiInterconnect,
199            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
200        }
201    }
202
203    #[inline]
204    pub fn unknown() -> Self {
205        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
206    }
207
208    #[inline]
209    pub const fn into_primitive(self) -> u32 {
210        match self {
211            Self::VendorSpecific => 1,
212            Self::ConnectionPoint => 3,
213            Self::Gain => 4,
214            Self::AutomaticGainControl => 5,
215            Self::AutomaticGainLimiter => 6,
216            Self::Dynamics => 7,
217            Self::Mute => 8,
218            Self::Delay => 9,
219            Self::Equalizer => 10,
220            Self::SampleRateConversion => 11,
221            Self::Endpoint => 12,
222            Self::RingBuffer => 13,
223            Self::DaiInterconnect => 14,
224            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
225        }
226    }
227
228    #[inline]
229    pub fn is_unknown(&self) -> bool {
230        match self {
231            Self::__SourceBreaking { unknown_ordinal: _ } => true,
232            _ => false,
233        }
234    }
235}
236
237/// Endpoint types.
238///
239/// # Deprecation
240///
241/// Use `ElementType` `RING_BUFFER` or `DAI_INTERCONNECT` instead.
242#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
243pub enum EndpointType {
244    /// The endpoint represents a ring buffer.
245    /// A ring buffer processing element's id allows for multi-ring buffer topologies to
246    /// be supported by a driver providing the fuchsia.hardware.audio/Composite API.
247    RingBuffer,
248    /// The endpoint represents a Digital Audio Interface Interconnect,
249    /// e.g. connecting an SoC audio subsystem to a DAC + amplifier hardware codec.
250    DaiInterconnect,
251    #[doc(hidden)]
252    __SourceBreaking { unknown_ordinal: u8 },
253}
254
255/// Pattern that matches an unknown `EndpointType` member.
256#[macro_export]
257macro_rules! EndpointTypeUnknown {
258    () => {
259        _
260    };
261}
262
263impl EndpointType {
264    #[inline]
265    pub fn from_primitive(prim: u8) -> Option<Self> {
266        match prim {
267            1 => Some(Self::RingBuffer),
268            2 => Some(Self::DaiInterconnect),
269            _ => None,
270        }
271    }
272
273    #[inline]
274    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
275        match prim {
276            1 => Self::RingBuffer,
277            2 => Self::DaiInterconnect,
278            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
279        }
280    }
281
282    #[inline]
283    pub fn unknown() -> Self {
284        Self::__SourceBreaking { unknown_ordinal: 0xff }
285    }
286
287    #[inline]
288    pub const fn into_primitive(self) -> u8 {
289        match self {
290            Self::RingBuffer => 1,
291            Self::DaiInterconnect => 2,
292            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
293        }
294    }
295
296    #[inline]
297    pub fn is_unknown(&self) -> bool {
298        match self {
299            Self::__SourceBreaking { unknown_ordinal: _ } => true,
300            _ => false,
301        }
302    }
303}
304
305/// Type of the equalizer band.
306#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
307pub enum EqualizerBandType {
308    /// Increase/decrease in `gain_db` in the vicinity of a `frequency` with an optional `q`.
309    Peak,
310    /// Narrow band rejection significantly attenuating a `frequency` with an optional `q`.
311    Notch,
312    /// Decrease gain below a `frequency` with an optional `q`, a.k.a high pass.
313    LowCut,
314    /// Decrease gain above a `frequency` with an optional `q`, a.k.a low pass.
315    HighCut,
316    /// Decrease gain below a `frequency` for a `gain_db` amount with a plateau effect.
317    LowShelf,
318    /// Decrease gain above a `frequency` for a `gain_db` amount with a plateau effect.
319    HighShelf,
320    #[doc(hidden)]
321    __SourceBreaking { unknown_ordinal: u64 },
322}
323
324/// Pattern that matches an unknown `EqualizerBandType` member.
325#[macro_export]
326macro_rules! EqualizerBandTypeUnknown {
327    () => {
328        _
329    };
330}
331
332impl EqualizerBandType {
333    #[inline]
334    pub fn from_primitive(prim: u64) -> Option<Self> {
335        match prim {
336            1 => Some(Self::Peak),
337            2 => Some(Self::Notch),
338            3 => Some(Self::LowCut),
339            4 => Some(Self::HighCut),
340            5 => Some(Self::LowShelf),
341            6 => Some(Self::HighShelf),
342            _ => None,
343        }
344    }
345
346    #[inline]
347    pub fn from_primitive_allow_unknown(prim: u64) -> Self {
348        match prim {
349            1 => Self::Peak,
350            2 => Self::Notch,
351            3 => Self::LowCut,
352            4 => Self::HighCut,
353            5 => Self::LowShelf,
354            6 => Self::HighShelf,
355            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
356        }
357    }
358
359    #[inline]
360    pub fn unknown() -> Self {
361        Self::__SourceBreaking { unknown_ordinal: 0xffffffffffffffff }
362    }
363
364    #[inline]
365    pub const fn into_primitive(self) -> u64 {
366        match self {
367            Self::Peak => 1,
368            Self::Notch => 2,
369            Self::LowCut => 3,
370            Self::HighCut => 4,
371            Self::LowShelf => 5,
372            Self::HighShelf => 6,
373            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
374        }
375    }
376
377    #[inline]
378    pub fn is_unknown(&self) -> bool {
379        match self {
380            Self::__SourceBreaking { unknown_ordinal: _ } => true,
381            _ => false,
382        }
383    }
384}
385
386/// Hardware domain of the gain, e.g. ANALOG.
387#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
388pub enum GainDomain {
389    /// The processing element gain is applied in the digital domain.
390    Digital,
391    /// The processing element gain is applied in the analog domain.
392    Analog,
393    /// The processing element gain is mixed using digital and analog hardware.
394    Mixed,
395    #[doc(hidden)]
396    __SourceBreaking { unknown_ordinal: u8 },
397}
398
399/// Pattern that matches an unknown `GainDomain` member.
400#[macro_export]
401macro_rules! GainDomainUnknown {
402    () => {
403        _
404    };
405}
406
407impl GainDomain {
408    #[inline]
409    pub fn from_primitive(prim: u8) -> Option<Self> {
410        match prim {
411            1 => Some(Self::Digital),
412            2 => Some(Self::Analog),
413            3 => Some(Self::Mixed),
414            _ => None,
415        }
416    }
417
418    #[inline]
419    pub fn from_primitive_allow_unknown(prim: u8) -> Self {
420        match prim {
421            1 => Self::Digital,
422            2 => Self::Analog,
423            3 => Self::Mixed,
424            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
425        }
426    }
427
428    #[inline]
429    pub fn unknown() -> Self {
430        Self::__SourceBreaking { unknown_ordinal: 0xff }
431    }
432
433    #[inline]
434    pub const fn into_primitive(self) -> u8 {
435        match self {
436            Self::Digital => 1,
437            Self::Analog => 2,
438            Self::Mixed => 3,
439            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
440        }
441    }
442
443    #[inline]
444    pub fn is_unknown(&self) -> bool {
445        match self {
446            Self::__SourceBreaking { unknown_ordinal: _ } => true,
447            _ => false,
448        }
449    }
450}
451
452/// Gain type of representation.
453#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
454#[repr(u8)]
455pub enum GainType {
456    /// Gain specified in dB, for example -103.0dB or +3.2dB.
457    Decibels = 1,
458    /// Gain specified as a percentage, for example 10.0% or 80.5%.
459    Percent = 2,
460}
461
462impl GainType {
463    #[inline]
464    pub fn from_primitive(prim: u8) -> Option<Self> {
465        match prim {
466            1 => Some(Self::Decibels),
467            2 => Some(Self::Percent),
468            _ => None,
469        }
470    }
471
472    #[inline]
473    pub const fn into_primitive(self) -> u8 {
474        self as u8
475    }
476}
477
478/// Level type.
479#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
480#[repr(u8)]
481pub enum LevelType {
482    /// Level Gain specified as peak.
483    Peak = 1,
484    /// Level specified as RMS.
485    Rms = 2,
486}
487
488impl LevelType {
489    #[inline]
490    pub fn from_primitive(prim: u8) -> Option<Self> {
491        match prim {
492            1 => Some(Self::Peak),
493            2 => Some(Self::Rms),
494            _ => None,
495        }
496    }
497
498    #[inline]
499    pub const fn into_primitive(self) -> u8 {
500        self as u8
501    }
502}
503
504/// Plug detection capabilities for the interconnect.
505#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
506pub enum PlugDetectCapabilities {
507    /// Interconnect is hardwired (will always be plugged in).
508    Hardwired,
509    /// Interconnect can be unplugged/plugged and can asynchronously notify of plug state changes.
510    CanAsyncNotify,
511    #[doc(hidden)]
512    __SourceBreaking { unknown_ordinal: u32 },
513}
514
515/// Pattern that matches an unknown `PlugDetectCapabilities` member.
516#[macro_export]
517macro_rules! PlugDetectCapabilitiesUnknown {
518    () => {
519        _
520    };
521}
522
523impl PlugDetectCapabilities {
524    #[inline]
525    pub fn from_primitive(prim: u32) -> Option<Self> {
526        match prim {
527            0 => Some(Self::Hardwired),
528            1 => Some(Self::CanAsyncNotify),
529            _ => None,
530        }
531    }
532
533    #[inline]
534    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
535        match prim {
536            0 => Self::Hardwired,
537            1 => Self::CanAsyncNotify,
538            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
539        }
540    }
541
542    #[inline]
543    pub fn unknown() -> Self {
544        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
545    }
546
547    #[inline]
548    pub const fn into_primitive(self) -> u32 {
549        match self {
550            Self::Hardwired => 0,
551            Self::CanAsyncNotify => 1,
552            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
553        }
554    }
555
556    #[inline]
557    pub fn is_unknown(&self) -> bool {
558        match self {
559            Self::__SourceBreaking { unknown_ordinal: _ } => true,
560            _ => false,
561        }
562    }
563}
564
565/// Threshold type.
566#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
567#[repr(u8)]
568pub enum ThresholdType {
569    /// Apply dynamics processing above the threshold.
570    Above = 1,
571    /// Apply dynamics processing below the threshold.
572    Below = 2,
573}
574
575impl ThresholdType {
576    #[inline]
577    pub fn from_primitive(prim: u8) -> Option<Self> {
578        match prim {
579            1 => Some(Self::Above),
580            2 => Some(Self::Below),
581            _ => None,
582        }
583    }
584
585    #[inline]
586    pub const fn into_primitive(self) -> u8 {
587        self as u8
588    }
589}
590
591/// Edge pairs between processing elements, used to specify how audio flows sequentially through
592/// a collection of processing elements
593/// arrangements.
594#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
595#[repr(C)]
596pub struct EdgePair {
597    pub processing_element_id_from: u64,
598    pub processing_element_id_to: u64,
599}
600
601impl fidl::Persistable for EdgePair {}
602
603#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
604#[repr(C)]
605pub struct ReaderWatchElementStateRequest {
606    pub processing_element_id: u64,
607}
608
609impl fidl::Persistable for ReaderWatchElementStateRequest {}
610
611#[derive(Clone, Debug, PartialEq)]
612pub struct ReaderWatchElementStateResponse {
613    pub state: ElementState,
614}
615
616impl fidl::Persistable for ReaderWatchElementStateResponse {}
617
618#[derive(Clone, Debug, PartialEq)]
619pub struct ReaderGetElementsResponse {
620    pub processing_elements: Vec<Element>,
621}
622
623impl fidl::Persistable for ReaderGetElementsResponse {}
624
625#[derive(Clone, Debug, PartialEq)]
626pub struct ReaderGetTopologiesResponse {
627    pub topologies: Vec<Topology>,
628}
629
630impl fidl::Persistable for ReaderGetTopologiesResponse {}
631
632#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
633#[repr(C)]
634pub struct ReaderWatchTopologyResponse {
635    pub topology_id: u64,
636}
637
638impl fidl::Persistable for ReaderWatchTopologyResponse {}
639
640#[derive(Clone, Debug, PartialEq)]
641pub struct SignalProcessingSetElementStateRequest {
642    pub processing_element_id: u64,
643    pub state: SettableElementState,
644}
645
646impl fidl::Persistable for SignalProcessingSetElementStateRequest {}
647
648#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
649#[repr(C)]
650pub struct SignalProcessingSetTopologyRequest {
651    pub topology_id: u64,
652}
653
654impl fidl::Persistable for SignalProcessingSetTopologyRequest {}
655
656/// Parameters for an `Element` with `ElementType` `DAI_INTERCONNECT`.
657#[derive(Clone, Debug, Default, PartialEq)]
658pub struct DaiInterconnect {
659    /// Plug Detect Capabilities.
660    ///
661    /// Required.
662    pub plug_detect_capabilities: Option<PlugDetectCapabilities>,
663    #[doc(hidden)]
664    pub __source_breaking: fidl::marker::SourceBreaking,
665}
666
667impl fidl::Persistable for DaiInterconnect {}
668
669/// State for an `Element` with `ElementType` `DAI_INTERCONNECT`.
670#[derive(Clone, Debug, Default, PartialEq)]
671pub struct DaiInterconnectElementState {
672    /// The plug state for this DAI interconnect.
673    ///
674    /// Required.
675    pub plug_state: Option<PlugState>,
676    /// The driver's best estimate of the external delay beyond this DAI endpoint, as the pipeline
677    /// is currently configured.
678    ///
679    /// `external_delay` must be taken into account by the client when determining the requirements
680    /// for minimum lead time (during playback) and minimum capture delay (during capture).
681    ///
682    /// If not included, `external_delay` is unknown; the client may treat it however it chooses
683    /// (e.g. consider it zero or some other duration, autodetect it, etc).
684    ///
685    /// Optional. If specified, must be non-negative.
686    pub external_delay: Option<i64>,
687    #[doc(hidden)]
688    pub __source_breaking: fidl::marker::SourceBreaking,
689}
690
691impl fidl::Persistable for DaiInterconnectElementState {}
692
693/// Parameters for an `Element` with `type` equal to `DYNAMICS`.
694#[derive(Clone, Debug, Default, PartialEq)]
695pub struct Dynamics {
696    /// `Dynamics` elements in this protocol may support multiple bands. Each band specifies a
697    /// number of parameters in `DynamicsElementState` that can be changed with `SetElementState`.
698    /// The number of elements in the `bands` vector determines the number of bands supported by
699    /// this processing element.
700    ///
701    /// Required. Must contain at least one entry.
702    pub bands: Option<Vec<DynamicsBand>>,
703    /// The controls supported by this processing element (i.e. that can be changed by a call to
704    /// `SetElementState`).
705    ///
706    /// Optional.
707    pub supported_controls: Option<DynamicsSupportedControls>,
708    #[doc(hidden)]
709    pub __source_breaking: fidl::marker::SourceBreaking,
710}
711
712impl fidl::Persistable for Dynamics {}
713
714/// Parameters for a `Dynamics` element band.
715#[derive(Clone, Debug, Default, PartialEq)]
716pub struct DynamicsBand {
717    /// Unique ID for this band, only required to be unique within the corresponding
718    /// `Element`, and valid until the channel associated with the `SignalProcessing`
719    /// protocol is closed.
720    ///
721    /// Required.
722    pub id: Option<u64>,
723    #[doc(hidden)]
724    pub __source_breaking: fidl::marker::SourceBreaking,
725}
726
727impl fidl::Persistable for DynamicsBand {}
728
729/// State for a single band within an `Element` with `type` equal to `DYNAMICS`.
730/// `WatchElementState` may return control band fields, even if the values cannot be changed by the
731/// client (i.e. the bits are not set in `supported_controls`).
732#[derive(Clone, Debug, Default, PartialEq)]
733pub struct DynamicsBandState {
734    /// Unique ID for the band. Must match one of the `id`s specified in
735    /// `Dynamics` `bands`.
736    pub id: Option<u64>,
737    /// Minimum frequency for the band in Hz.
738    /// This field could be 0, for instance for single band dynamics processing to specify
739    /// (together with max_frequency) that the band is full range.
740    pub min_frequency: Option<u32>,
741    /// Maximum frequency for the band in Hz.
742    /// This field could be the Nyquist frequency, for instance for single band dynamics
743    /// processing to specify (together with min_frequency) that the band is full range.
744    ///
745    /// Required.
746    pub max_frequency: Option<u32>,
747    /// The value beyond which the dynamics main processing starts (subject to the
748    /// `knee_width_db`), in input dB.
749    /// Some signal processing like `input_gain` and `output_gain` are not affected by this value.
750    ///
751    /// Required. Must be finite.
752    pub threshold_db: Option<f32>,
753    /// Dynamics processing is applied `ABOVE` or `BELOW` the threshold.
754    ///
755    /// Required for `WatchElementState`.
756    /// Disallowed in `SetElementState` if `DynamicsSupportedControls.THRESHOLD_TYPE` is not set
757    /// in `supported_controls`.
758    pub threshold_type: Option<ThresholdType>,
759    /// The input-to-output dB ratio above or below (see `threshold_type`) the knee region.
760    ///
761    /// Required. Must be finite.
762    pub ratio: Option<f32>,
763    /// The width of the knee region, in input dB. If present, cannot be negative.
764    /// If not included, the width of the knee region is unspecified.
765    /// A value of zero is a "hard" knee; larger values lead to "softer" knees.
766    /// This knee is centered on `threshold_db`.
767    ///
768    /// Optional. If specified, must be finite.
769    /// Disallowed in `SetElementState` if `DynamicsSupportedControls.KNEE_WIDTH` is not set
770    /// in `supported_controls`.
771    pub knee_width_db: Option<f32>,
772    /// Attack time.
773    /// If not included, the attack time is unspecified.
774    ///
775    /// Optional. If specified, must be non-negative.
776    /// Disallowed in `SetElementState` if `DynamicsSupportedControls.ATTACK` is not set
777    /// in `supported_controls`.
778    pub attack: Option<i64>,
779    /// Release time.
780    /// If not included, the release time is unspecified.
781    ///
782    /// Optional. If specified, must be non-negative.
783    /// Disallowed in `SetElementState` if `DynamicsSupportedControls.RELEASE` is not set
784    /// in `supported_controls`.
785    pub release: Option<i64>,
786    /// Output (a.k.a. make up or post) gain value in dB.
787    /// If not included, the output gain is unspecified.
788    ///
789    /// Optional. If specified, must be finite.
790    /// Disallowed in `SetElementState` if `DynamicsSupportedControls.OUTPUT_GAIN` is not set
791    /// in `supported_controls`.
792    pub output_gain_db: Option<f32>,
793    /// Input (a.k.a. pre) gain value in dB.
794    /// If not included, the input gain is unspecified.
795    ///
796    /// Optional. If specified, must be finite.
797    /// Disallowed in `SetElementState` if `DynamicsSupportedControls.INPUT_GAIN` is not set
798    /// in `supported_controls`.
799    pub input_gain_db: Option<f32>,
800    /// Level type (peak or RMS).
801    /// If not included, the level type is unspecified.
802    ///
803    /// Optional.
804    /// Disallowed in `SetElementState` if `DynamicsSupportedControls.LEVEL_TYPE` is not set
805    /// in `supported_controls`.
806    pub level_type: Option<LevelType>,
807    /// Look-ahead time.
808    /// If not included, the look-ahead time is unspecified.
809    ///
810    /// Optional. If specified, must be non-negative.
811    /// Disallowed in `SetElementState` if `DynamicsSupportedControls.LOOKAHEAD` is not set
812    /// in `supported_controls`.
813    pub lookahead: Option<i64>,
814    /// Linked channels (a.k.a. Stereo linked for 2-channel systems).
815    /// If not included, the linked channels option is unspecified.
816    /// If true, the dynamics response is applied to all channels.
817    /// If false, each channel has its own dynamics response.
818    ///
819    /// Optional.
820    /// Disallowed in `SetElementState` if `DynamicsSupportedControls.LINKED_CHANNELS` is not set
821    /// in `supported_controls`.
822    pub linked_channels: Option<bool>,
823    #[doc(hidden)]
824    pub __source_breaking: fidl::marker::SourceBreaking,
825}
826
827impl fidl::Persistable for DynamicsBandState {}
828
829/// State for an `Element` with `type` equal to `DYNAMICS`.
830#[derive(Clone, Debug, Default, PartialEq)]
831pub struct DynamicsElementState {
832    /// Each id must match an id from `Dynamics.bands` and ids cannot be repeated.
833    /// `band_states` must have at least one element.
834    /// The bands controlled by `band_states` are determined by each `band.id`.
835    ///
836    /// Required. Must contain at least one entry.
837    pub band_states: Option<Vec<DynamicsBandState>>,
838    #[doc(hidden)]
839    pub __source_breaking: fidl::marker::SourceBreaking,
840}
841
842impl fidl::Persistable for DynamicsElementState {}
843
844#[derive(Clone, Debug, Default, PartialEq)]
845pub struct Element {
846    /// Unique ID for this element. The scope of this id is only within the `SignalProcessing`
847    /// protocol lifespan, i.e. until the channel associated with the protocol is closed.
848    ///
849    /// Required.
850    pub id: Option<u64>,
851    /// Processing element type.
852    ///
853    /// Required.
854    pub type_: Option<ElementType>,
855    /// Type-specific parameters for the processing element.
856    ///
857    /// Required for `ElementType`s DAI_INTERCONNECT, DYNAMICS, EQUALIZER, GAIN, VENDOR_SPECIFIC.
858    /// Invalid if specified for elements of type AUTOMATIC_GAIN_CONTROL, AUTOMATIC_GAIN_LIMITER,
859    ///         CONNECTION_POINT, DELAY, MUTE, RING_BUFFER or SAMPLE_RATE_CONVERSION.
860    pub type_specific: Option<TypeSpecificElement>,
861    /// Can the processing element be disabled via `SetElementState`.
862    ///
863    /// # Deprecation
864    ///
865    /// Use `can_bypass` instead.
866    pub can_disable: Option<bool>,
867    /// If included, a textual description of the processing element.
868    ///
869    /// Optional. If present, must not be empty.
870    pub description: Option<String>,
871    /// If true, the processing element can be stopped via `SetElementState`.
872    /// If not included or false, the processing element is always started.
873    ///
874    /// Optional.
875    pub can_stop: Option<bool>,
876    /// If true, the processing element can be bypassed via `SetElementState`.
877    /// If not included or false, the processing element cannot be bypassed.
878    ///
879    /// Optional.
880    pub can_bypass: Option<bool>,
881    #[doc(hidden)]
882    pub __source_breaking: fidl::marker::SourceBreaking,
883}
884
885impl fidl::Persistable for Element {}
886
887/// The current state of an element, as returned from the driver. Note that this table contains
888/// fields that are not present in `SettableElementState`, since they cannot be changed by clients.
889#[derive(Clone, Debug, Default, PartialEq)]
890pub struct ElementState {
891    /// Type-specific state parameters for the processing element.
892    ///
893    /// If this processing element is disabled and its type-specific state is provided, then the
894    /// type-specific state is only informational (e.g. the state of a stopped element, if it were
895    /// to be re-started without also providing additional superceding state information).
896    ///
897    /// Required for DAI_INTERCONNECT, DYNAMICS, EQUALIZER, GAIN and VENDOR_SPECIFIC elements.
898    /// Invalid if specified for elements of type AUTOMATIC_GAIN_CONTROL, AUTOMATIC_GAIN_LIMITER,
899    ///         CONNECTION_POINT, DELAY, MUTE, RING_BUFFER or SAMPLE_RATE_CONVERSION.
900    pub type_specific: Option<TypeSpecificElementState>,
901    /// Enable/disable state for the processing element.
902    ///
903    /// # Deprecation
904    ///
905    /// Use `bypassed` instead.
906    pub enabled: Option<bool>,
907    /// How much latency this element adds, if enabled.
908    ///
909    /// # Deprecation
910    ///
911    /// Use `processing_delay` instead.
912    pub latency: Option<Latency>,
913    /// If included, an opaque object of octets for conveying vendor-specific information from the
914    /// driver to `SignalProcessing` clients.
915    ///
916    /// Optional (permitted even if the element's type is not VENDOR_SPECIFIC).
917    pub vendor_specific_data: Option<Vec<u8>>,
918    /// The start/stop state for this processing element.
919    /// If true, the hardware associated with the element is started. If false, it is stopped.
920    ///
921    /// If the corresponding `Element` omitted `can_stop` or set it to `false`, then this field
922    /// can never be `false`.
923    ///
924    /// A stopped processing element does not provide its abstracted functionality.
925    /// No audio data flows through stopped elements.
926    ///
927    /// Required.
928    pub started: Option<bool>,
929    /// The bypass state for this processing element.
930    /// If true, the hardware associated with the element is bypassed. If false or missing, the
931    /// associated hardware is not bypassed.
932    ///
933    /// By default, processing elements are not bypassed.
934    /// If the corresponding `Element` omitted `can_bypass` or set it to `false`, then this field
935    /// can never be set to `true`.
936    ///
937    /// A bypassed element does not affect the flow of audio through the topology.
938    /// Audio flows through a bypassed element, unchanged.
939    ///
940    /// Optional.
941    pub bypassed: Option<bool>,
942    /// If included, the driver's best estimate of the amount of time it takes the element's
943    /// hardware to enter a fully operational mode after `started` has changed from false to true.
944    /// Hardware may require some duration to reach a fully operational mode after changing its
945    /// power state, for example.
946    ///
947    /// If `turn_on_delay` is not taken into account, then an audio stream's initial frames might
948    /// be lost while audio elements are powering up.
949    /// If not included, `turn_on_delay` is unknown.
950    ///
951    /// Optional. If specified, must be non-negative.
952    pub turn_on_delay: Option<i64>,
953    /// If included, the driver's best estimate of the amount of time it takes the element's
954    /// hardware to enter a fully disabled mode after `started` has changed from true to false.
955    /// Hardware may require some duration to get into a fully stopped state after a change in
956    /// power state, for example.
957    ///
958    /// If `turn_off_delay` is not taken into account, more frames will be emitted/captured than a
959    /// client might expect, while audio elements are powering down.
960    /// If not included, `turn_off_delay` is unknown.
961    ///
962    /// Optional. If specified, must be non-negative.
963    pub turn_off_delay: Option<i64>,
964    /// If included, the driver's best estimate of the delay added by this processing element,
965    /// as it is currently configured  (including `bypassed` state).
966    ///
967    /// This value should be taken into account by timing-sensitive clients, when determining the
968    /// requirements for (playback) minimum lead time and minimum capture delay.
969    ///
970    /// For an element of type `RING_BUFFER`, this delay should not include the inherent delay
971    /// added by the temporary buffering needed to copy data in and out of a ring buffer, which
972    /// is contained in the `RingBufferProperties` field `driver_transfer_bytes`.
973    ///
974    /// Optional. If specified, must be non-negative.
975    pub processing_delay: Option<i64>,
976    #[doc(hidden)]
977    pub __source_breaking: fidl::marker::SourceBreaking,
978}
979
980impl fidl::Persistable for ElementState {}
981
982/// Parameters for an `Element` with `type` equal to `ENDPOINT`.
983///
984/// # Deprecation
985///
986/// Use `DaiInterconnect` and `ElementType` `DAI_INTERCONNECT` instead.
987#[derive(Clone, Debug, Default, PartialEq)]
988pub struct Endpoint {
989    /// Specifies what the endpoint represents.
990    ///
991    /// Required.
992    pub type_: Option<EndpointType>,
993    /// Plug Detect Capabilities.
994    /// Required.
995    pub plug_detect_capabilities: Option<PlugDetectCapabilities>,
996    #[doc(hidden)]
997    pub __source_breaking: fidl::marker::SourceBreaking,
998}
999
1000impl fidl::Persistable for Endpoint {}
1001
1002/// State for an `Element` with `type` equal to `ENDPOINT`.
1003///
1004/// # Deprecation
1005///
1006/// Use `DaiInterconnectElementState` and `ElementType` `DAI_INTERCONNECT` instead.
1007#[derive(Clone, Debug, Default, PartialEq)]
1008pub struct EndpointElementState {
1009    /// If included the plug detect state for this endpoint.
1010    ///
1011    /// Required for servers.
1012    pub plug_state: Option<PlugState>,
1013    #[doc(hidden)]
1014    pub __source_breaking: fidl::marker::SourceBreaking,
1015}
1016
1017impl fidl::Persistable for EndpointElementState {}
1018
1019/// Parameters for a `Element` with `type` equal to `EQUALIZER`.
1020#[derive(Clone, Debug, Default, PartialEq)]
1021pub struct Equalizer {
1022    /// Equalizers in this protocol are built by a number of bands, each specifying a number of
1023    /// parameters here and in `EqualizerElementState` that can be changed with `SetElementState`.
1024    /// The number of elements of the `bands` vector determines the number of bands
1025    /// supported by this processing element.
1026    ///
1027    /// Required. Must contain at least one entry.
1028    pub bands: Option<Vec<EqualizerBand>>,
1029    /// The controls supported by this equalizer (i.e. that can be changed via `SetElementState`).
1030    ///
1031    /// Optional.
1032    pub supported_controls: Option<EqualizerSupportedControls>,
1033    /// If included and true, individual bands can be disabled via `SetElementState`.
1034    /// If not included or false, bands are always enabled.
1035    /// For EQ bands to be functional, the enclosing equalizer processing element must also be
1036    /// started and not bypassed.
1037    ///
1038    /// Optional.
1039    pub can_disable_bands: Option<bool>,
1040    /// Minimum frequency for all bands, in Hz.
1041    ///
1042    /// Required.
1043    pub min_frequency: Option<u32>,
1044    /// Maximum frequency for all bands, in Hz.
1045    ///
1046    /// Required.
1047    pub max_frequency: Option<u32>,
1048    /// Maximum quality factor, usually denoted by "Q", for all bands.
1049    /// This indicates how narrow the frequency transition is. Higher Q values imply narrower
1050    /// notches/peaks and steeper cuts/shelves. Must be positive.
1051    ///
1052    /// Optional. If specified, must be finite.
1053    pub max_q: Option<f32>,
1054    /// Minimum gain in dB.
1055    ///
1056    /// Required, if `supported_controls` is present and includes `SUPPORTS_TYPE_PEAK`,
1057    /// `SUPPORTS_TYPE_LOW_SHELF` or `SUPPORTS_TYPE_HIGH_SHELF`. Must be finite.
1058    /// Disallowed, otherwise.
1059    pub min_gain_db: Option<f32>,
1060    /// Maximum gain in dB.
1061    ///
1062    /// Required, if `supported_controls` is present and includes `SUPPORTS_TYPE_PEAK`,
1063    /// `SUPPORTS_TYPE_LOW_SHELF` or `SUPPORTS_TYPE_HIGH_SHELF`. Must be finite.
1064    /// Disallowed, otherwise.
1065    pub max_gain_db: Option<f32>,
1066    #[doc(hidden)]
1067    pub __source_breaking: fidl::marker::SourceBreaking,
1068}
1069
1070impl fidl::Persistable for Equalizer {}
1071
1072/// Parameters for an equalizer Band.
1073#[derive(Clone, Debug, Default, PartialEq)]
1074pub struct EqualizerBand {
1075    /// Unique ID for this band. Must only be unique within the corresponding `Element`.
1076    /// Only valid until the channel associated with the `SignalProcessing` protocol is closed.
1077    ///
1078    /// Required.
1079    pub id: Option<u64>,
1080    #[doc(hidden)]
1081    pub __source_breaking: fidl::marker::SourceBreaking,
1082}
1083
1084impl fidl::Persistable for EqualizerBand {}
1085
1086/// State for a single band within a `Element` with `type` equal to `EQUALIZER`.
1087#[derive(Clone, Debug, Default, PartialEq)]
1088pub struct EqualizerBandState {
1089    /// Unique ID for the band. Must match one of the `id`s specified in `Equalizer` `bands`.
1090    ///
1091    /// Required.
1092    pub id: Option<u64>,
1093    /// Type of band.
1094    ///
1095    /// Required.
1096    /// If this is a call to `SetElementState`, then the corresponding `SUPPORTS_TYPE_...`
1097    /// `EqualizerSupportedControls` bit for `type` must be set in `Element.supported_controls`.
1098    pub type_: Option<EqualizerBandType>,
1099    /// Center frequency for the band.
1100    ///
1101    /// Required.
1102    /// If this is a call to `SetElementState` and represents a change in this band's frequency,
1103    /// then `CAN_CONTROL_FREQUENCY` must be set in `Element.supported_controls`.
1104    pub frequency: Option<u32>,
1105    /// Quality factor, usually denoted as "Q".
1106    /// Indicates how narrow the frequency transition is. Higher Q values imply narrower
1107    /// notches/peaks and steeper cuts/shelves. Must be positive.
1108    ///
1109    /// Optional.
1110    /// If used in `SetElementState` and represents a change in this band's q, then `CAN_CONTROL_Q`
1111    /// must be set in  `Element.supported_controls`. Must be finite.
1112    pub q: Option<f32>,
1113    /// Gain in dB.
1114    ///
1115    /// Required, for `EqualizerBandType` of `PEAK`, `LOW_SHELF` and `HIGH_SHELF`. Must be finite.
1116    /// Disallowed, for `EqualizerBandType` of `NOTCH`, `LOW_CUT` and `HIGH_CUT`.
1117    pub gain_db: Option<f32>,
1118    /// Enable/disable the band.
1119    /// If disabled, audio still flows through the equalizer but this band has no effect.
1120    ///
1121    /// If absent in the return value from `WatchElementState`, the band is enabled.
1122    /// If omitted in a `SetElementState` call, the band's enable/disable state is unchanged.
1123    ///
1124    /// Bypassing the entire enclosing processing element (by setting `ElementState.bypassed` to
1125    /// true) does not change this field's value, although for an equalizer band to be functional,
1126    /// its enclosing equalizer processing element must be both started and not bypassed.
1127    ///
1128    /// Optional.
1129    pub enabled: Option<bool>,
1130    #[doc(hidden)]
1131    pub __source_breaking: fidl::marker::SourceBreaking,
1132}
1133
1134impl fidl::Persistable for EqualizerBandState {}
1135
1136/// State for a `Element` with `type` equal to `EQUALIZER`.
1137#[derive(Clone, Debug, Default, PartialEq)]
1138pub struct EqualizerElementState {
1139    /// The states of the bands in this equalizer processing element.
1140    ///
1141    /// # Deprecation
1142    ///
1143    /// Use `band_states` instead.
1144    pub bands_state: Option<Vec<EqualizerBandState>>,
1145    /// The states of the bands in this equalizer processing element.
1146    ///
1147    /// The number of elements of the `band_states` vector must be equal or smaller than the
1148    /// number of elements of the `bands` returned in returned in the corresponding
1149    /// `Equalizer`. `band_states` must have at least one element.
1150    /// The bands controlled by `band_states` are determined by each `band.id`.
1151    ///
1152    /// Required. Must contain at least one entry.
1153    pub band_states: Option<Vec<EqualizerBandState>>,
1154    #[doc(hidden)]
1155    pub __source_breaking: fidl::marker::SourceBreaking,
1156}
1157
1158impl fidl::Persistable for EqualizerElementState {}
1159
1160/// Parameters for an `Element` with `type` equal to `GAIN`.
1161#[derive(Clone, Debug, Default, PartialEq)]
1162pub struct Gain {
1163    /// Specifies what the numbers for gain represent, e.g. a percentage.
1164    ///
1165    /// Required.
1166    pub type_: Option<GainType>,
1167    /// If included, the gain is applied in the specified `GainDomain`.
1168    /// If not included, the gain domain is unspecified.
1169    ///
1170    /// Optional.
1171    pub domain: Option<GainDomain>,
1172    /// Minimum gain in `GainType` format.
1173    ///
1174    /// Required. Must be finite.
1175    pub min_gain: Option<f32>,
1176    /// Maximum gain in `GainType` format.
1177    ///
1178    /// Required. Must be finite.
1179    pub max_gain: Option<f32>,
1180    /// Minimum gain step in `GainType` format, this value must not be negative, but may be zero to
1181    /// convey an effectively continuous range of values. Must not exceed `max_gain` - `min_gain`.
1182    /// The actual gain set may be queried by the client with a `WatchElementState` call.
1183    ///
1184    /// Required. Must be finite.
1185    pub min_gain_step: Option<f32>,
1186    #[doc(hidden)]
1187    pub __source_breaking: fidl::marker::SourceBreaking,
1188}
1189
1190impl fidl::Persistable for Gain {}
1191
1192/// State for an `Element` with `type` equal to `GAIN`.
1193#[derive(Clone, Debug, Default, PartialEq)]
1194pub struct GainElementState {
1195    /// Current gain in `GainType` format.
1196    ///
1197    /// Required. Must be finite.
1198    pub gain: Option<f32>,
1199    #[doc(hidden)]
1200    pub __source_breaking: fidl::marker::SourceBreaking,
1201}
1202
1203impl fidl::Persistable for GainElementState {}
1204
1205/// Plug state for the interconnect.
1206/// If the driver reports a `plug_detect_capabilities` equal to HARDWIRED, then the driver should
1207/// respond to `WatchElementState` only the first time it is called for a given interconnect, with
1208/// `plugged` set to true and `plug_state_time` set to time '0'.
1209#[derive(Clone, Debug, Default, PartialEq)]
1210pub struct PlugState {
1211    /// Indicates whether the interconnect is currently plugged in.
1212    ///
1213    /// Required
1214    pub plugged: Option<bool>,
1215    /// Indicates when the current `plugged` state was set, using `ZX_CLOCK_MONOTONIC`.
1216    /// Cannot be negative.
1217    ///
1218    /// Required.
1219    pub plug_state_time: Option<i64>,
1220    #[doc(hidden)]
1221    pub __source_breaking: fidl::marker::SourceBreaking,
1222}
1223
1224impl fidl::Persistable for PlugState {}
1225
1226/// Processing element state that can be set by clients.
1227#[derive(Clone, Debug, Default, PartialEq)]
1228pub struct SettableElementState {
1229    /// Type-specific element-state parameters that can be set by clients.
1230    ///
1231    /// If an element is disabled, changes in this field (and all others in SettableElementState)
1232    /// are purely informational and take no effect until the element is enabled.
1233    ///
1234    /// If not set, then the element's previous `type_specific` state is preserved.
1235    ///
1236    /// Optional for DYNAMICS, EQUALIZER, GAIN and VENDOR_SPECIFIC types.
1237    /// Invalid if specified for AUTOMATIC_GAIN_CONTROL, AUTOMATIC_GAIN_LIMITER, CONNECTION_POINT,
1238    ///         DAI_INTERCONNECT, DELAY, MUTE, RING_BUFFER or SAMPLE_RATE_CONVERSION elements.
1239    pub type_specific: Option<SettableTypeSpecificElementState>,
1240    /// If included, an opaque object of octets for conveying vendor-specific information from
1241    /// a client to the audio driver.
1242    /// This can be used with any element type, not just VENDOR_SPECIFIC elements.
1243    ///
1244    /// Optional.
1245    pub vendor_specific_data: Option<Vec<u8>>,
1246    /// Whether to start or stop this processing element.
1247    /// A stopped processing element does not provide its abstracted functionality.
1248    /// Specifically, no audio data flows through a stopped element.
1249    ///
1250    /// If the corresponding `Element` returned `can_stop` equals to `false`, then this field must
1251    /// not be set to `false` -- `SetElementState` will return ZX_ERR_INVALID_ARGS in that case.
1252    /// If not set, then the element's previous `started` state will be unchanged.
1253    ///
1254    /// Optional.
1255    pub started: Option<bool>,
1256    /// Whether to bypass this processing element.
1257    /// A bypassed element does not affect the flow of audio through the topology.
1258    /// Specifically, audio flows through a bypassed element, without change.
1259    ///
1260    /// If the corresponding `Element` omits `can_bypass` or sets it to `false`, then this field
1261    /// must not be set to `true`. If this occurs, `SetElementState` will fail and return error
1262    /// `ZX_ERR_INVALID_ARGS`.
1263    /// If not set, then the element's previous `bypassed` state will be unchanged.
1264    ///
1265    /// Optional.
1266    pub bypassed: Option<bool>,
1267    #[doc(hidden)]
1268    pub __source_breaking: fidl::marker::SourceBreaking,
1269}
1270
1271impl fidl::Persistable for SettableElementState {}
1272
1273/// A `Topology` specifies how processing elements are arranged within the hardware.
1274#[derive(Clone, Debug, Default, PartialEq)]
1275pub struct Topology {
1276    /// Unique ID for this topology. The scope of this id is only within the `SignalProcessing`
1277    /// protocol lifespan, i.e. until the channel associated with the protocol is closed.
1278    ///
1279    /// Required.
1280    pub id: Option<u64>,
1281    /// Vector of processing elements edge pairs that specify connections between elements.
1282    /// Processing elements are connected by edge pairs, to form multi-element pipelines.
1283    /// A Topology can contain more than one distinct pipeline: the Topology need not be a single
1284    /// interconnected sequence (e.g. Topology  A->B->C  D->E->F  is valid).
1285    ///
1286    /// To define multiple possible configurations where one possibility can be selected by the
1287    /// client, return multiple `Topology` entries in `GetTopologies`.
1288    ///
1289    /// If a device does support multiple Topology entries, then each specific Topology is not
1290    /// required to include every Element. However, every element must be included in at least one
1291    /// Topology.
1292    ///
1293    /// Within each Topology, every sequence of connected elements must begin with an element
1294    /// of type DAI_INTERCONNECT or RING_BUFFER, and must end with an element of type
1295    /// DAI_INTERCONNECT or RING_BUFFER.
1296    ///
1297    /// An DAI_INTERCONNECT element is permitted to be the endpoint for an element sequence, but a
1298    /// RING_BUFFER is required to be one. If a certain RING_BUFFER element is listed in an EdgeList
1299    /// entry as a `processing_element_id_from`, then within that Topology it must not be listed in
1300    /// any EdgeList entry as a `processing_element_id_to` (and vice versa).
1301    ///
1302    /// Required. Must contain at least one entry.
1303    pub processing_elements_edge_pairs: Option<Vec<EdgePair>>,
1304    #[doc(hidden)]
1305    pub __source_breaking: fidl::marker::SourceBreaking,
1306}
1307
1308impl fidl::Persistable for Topology {}
1309
1310/// Parameters for an `Element` with `type` equal to `VENDOR_SPECIFIC`.
1311#[derive(Clone, Debug, Default, PartialEq)]
1312pub struct VendorSpecific {
1313    #[doc(hidden)]
1314    pub __source_breaking: fidl::marker::SourceBreaking,
1315}
1316
1317impl fidl::Persistable for VendorSpecific {}
1318
1319/// State for an `Element` with `type` equal to `VENDOR_SPECIFIC`.
1320#[derive(Clone, Debug, Default, PartialEq)]
1321pub struct VendorSpecificState {
1322    #[doc(hidden)]
1323    pub __source_breaking: fidl::marker::SourceBreaking,
1324}
1325
1326impl fidl::Persistable for VendorSpecificState {}
1327
1328///
1329/// # Deprecation
1330///
1331/// Use `processing_delay` instead.
1332#[derive(Clone, Debug)]
1333pub enum Latency {
1334    /// Latency added to the pipeline as a zx.Duration.
1335    LatencyTime(i64),
1336    /// Latency added to the pipeline as a number of frames.
1337    LatencyFrames(u32),
1338    #[doc(hidden)]
1339    __SourceBreaking { unknown_ordinal: u64 },
1340}
1341
1342/// Pattern that matches an unknown `Latency` member.
1343#[macro_export]
1344macro_rules! LatencyUnknown {
1345    () => {
1346        _
1347    };
1348}
1349
1350// Custom PartialEq so that unknown variants are not equal to themselves.
1351impl PartialEq for Latency {
1352    fn eq(&self, other: &Self) -> bool {
1353        match (self, other) {
1354            (Self::LatencyTime(x), Self::LatencyTime(y)) => *x == *y,
1355            (Self::LatencyFrames(x), Self::LatencyFrames(y)) => *x == *y,
1356            _ => false,
1357        }
1358    }
1359}
1360
1361impl Latency {
1362    #[inline]
1363    pub fn ordinal(&self) -> u64 {
1364        match *self {
1365            Self::LatencyTime(_) => 1,
1366            Self::LatencyFrames(_) => 2,
1367            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1368        }
1369    }
1370
1371    #[inline]
1372    pub fn unknown_variant_for_testing() -> Self {
1373        Self::__SourceBreaking { unknown_ordinal: 0 }
1374    }
1375
1376    #[inline]
1377    pub fn is_unknown(&self) -> bool {
1378        match self {
1379            Self::__SourceBreaking { .. } => true,
1380            _ => false,
1381        }
1382    }
1383}
1384
1385impl fidl::Persistable for Latency {}
1386
1387/// Type-specific processing element state that can be set by clients.
1388/// The type of processing element control is defined by the type of parameters provided in this
1389/// union. This type-specific variant must match the `ElementType` entry in the corresponding
1390/// `Element`.
1391#[derive(Clone, Debug)]
1392pub enum SettableTypeSpecificElementState {
1393    VendorSpecific(VendorSpecificState),
1394    Gain(GainElementState),
1395    Equalizer(EqualizerElementState),
1396    Dynamics(DynamicsElementState),
1397    #[doc(hidden)]
1398    __SourceBreaking {
1399        unknown_ordinal: u64,
1400    },
1401}
1402
1403/// Pattern that matches an unknown `SettableTypeSpecificElementState` member.
1404#[macro_export]
1405macro_rules! SettableTypeSpecificElementStateUnknown {
1406    () => {
1407        _
1408    };
1409}
1410
1411// Custom PartialEq so that unknown variants are not equal to themselves.
1412impl PartialEq for SettableTypeSpecificElementState {
1413    fn eq(&self, other: &Self) -> bool {
1414        match (self, other) {
1415            (Self::VendorSpecific(x), Self::VendorSpecific(y)) => *x == *y,
1416            (Self::Gain(x), Self::Gain(y)) => *x == *y,
1417            (Self::Equalizer(x), Self::Equalizer(y)) => *x == *y,
1418            (Self::Dynamics(x), Self::Dynamics(y)) => *x == *y,
1419            _ => false,
1420        }
1421    }
1422}
1423
1424impl SettableTypeSpecificElementState {
1425    #[inline]
1426    pub fn ordinal(&self) -> u64 {
1427        match *self {
1428            Self::VendorSpecific(_) => 1,
1429            Self::Gain(_) => 2,
1430            Self::Equalizer(_) => 3,
1431            Self::Dynamics(_) => 4,
1432            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1433        }
1434    }
1435
1436    #[inline]
1437    pub fn unknown_variant_for_testing() -> Self {
1438        Self::__SourceBreaking { unknown_ordinal: 0 }
1439    }
1440
1441    #[inline]
1442    pub fn is_unknown(&self) -> bool {
1443        match self {
1444            Self::__SourceBreaking { .. } => true,
1445            _ => false,
1446        }
1447    }
1448}
1449
1450impl fidl::Persistable for SettableTypeSpecificElementState {}
1451
1452/// Type-specific Parameters for an `Element`.
1453#[derive(Clone, Debug)]
1454pub enum TypeSpecificElement {
1455    VendorSpecific(VendorSpecific),
1456    Gain(Gain),
1457    Equalizer(Equalizer),
1458    Dynamics(Dynamics),
1459    Endpoint(Endpoint),
1460    DaiInterconnect(DaiInterconnect),
1461    #[doc(hidden)]
1462    __SourceBreaking {
1463        unknown_ordinal: u64,
1464    },
1465}
1466
1467/// Pattern that matches an unknown `TypeSpecificElement` member.
1468#[macro_export]
1469macro_rules! TypeSpecificElementUnknown {
1470    () => {
1471        _
1472    };
1473}
1474
1475// Custom PartialEq so that unknown variants are not equal to themselves.
1476impl PartialEq for TypeSpecificElement {
1477    fn eq(&self, other: &Self) -> bool {
1478        match (self, other) {
1479            (Self::VendorSpecific(x), Self::VendorSpecific(y)) => *x == *y,
1480            (Self::Gain(x), Self::Gain(y)) => *x == *y,
1481            (Self::Equalizer(x), Self::Equalizer(y)) => *x == *y,
1482            (Self::Dynamics(x), Self::Dynamics(y)) => *x == *y,
1483            (Self::Endpoint(x), Self::Endpoint(y)) => *x == *y,
1484            (Self::DaiInterconnect(x), Self::DaiInterconnect(y)) => *x == *y,
1485            _ => false,
1486        }
1487    }
1488}
1489
1490impl TypeSpecificElement {
1491    #[inline]
1492    pub fn ordinal(&self) -> u64 {
1493        match *self {
1494            Self::VendorSpecific(_) => 1,
1495            Self::Gain(_) => 2,
1496            Self::Equalizer(_) => 3,
1497            Self::Dynamics(_) => 4,
1498            Self::Endpoint(_) => 5,
1499            Self::DaiInterconnect(_) => 6,
1500            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1501        }
1502    }
1503
1504    #[inline]
1505    pub fn unknown_variant_for_testing() -> Self {
1506        Self::__SourceBreaking { unknown_ordinal: 0 }
1507    }
1508
1509    #[inline]
1510    pub fn is_unknown(&self) -> bool {
1511        match self {
1512            Self::__SourceBreaking { .. } => true,
1513            _ => false,
1514        }
1515    }
1516}
1517
1518impl fidl::Persistable for TypeSpecificElement {}
1519
1520/// Type-specific processing element state, as returned from the driver.
1521/// The type of processing element control is defined by the type of parameters provided in this
1522/// union. This type-specific variant must match the `ElementType` entry in the corresponding
1523/// `Element`.
1524#[derive(Clone, Debug)]
1525pub enum TypeSpecificElementState {
1526    VendorSpecific(VendorSpecificState),
1527    Gain(GainElementState),
1528    Equalizer(EqualizerElementState),
1529    Dynamics(DynamicsElementState),
1530    Endpoint(EndpointElementState),
1531    DaiInterconnect(DaiInterconnectElementState),
1532    #[doc(hidden)]
1533    __SourceBreaking {
1534        unknown_ordinal: u64,
1535    },
1536}
1537
1538/// Pattern that matches an unknown `TypeSpecificElementState` member.
1539#[macro_export]
1540macro_rules! TypeSpecificElementStateUnknown {
1541    () => {
1542        _
1543    };
1544}
1545
1546// Custom PartialEq so that unknown variants are not equal to themselves.
1547impl PartialEq for TypeSpecificElementState {
1548    fn eq(&self, other: &Self) -> bool {
1549        match (self, other) {
1550            (Self::VendorSpecific(x), Self::VendorSpecific(y)) => *x == *y,
1551            (Self::Gain(x), Self::Gain(y)) => *x == *y,
1552            (Self::Equalizer(x), Self::Equalizer(y)) => *x == *y,
1553            (Self::Dynamics(x), Self::Dynamics(y)) => *x == *y,
1554            (Self::Endpoint(x), Self::Endpoint(y)) => *x == *y,
1555            (Self::DaiInterconnect(x), Self::DaiInterconnect(y)) => *x == *y,
1556            _ => false,
1557        }
1558    }
1559}
1560
1561impl TypeSpecificElementState {
1562    #[inline]
1563    pub fn ordinal(&self) -> u64 {
1564        match *self {
1565            Self::VendorSpecific(_) => 1,
1566            Self::Gain(_) => 2,
1567            Self::Equalizer(_) => 3,
1568            Self::Dynamics(_) => 4,
1569            Self::Endpoint(_) => 5,
1570            Self::DaiInterconnect(_) => 6,
1571            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1572        }
1573    }
1574
1575    #[inline]
1576    pub fn unknown_variant_for_testing() -> Self {
1577        Self::__SourceBreaking { unknown_ordinal: 0 }
1578    }
1579
1580    #[inline]
1581    pub fn is_unknown(&self) -> bool {
1582        match self {
1583            Self::__SourceBreaking { .. } => true,
1584            _ => false,
1585        }
1586    }
1587}
1588
1589impl fidl::Persistable for TypeSpecificElementState {}
1590
1591pub mod connector_ordinals {
1592    pub const SIGNAL_PROCESSING_CONNECT: u64 = 0xa81907ce6066295;
1593}
1594
1595pub mod reader_ordinals {
1596    pub const GET_ELEMENTS: u64 = 0x1b14ff4adf5dc6f8;
1597    pub const WATCH_ELEMENT_STATE: u64 = 0x524da8772a69056f;
1598    pub const GET_TOPOLOGIES: u64 = 0x73ffb73af24d30b6;
1599    pub const WATCH_TOPOLOGY: u64 = 0x66d172acdb36a729;
1600}
1601
1602pub mod signal_processing_ordinals {
1603    pub const GET_ELEMENTS: u64 = 0x1b14ff4adf5dc6f8;
1604    pub const WATCH_ELEMENT_STATE: u64 = 0x524da8772a69056f;
1605    pub const GET_TOPOLOGIES: u64 = 0x73ffb73af24d30b6;
1606    pub const WATCH_TOPOLOGY: u64 = 0x66d172acdb36a729;
1607    pub const SET_TOPOLOGY: u64 = 0x1d9a7f9b8fee790c;
1608    pub const SET_ELEMENT_STATE: u64 = 0x38c3b2d4bae698f4;
1609}
1610
1611mod internal {
1612    use super::*;
1613    unsafe impl fidl::encoding::TypeMarker for DynamicsSupportedControls {
1614        type Owned = Self;
1615
1616        #[inline(always)]
1617        fn inline_align(_context: fidl::encoding::Context) -> usize {
1618            8
1619        }
1620
1621        #[inline(always)]
1622        fn inline_size(_context: fidl::encoding::Context) -> usize {
1623            8
1624        }
1625    }
1626
1627    impl fidl::encoding::ValueTypeMarker for DynamicsSupportedControls {
1628        type Borrowed<'a> = Self;
1629        #[inline(always)]
1630        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1631            *value
1632        }
1633    }
1634
1635    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1636        for DynamicsSupportedControls
1637    {
1638        #[inline]
1639        unsafe fn encode(
1640            self,
1641            encoder: &mut fidl::encoding::Encoder<'_, D>,
1642            offset: usize,
1643            _depth: fidl::encoding::Depth,
1644        ) -> fidl::Result<()> {
1645            encoder.debug_check_bounds::<Self>(offset);
1646            encoder.write_num(self.bits(), offset);
1647            Ok(())
1648        }
1649    }
1650
1651    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1652        for DynamicsSupportedControls
1653    {
1654        #[inline(always)]
1655        fn new_empty() -> Self {
1656            Self::empty()
1657        }
1658
1659        #[inline]
1660        unsafe fn decode(
1661            &mut self,
1662            decoder: &mut fidl::encoding::Decoder<'_, D>,
1663            offset: usize,
1664            _depth: fidl::encoding::Depth,
1665        ) -> fidl::Result<()> {
1666            decoder.debug_check_bounds::<Self>(offset);
1667            let prim = decoder.read_num::<u64>(offset);
1668            *self = Self::from_bits_allow_unknown(prim);
1669            Ok(())
1670        }
1671    }
1672    unsafe impl fidl::encoding::TypeMarker for EqualizerSupportedControls {
1673        type Owned = Self;
1674
1675        #[inline(always)]
1676        fn inline_align(_context: fidl::encoding::Context) -> usize {
1677            8
1678        }
1679
1680        #[inline(always)]
1681        fn inline_size(_context: fidl::encoding::Context) -> usize {
1682            8
1683        }
1684    }
1685
1686    impl fidl::encoding::ValueTypeMarker for EqualizerSupportedControls {
1687        type Borrowed<'a> = Self;
1688        #[inline(always)]
1689        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1690            *value
1691        }
1692    }
1693
1694    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1695        for EqualizerSupportedControls
1696    {
1697        #[inline]
1698        unsafe fn encode(
1699            self,
1700            encoder: &mut fidl::encoding::Encoder<'_, D>,
1701            offset: usize,
1702            _depth: fidl::encoding::Depth,
1703        ) -> fidl::Result<()> {
1704            encoder.debug_check_bounds::<Self>(offset);
1705            encoder.write_num(self.bits(), offset);
1706            Ok(())
1707        }
1708    }
1709
1710    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1711        for EqualizerSupportedControls
1712    {
1713        #[inline(always)]
1714        fn new_empty() -> Self {
1715            Self::empty()
1716        }
1717
1718        #[inline]
1719        unsafe fn decode(
1720            &mut self,
1721            decoder: &mut fidl::encoding::Decoder<'_, D>,
1722            offset: usize,
1723            _depth: fidl::encoding::Depth,
1724        ) -> fidl::Result<()> {
1725            decoder.debug_check_bounds::<Self>(offset);
1726            let prim = decoder.read_num::<u64>(offset);
1727            *self = Self::from_bits_allow_unknown(prim);
1728            Ok(())
1729        }
1730    }
1731    unsafe impl fidl::encoding::TypeMarker for ElementType {
1732        type Owned = Self;
1733
1734        #[inline(always)]
1735        fn inline_align(_context: fidl::encoding::Context) -> usize {
1736            std::mem::align_of::<u32>()
1737        }
1738
1739        #[inline(always)]
1740        fn inline_size(_context: fidl::encoding::Context) -> usize {
1741            std::mem::size_of::<u32>()
1742        }
1743
1744        #[inline(always)]
1745        fn encode_is_copy() -> bool {
1746            false
1747        }
1748
1749        #[inline(always)]
1750        fn decode_is_copy() -> bool {
1751            false
1752        }
1753    }
1754
1755    impl fidl::encoding::ValueTypeMarker for ElementType {
1756        type Borrowed<'a> = Self;
1757        #[inline(always)]
1758        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1759            *value
1760        }
1761    }
1762
1763    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ElementType {
1764        #[inline]
1765        unsafe fn encode(
1766            self,
1767            encoder: &mut fidl::encoding::Encoder<'_, D>,
1768            offset: usize,
1769            _depth: fidl::encoding::Depth,
1770        ) -> fidl::Result<()> {
1771            encoder.debug_check_bounds::<Self>(offset);
1772            encoder.write_num(self.into_primitive(), offset);
1773            Ok(())
1774        }
1775    }
1776
1777    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ElementType {
1778        #[inline(always)]
1779        fn new_empty() -> Self {
1780            Self::unknown()
1781        }
1782
1783        #[inline]
1784        unsafe fn decode(
1785            &mut self,
1786            decoder: &mut fidl::encoding::Decoder<'_, D>,
1787            offset: usize,
1788            _depth: fidl::encoding::Depth,
1789        ) -> fidl::Result<()> {
1790            decoder.debug_check_bounds::<Self>(offset);
1791            let prim = decoder.read_num::<u32>(offset);
1792
1793            *self = Self::from_primitive_allow_unknown(prim);
1794            Ok(())
1795        }
1796    }
1797    unsafe impl fidl::encoding::TypeMarker for EndpointType {
1798        type Owned = Self;
1799
1800        #[inline(always)]
1801        fn inline_align(_context: fidl::encoding::Context) -> usize {
1802            std::mem::align_of::<u8>()
1803        }
1804
1805        #[inline(always)]
1806        fn inline_size(_context: fidl::encoding::Context) -> usize {
1807            std::mem::size_of::<u8>()
1808        }
1809
1810        #[inline(always)]
1811        fn encode_is_copy() -> bool {
1812            false
1813        }
1814
1815        #[inline(always)]
1816        fn decode_is_copy() -> bool {
1817            false
1818        }
1819    }
1820
1821    impl fidl::encoding::ValueTypeMarker for EndpointType {
1822        type Borrowed<'a> = Self;
1823        #[inline(always)]
1824        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1825            *value
1826        }
1827    }
1828
1829    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for EndpointType {
1830        #[inline]
1831        unsafe fn encode(
1832            self,
1833            encoder: &mut fidl::encoding::Encoder<'_, D>,
1834            offset: usize,
1835            _depth: fidl::encoding::Depth,
1836        ) -> fidl::Result<()> {
1837            encoder.debug_check_bounds::<Self>(offset);
1838            encoder.write_num(self.into_primitive(), offset);
1839            Ok(())
1840        }
1841    }
1842
1843    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EndpointType {
1844        #[inline(always)]
1845        fn new_empty() -> Self {
1846            Self::unknown()
1847        }
1848
1849        #[inline]
1850        unsafe fn decode(
1851            &mut self,
1852            decoder: &mut fidl::encoding::Decoder<'_, D>,
1853            offset: usize,
1854            _depth: fidl::encoding::Depth,
1855        ) -> fidl::Result<()> {
1856            decoder.debug_check_bounds::<Self>(offset);
1857            let prim = decoder.read_num::<u8>(offset);
1858
1859            *self = Self::from_primitive_allow_unknown(prim);
1860            Ok(())
1861        }
1862    }
1863    unsafe impl fidl::encoding::TypeMarker for EqualizerBandType {
1864        type Owned = Self;
1865
1866        #[inline(always)]
1867        fn inline_align(_context: fidl::encoding::Context) -> usize {
1868            std::mem::align_of::<u64>()
1869        }
1870
1871        #[inline(always)]
1872        fn inline_size(_context: fidl::encoding::Context) -> usize {
1873            std::mem::size_of::<u64>()
1874        }
1875
1876        #[inline(always)]
1877        fn encode_is_copy() -> bool {
1878            false
1879        }
1880
1881        #[inline(always)]
1882        fn decode_is_copy() -> bool {
1883            false
1884        }
1885    }
1886
1887    impl fidl::encoding::ValueTypeMarker for EqualizerBandType {
1888        type Borrowed<'a> = Self;
1889        #[inline(always)]
1890        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1891            *value
1892        }
1893    }
1894
1895    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1896        for EqualizerBandType
1897    {
1898        #[inline]
1899        unsafe fn encode(
1900            self,
1901            encoder: &mut fidl::encoding::Encoder<'_, D>,
1902            offset: usize,
1903            _depth: fidl::encoding::Depth,
1904        ) -> fidl::Result<()> {
1905            encoder.debug_check_bounds::<Self>(offset);
1906            encoder.write_num(self.into_primitive(), offset);
1907            Ok(())
1908        }
1909    }
1910
1911    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EqualizerBandType {
1912        #[inline(always)]
1913        fn new_empty() -> Self {
1914            Self::unknown()
1915        }
1916
1917        #[inline]
1918        unsafe fn decode(
1919            &mut self,
1920            decoder: &mut fidl::encoding::Decoder<'_, D>,
1921            offset: usize,
1922            _depth: fidl::encoding::Depth,
1923        ) -> fidl::Result<()> {
1924            decoder.debug_check_bounds::<Self>(offset);
1925            let prim = decoder.read_num::<u64>(offset);
1926
1927            *self = Self::from_primitive_allow_unknown(prim);
1928            Ok(())
1929        }
1930    }
1931    unsafe impl fidl::encoding::TypeMarker for GainDomain {
1932        type Owned = Self;
1933
1934        #[inline(always)]
1935        fn inline_align(_context: fidl::encoding::Context) -> usize {
1936            std::mem::align_of::<u8>()
1937        }
1938
1939        #[inline(always)]
1940        fn inline_size(_context: fidl::encoding::Context) -> usize {
1941            std::mem::size_of::<u8>()
1942        }
1943
1944        #[inline(always)]
1945        fn encode_is_copy() -> bool {
1946            false
1947        }
1948
1949        #[inline(always)]
1950        fn decode_is_copy() -> bool {
1951            false
1952        }
1953    }
1954
1955    impl fidl::encoding::ValueTypeMarker for GainDomain {
1956        type Borrowed<'a> = Self;
1957        #[inline(always)]
1958        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1959            *value
1960        }
1961    }
1962
1963    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for GainDomain {
1964        #[inline]
1965        unsafe fn encode(
1966            self,
1967            encoder: &mut fidl::encoding::Encoder<'_, D>,
1968            offset: usize,
1969            _depth: fidl::encoding::Depth,
1970        ) -> fidl::Result<()> {
1971            encoder.debug_check_bounds::<Self>(offset);
1972            encoder.write_num(self.into_primitive(), offset);
1973            Ok(())
1974        }
1975    }
1976
1977    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GainDomain {
1978        #[inline(always)]
1979        fn new_empty() -> Self {
1980            Self::unknown()
1981        }
1982
1983        #[inline]
1984        unsafe fn decode(
1985            &mut self,
1986            decoder: &mut fidl::encoding::Decoder<'_, D>,
1987            offset: usize,
1988            _depth: fidl::encoding::Depth,
1989        ) -> fidl::Result<()> {
1990            decoder.debug_check_bounds::<Self>(offset);
1991            let prim = decoder.read_num::<u8>(offset);
1992
1993            *self = Self::from_primitive_allow_unknown(prim);
1994            Ok(())
1995        }
1996    }
1997    unsafe impl fidl::encoding::TypeMarker for GainType {
1998        type Owned = Self;
1999
2000        #[inline(always)]
2001        fn inline_align(_context: fidl::encoding::Context) -> usize {
2002            std::mem::align_of::<u8>()
2003        }
2004
2005        #[inline(always)]
2006        fn inline_size(_context: fidl::encoding::Context) -> usize {
2007            std::mem::size_of::<u8>()
2008        }
2009
2010        #[inline(always)]
2011        fn encode_is_copy() -> bool {
2012            true
2013        }
2014
2015        #[inline(always)]
2016        fn decode_is_copy() -> bool {
2017            false
2018        }
2019    }
2020
2021    impl fidl::encoding::ValueTypeMarker for GainType {
2022        type Borrowed<'a> = Self;
2023        #[inline(always)]
2024        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2025            *value
2026        }
2027    }
2028
2029    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for GainType {
2030        #[inline]
2031        unsafe fn encode(
2032            self,
2033            encoder: &mut fidl::encoding::Encoder<'_, D>,
2034            offset: usize,
2035            _depth: fidl::encoding::Depth,
2036        ) -> fidl::Result<()> {
2037            encoder.debug_check_bounds::<Self>(offset);
2038            encoder.write_num(self.into_primitive(), offset);
2039            Ok(())
2040        }
2041    }
2042
2043    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GainType {
2044        #[inline(always)]
2045        fn new_empty() -> Self {
2046            Self::Decibels
2047        }
2048
2049        #[inline]
2050        unsafe fn decode(
2051            &mut self,
2052            decoder: &mut fidl::encoding::Decoder<'_, D>,
2053            offset: usize,
2054            _depth: fidl::encoding::Depth,
2055        ) -> fidl::Result<()> {
2056            decoder.debug_check_bounds::<Self>(offset);
2057            let prim = decoder.read_num::<u8>(offset);
2058
2059            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2060            Ok(())
2061        }
2062    }
2063    unsafe impl fidl::encoding::TypeMarker for LevelType {
2064        type Owned = Self;
2065
2066        #[inline(always)]
2067        fn inline_align(_context: fidl::encoding::Context) -> usize {
2068            std::mem::align_of::<u8>()
2069        }
2070
2071        #[inline(always)]
2072        fn inline_size(_context: fidl::encoding::Context) -> usize {
2073            std::mem::size_of::<u8>()
2074        }
2075
2076        #[inline(always)]
2077        fn encode_is_copy() -> bool {
2078            true
2079        }
2080
2081        #[inline(always)]
2082        fn decode_is_copy() -> bool {
2083            false
2084        }
2085    }
2086
2087    impl fidl::encoding::ValueTypeMarker for LevelType {
2088        type Borrowed<'a> = Self;
2089        #[inline(always)]
2090        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2091            *value
2092        }
2093    }
2094
2095    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for LevelType {
2096        #[inline]
2097        unsafe fn encode(
2098            self,
2099            encoder: &mut fidl::encoding::Encoder<'_, D>,
2100            offset: usize,
2101            _depth: fidl::encoding::Depth,
2102        ) -> fidl::Result<()> {
2103            encoder.debug_check_bounds::<Self>(offset);
2104            encoder.write_num(self.into_primitive(), offset);
2105            Ok(())
2106        }
2107    }
2108
2109    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LevelType {
2110        #[inline(always)]
2111        fn new_empty() -> Self {
2112            Self::Peak
2113        }
2114
2115        #[inline]
2116        unsafe fn decode(
2117            &mut self,
2118            decoder: &mut fidl::encoding::Decoder<'_, D>,
2119            offset: usize,
2120            _depth: fidl::encoding::Depth,
2121        ) -> fidl::Result<()> {
2122            decoder.debug_check_bounds::<Self>(offset);
2123            let prim = decoder.read_num::<u8>(offset);
2124
2125            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2126            Ok(())
2127        }
2128    }
2129    unsafe impl fidl::encoding::TypeMarker for PlugDetectCapabilities {
2130        type Owned = Self;
2131
2132        #[inline(always)]
2133        fn inline_align(_context: fidl::encoding::Context) -> usize {
2134            std::mem::align_of::<u32>()
2135        }
2136
2137        #[inline(always)]
2138        fn inline_size(_context: fidl::encoding::Context) -> usize {
2139            std::mem::size_of::<u32>()
2140        }
2141
2142        #[inline(always)]
2143        fn encode_is_copy() -> bool {
2144            false
2145        }
2146
2147        #[inline(always)]
2148        fn decode_is_copy() -> bool {
2149            false
2150        }
2151    }
2152
2153    impl fidl::encoding::ValueTypeMarker for PlugDetectCapabilities {
2154        type Borrowed<'a> = Self;
2155        #[inline(always)]
2156        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2157            *value
2158        }
2159    }
2160
2161    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2162        for PlugDetectCapabilities
2163    {
2164        #[inline]
2165        unsafe fn encode(
2166            self,
2167            encoder: &mut fidl::encoding::Encoder<'_, D>,
2168            offset: usize,
2169            _depth: fidl::encoding::Depth,
2170        ) -> fidl::Result<()> {
2171            encoder.debug_check_bounds::<Self>(offset);
2172            encoder.write_num(self.into_primitive(), offset);
2173            Ok(())
2174        }
2175    }
2176
2177    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2178        for PlugDetectCapabilities
2179    {
2180        #[inline(always)]
2181        fn new_empty() -> Self {
2182            Self::unknown()
2183        }
2184
2185        #[inline]
2186        unsafe fn decode(
2187            &mut self,
2188            decoder: &mut fidl::encoding::Decoder<'_, D>,
2189            offset: usize,
2190            _depth: fidl::encoding::Depth,
2191        ) -> fidl::Result<()> {
2192            decoder.debug_check_bounds::<Self>(offset);
2193            let prim = decoder.read_num::<u32>(offset);
2194
2195            *self = Self::from_primitive_allow_unknown(prim);
2196            Ok(())
2197        }
2198    }
2199    unsafe impl fidl::encoding::TypeMarker for ThresholdType {
2200        type Owned = Self;
2201
2202        #[inline(always)]
2203        fn inline_align(_context: fidl::encoding::Context) -> usize {
2204            std::mem::align_of::<u8>()
2205        }
2206
2207        #[inline(always)]
2208        fn inline_size(_context: fidl::encoding::Context) -> usize {
2209            std::mem::size_of::<u8>()
2210        }
2211
2212        #[inline(always)]
2213        fn encode_is_copy() -> bool {
2214            true
2215        }
2216
2217        #[inline(always)]
2218        fn decode_is_copy() -> bool {
2219            false
2220        }
2221    }
2222
2223    impl fidl::encoding::ValueTypeMarker for ThresholdType {
2224        type Borrowed<'a> = Self;
2225        #[inline(always)]
2226        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2227            *value
2228        }
2229    }
2230
2231    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ThresholdType {
2232        #[inline]
2233        unsafe fn encode(
2234            self,
2235            encoder: &mut fidl::encoding::Encoder<'_, D>,
2236            offset: usize,
2237            _depth: fidl::encoding::Depth,
2238        ) -> fidl::Result<()> {
2239            encoder.debug_check_bounds::<Self>(offset);
2240            encoder.write_num(self.into_primitive(), offset);
2241            Ok(())
2242        }
2243    }
2244
2245    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ThresholdType {
2246        #[inline(always)]
2247        fn new_empty() -> Self {
2248            Self::Above
2249        }
2250
2251        #[inline]
2252        unsafe fn decode(
2253            &mut self,
2254            decoder: &mut fidl::encoding::Decoder<'_, D>,
2255            offset: usize,
2256            _depth: fidl::encoding::Depth,
2257        ) -> fidl::Result<()> {
2258            decoder.debug_check_bounds::<Self>(offset);
2259            let prim = decoder.read_num::<u8>(offset);
2260
2261            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2262            Ok(())
2263        }
2264    }
2265
2266    impl fidl::encoding::ValueTypeMarker for EdgePair {
2267        type Borrowed<'a> = &'a Self;
2268        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2269            value
2270        }
2271    }
2272
2273    unsafe impl fidl::encoding::TypeMarker for EdgePair {
2274        type Owned = Self;
2275
2276        #[inline(always)]
2277        fn inline_align(_context: fidl::encoding::Context) -> usize {
2278            8
2279        }
2280
2281        #[inline(always)]
2282        fn inline_size(_context: fidl::encoding::Context) -> usize {
2283            16
2284        }
2285        #[inline(always)]
2286        fn encode_is_copy() -> bool {
2287            true
2288        }
2289
2290        #[inline(always)]
2291        fn decode_is_copy() -> bool {
2292            true
2293        }
2294    }
2295
2296    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EdgePair, D> for &EdgePair {
2297        #[inline]
2298        unsafe fn encode(
2299            self,
2300            encoder: &mut fidl::encoding::Encoder<'_, D>,
2301            offset: usize,
2302            _depth: fidl::encoding::Depth,
2303        ) -> fidl::Result<()> {
2304            encoder.debug_check_bounds::<EdgePair>(offset);
2305            unsafe {
2306                // Copy the object into the buffer.
2307                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2308                (buf_ptr as *mut EdgePair).write_unaligned((self as *const EdgePair).read());
2309                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2310                // done second because the memcpy will write garbage to these bytes.
2311            }
2312            Ok(())
2313        }
2314    }
2315    unsafe impl<
2316            D: fidl::encoding::ResourceDialect,
2317            T0: fidl::encoding::Encode<u64, D>,
2318            T1: fidl::encoding::Encode<u64, D>,
2319        > fidl::encoding::Encode<EdgePair, D> for (T0, T1)
2320    {
2321        #[inline]
2322        unsafe fn encode(
2323            self,
2324            encoder: &mut fidl::encoding::Encoder<'_, D>,
2325            offset: usize,
2326            depth: fidl::encoding::Depth,
2327        ) -> fidl::Result<()> {
2328            encoder.debug_check_bounds::<EdgePair>(offset);
2329            // Zero out padding regions. There's no need to apply masks
2330            // because the unmasked parts will be overwritten by fields.
2331            // Write the fields.
2332            self.0.encode(encoder, offset + 0, depth)?;
2333            self.1.encode(encoder, offset + 8, depth)?;
2334            Ok(())
2335        }
2336    }
2337
2338    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EdgePair {
2339        #[inline(always)]
2340        fn new_empty() -> Self {
2341            Self {
2342                processing_element_id_from: fidl::new_empty!(u64, D),
2343                processing_element_id_to: fidl::new_empty!(u64, D),
2344            }
2345        }
2346
2347        #[inline]
2348        unsafe fn decode(
2349            &mut self,
2350            decoder: &mut fidl::encoding::Decoder<'_, D>,
2351            offset: usize,
2352            _depth: fidl::encoding::Depth,
2353        ) -> fidl::Result<()> {
2354            decoder.debug_check_bounds::<Self>(offset);
2355            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2356            // Verify that padding bytes are zero.
2357            // Copy from the buffer into the object.
2358            unsafe {
2359                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
2360            }
2361            Ok(())
2362        }
2363    }
2364
2365    impl fidl::encoding::ValueTypeMarker for ReaderWatchElementStateRequest {
2366        type Borrowed<'a> = &'a Self;
2367        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2368            value
2369        }
2370    }
2371
2372    unsafe impl fidl::encoding::TypeMarker for ReaderWatchElementStateRequest {
2373        type Owned = Self;
2374
2375        #[inline(always)]
2376        fn inline_align(_context: fidl::encoding::Context) -> usize {
2377            8
2378        }
2379
2380        #[inline(always)]
2381        fn inline_size(_context: fidl::encoding::Context) -> usize {
2382            8
2383        }
2384        #[inline(always)]
2385        fn encode_is_copy() -> bool {
2386            true
2387        }
2388
2389        #[inline(always)]
2390        fn decode_is_copy() -> bool {
2391            true
2392        }
2393    }
2394
2395    unsafe impl<D: fidl::encoding::ResourceDialect>
2396        fidl::encoding::Encode<ReaderWatchElementStateRequest, D>
2397        for &ReaderWatchElementStateRequest
2398    {
2399        #[inline]
2400        unsafe fn encode(
2401            self,
2402            encoder: &mut fidl::encoding::Encoder<'_, D>,
2403            offset: usize,
2404            _depth: fidl::encoding::Depth,
2405        ) -> fidl::Result<()> {
2406            encoder.debug_check_bounds::<ReaderWatchElementStateRequest>(offset);
2407            unsafe {
2408                // Copy the object into the buffer.
2409                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2410                (buf_ptr as *mut ReaderWatchElementStateRequest)
2411                    .write_unaligned((self as *const ReaderWatchElementStateRequest).read());
2412                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2413                // done second because the memcpy will write garbage to these bytes.
2414            }
2415            Ok(())
2416        }
2417    }
2418    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
2419        fidl::encoding::Encode<ReaderWatchElementStateRequest, D> for (T0,)
2420    {
2421        #[inline]
2422        unsafe fn encode(
2423            self,
2424            encoder: &mut fidl::encoding::Encoder<'_, D>,
2425            offset: usize,
2426            depth: fidl::encoding::Depth,
2427        ) -> fidl::Result<()> {
2428            encoder.debug_check_bounds::<ReaderWatchElementStateRequest>(offset);
2429            // Zero out padding regions. There's no need to apply masks
2430            // because the unmasked parts will be overwritten by fields.
2431            // Write the fields.
2432            self.0.encode(encoder, offset + 0, depth)?;
2433            Ok(())
2434        }
2435    }
2436
2437    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2438        for ReaderWatchElementStateRequest
2439    {
2440        #[inline(always)]
2441        fn new_empty() -> Self {
2442            Self { processing_element_id: fidl::new_empty!(u64, D) }
2443        }
2444
2445        #[inline]
2446        unsafe fn decode(
2447            &mut self,
2448            decoder: &mut fidl::encoding::Decoder<'_, D>,
2449            offset: usize,
2450            _depth: fidl::encoding::Depth,
2451        ) -> fidl::Result<()> {
2452            decoder.debug_check_bounds::<Self>(offset);
2453            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2454            // Verify that padding bytes are zero.
2455            // Copy from the buffer into the object.
2456            unsafe {
2457                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
2458            }
2459            Ok(())
2460        }
2461    }
2462
2463    impl fidl::encoding::ValueTypeMarker for ReaderWatchElementStateResponse {
2464        type Borrowed<'a> = &'a Self;
2465        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2466            value
2467        }
2468    }
2469
2470    unsafe impl fidl::encoding::TypeMarker for ReaderWatchElementStateResponse {
2471        type Owned = Self;
2472
2473        #[inline(always)]
2474        fn inline_align(_context: fidl::encoding::Context) -> usize {
2475            8
2476        }
2477
2478        #[inline(always)]
2479        fn inline_size(_context: fidl::encoding::Context) -> usize {
2480            16
2481        }
2482    }
2483
2484    unsafe impl<D: fidl::encoding::ResourceDialect>
2485        fidl::encoding::Encode<ReaderWatchElementStateResponse, D>
2486        for &ReaderWatchElementStateResponse
2487    {
2488        #[inline]
2489        unsafe fn encode(
2490            self,
2491            encoder: &mut fidl::encoding::Encoder<'_, D>,
2492            offset: usize,
2493            _depth: fidl::encoding::Depth,
2494        ) -> fidl::Result<()> {
2495            encoder.debug_check_bounds::<ReaderWatchElementStateResponse>(offset);
2496            // Delegate to tuple encoding.
2497            fidl::encoding::Encode::<ReaderWatchElementStateResponse, D>::encode(
2498                (<ElementState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),),
2499                encoder,
2500                offset,
2501                _depth,
2502            )
2503        }
2504    }
2505    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ElementState, D>>
2506        fidl::encoding::Encode<ReaderWatchElementStateResponse, D> for (T0,)
2507    {
2508        #[inline]
2509        unsafe fn encode(
2510            self,
2511            encoder: &mut fidl::encoding::Encoder<'_, D>,
2512            offset: usize,
2513            depth: fidl::encoding::Depth,
2514        ) -> fidl::Result<()> {
2515            encoder.debug_check_bounds::<ReaderWatchElementStateResponse>(offset);
2516            // Zero out padding regions. There's no need to apply masks
2517            // because the unmasked parts will be overwritten by fields.
2518            // Write the fields.
2519            self.0.encode(encoder, offset + 0, depth)?;
2520            Ok(())
2521        }
2522    }
2523
2524    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2525        for ReaderWatchElementStateResponse
2526    {
2527        #[inline(always)]
2528        fn new_empty() -> Self {
2529            Self { state: fidl::new_empty!(ElementState, D) }
2530        }
2531
2532        #[inline]
2533        unsafe fn decode(
2534            &mut self,
2535            decoder: &mut fidl::encoding::Decoder<'_, D>,
2536            offset: usize,
2537            _depth: fidl::encoding::Depth,
2538        ) -> fidl::Result<()> {
2539            decoder.debug_check_bounds::<Self>(offset);
2540            // Verify that padding bytes are zero.
2541            fidl::decode!(ElementState, D, &mut self.state, decoder, offset + 0, _depth)?;
2542            Ok(())
2543        }
2544    }
2545
2546    impl fidl::encoding::ValueTypeMarker for ReaderGetElementsResponse {
2547        type Borrowed<'a> = &'a Self;
2548        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2549            value
2550        }
2551    }
2552
2553    unsafe impl fidl::encoding::TypeMarker for ReaderGetElementsResponse {
2554        type Owned = Self;
2555
2556        #[inline(always)]
2557        fn inline_align(_context: fidl::encoding::Context) -> usize {
2558            8
2559        }
2560
2561        #[inline(always)]
2562        fn inline_size(_context: fidl::encoding::Context) -> usize {
2563            16
2564        }
2565    }
2566
2567    unsafe impl<D: fidl::encoding::ResourceDialect>
2568        fidl::encoding::Encode<ReaderGetElementsResponse, D> for &ReaderGetElementsResponse
2569    {
2570        #[inline]
2571        unsafe fn encode(
2572            self,
2573            encoder: &mut fidl::encoding::Encoder<'_, D>,
2574            offset: usize,
2575            _depth: fidl::encoding::Depth,
2576        ) -> fidl::Result<()> {
2577            encoder.debug_check_bounds::<ReaderGetElementsResponse>(offset);
2578            // Delegate to tuple encoding.
2579            fidl::encoding::Encode::<ReaderGetElementsResponse, D>::encode(
2580                (<fidl::encoding::Vector<Element, 64> as fidl::encoding::ValueTypeMarker>::borrow(
2581                    &self.processing_elements,
2582                ),),
2583                encoder,
2584                offset,
2585                _depth,
2586            )
2587        }
2588    }
2589    unsafe impl<
2590            D: fidl::encoding::ResourceDialect,
2591            T0: fidl::encoding::Encode<fidl::encoding::Vector<Element, 64>, D>,
2592        > fidl::encoding::Encode<ReaderGetElementsResponse, D> for (T0,)
2593    {
2594        #[inline]
2595        unsafe fn encode(
2596            self,
2597            encoder: &mut fidl::encoding::Encoder<'_, D>,
2598            offset: usize,
2599            depth: fidl::encoding::Depth,
2600        ) -> fidl::Result<()> {
2601            encoder.debug_check_bounds::<ReaderGetElementsResponse>(offset);
2602            // Zero out padding regions. There's no need to apply masks
2603            // because the unmasked parts will be overwritten by fields.
2604            // Write the fields.
2605            self.0.encode(encoder, offset + 0, depth)?;
2606            Ok(())
2607        }
2608    }
2609
2610    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2611        for ReaderGetElementsResponse
2612    {
2613        #[inline(always)]
2614        fn new_empty() -> Self {
2615            Self { processing_elements: fidl::new_empty!(fidl::encoding::Vector<Element, 64>, D) }
2616        }
2617
2618        #[inline]
2619        unsafe fn decode(
2620            &mut self,
2621            decoder: &mut fidl::encoding::Decoder<'_, D>,
2622            offset: usize,
2623            _depth: fidl::encoding::Depth,
2624        ) -> fidl::Result<()> {
2625            decoder.debug_check_bounds::<Self>(offset);
2626            // Verify that padding bytes are zero.
2627            fidl::decode!(fidl::encoding::Vector<Element, 64>, D, &mut self.processing_elements, decoder, offset + 0, _depth)?;
2628            Ok(())
2629        }
2630    }
2631
2632    impl fidl::encoding::ValueTypeMarker for ReaderGetTopologiesResponse {
2633        type Borrowed<'a> = &'a Self;
2634        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2635            value
2636        }
2637    }
2638
2639    unsafe impl fidl::encoding::TypeMarker for ReaderGetTopologiesResponse {
2640        type Owned = Self;
2641
2642        #[inline(always)]
2643        fn inline_align(_context: fidl::encoding::Context) -> usize {
2644            8
2645        }
2646
2647        #[inline(always)]
2648        fn inline_size(_context: fidl::encoding::Context) -> usize {
2649            16
2650        }
2651    }
2652
2653    unsafe impl<D: fidl::encoding::ResourceDialect>
2654        fidl::encoding::Encode<ReaderGetTopologiesResponse, D> for &ReaderGetTopologiesResponse
2655    {
2656        #[inline]
2657        unsafe fn encode(
2658            self,
2659            encoder: &mut fidl::encoding::Encoder<'_, D>,
2660            offset: usize,
2661            _depth: fidl::encoding::Depth,
2662        ) -> fidl::Result<()> {
2663            encoder.debug_check_bounds::<ReaderGetTopologiesResponse>(offset);
2664            // Delegate to tuple encoding.
2665            fidl::encoding::Encode::<ReaderGetTopologiesResponse, D>::encode(
2666                (
2667                    <fidl::encoding::Vector<Topology, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.topologies),
2668                ),
2669                encoder, offset, _depth
2670            )
2671        }
2672    }
2673    unsafe impl<
2674            D: fidl::encoding::ResourceDialect,
2675            T0: fidl::encoding::Encode<fidl::encoding::Vector<Topology, 64>, D>,
2676        > fidl::encoding::Encode<ReaderGetTopologiesResponse, D> for (T0,)
2677    {
2678        #[inline]
2679        unsafe fn encode(
2680            self,
2681            encoder: &mut fidl::encoding::Encoder<'_, D>,
2682            offset: usize,
2683            depth: fidl::encoding::Depth,
2684        ) -> fidl::Result<()> {
2685            encoder.debug_check_bounds::<ReaderGetTopologiesResponse>(offset);
2686            // Zero out padding regions. There's no need to apply masks
2687            // because the unmasked parts will be overwritten by fields.
2688            // Write the fields.
2689            self.0.encode(encoder, offset + 0, depth)?;
2690            Ok(())
2691        }
2692    }
2693
2694    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2695        for ReaderGetTopologiesResponse
2696    {
2697        #[inline(always)]
2698        fn new_empty() -> Self {
2699            Self { topologies: fidl::new_empty!(fidl::encoding::Vector<Topology, 64>, D) }
2700        }
2701
2702        #[inline]
2703        unsafe fn decode(
2704            &mut self,
2705            decoder: &mut fidl::encoding::Decoder<'_, D>,
2706            offset: usize,
2707            _depth: fidl::encoding::Depth,
2708        ) -> fidl::Result<()> {
2709            decoder.debug_check_bounds::<Self>(offset);
2710            // Verify that padding bytes are zero.
2711            fidl::decode!(fidl::encoding::Vector<Topology, 64>, D, &mut self.topologies, decoder, offset + 0, _depth)?;
2712            Ok(())
2713        }
2714    }
2715
2716    impl fidl::encoding::ValueTypeMarker for ReaderWatchTopologyResponse {
2717        type Borrowed<'a> = &'a Self;
2718        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2719            value
2720        }
2721    }
2722
2723    unsafe impl fidl::encoding::TypeMarker for ReaderWatchTopologyResponse {
2724        type Owned = Self;
2725
2726        #[inline(always)]
2727        fn inline_align(_context: fidl::encoding::Context) -> usize {
2728            8
2729        }
2730
2731        #[inline(always)]
2732        fn inline_size(_context: fidl::encoding::Context) -> usize {
2733            8
2734        }
2735        #[inline(always)]
2736        fn encode_is_copy() -> bool {
2737            true
2738        }
2739
2740        #[inline(always)]
2741        fn decode_is_copy() -> bool {
2742            true
2743        }
2744    }
2745
2746    unsafe impl<D: fidl::encoding::ResourceDialect>
2747        fidl::encoding::Encode<ReaderWatchTopologyResponse, D> for &ReaderWatchTopologyResponse
2748    {
2749        #[inline]
2750        unsafe fn encode(
2751            self,
2752            encoder: &mut fidl::encoding::Encoder<'_, D>,
2753            offset: usize,
2754            _depth: fidl::encoding::Depth,
2755        ) -> fidl::Result<()> {
2756            encoder.debug_check_bounds::<ReaderWatchTopologyResponse>(offset);
2757            unsafe {
2758                // Copy the object into the buffer.
2759                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2760                (buf_ptr as *mut ReaderWatchTopologyResponse)
2761                    .write_unaligned((self as *const ReaderWatchTopologyResponse).read());
2762                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2763                // done second because the memcpy will write garbage to these bytes.
2764            }
2765            Ok(())
2766        }
2767    }
2768    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
2769        fidl::encoding::Encode<ReaderWatchTopologyResponse, D> for (T0,)
2770    {
2771        #[inline]
2772        unsafe fn encode(
2773            self,
2774            encoder: &mut fidl::encoding::Encoder<'_, D>,
2775            offset: usize,
2776            depth: fidl::encoding::Depth,
2777        ) -> fidl::Result<()> {
2778            encoder.debug_check_bounds::<ReaderWatchTopologyResponse>(offset);
2779            // Zero out padding regions. There's no need to apply masks
2780            // because the unmasked parts will be overwritten by fields.
2781            // Write the fields.
2782            self.0.encode(encoder, offset + 0, depth)?;
2783            Ok(())
2784        }
2785    }
2786
2787    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2788        for ReaderWatchTopologyResponse
2789    {
2790        #[inline(always)]
2791        fn new_empty() -> Self {
2792            Self { topology_id: fidl::new_empty!(u64, D) }
2793        }
2794
2795        #[inline]
2796        unsafe fn decode(
2797            &mut self,
2798            decoder: &mut fidl::encoding::Decoder<'_, D>,
2799            offset: usize,
2800            _depth: fidl::encoding::Depth,
2801        ) -> fidl::Result<()> {
2802            decoder.debug_check_bounds::<Self>(offset);
2803            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2804            // Verify that padding bytes are zero.
2805            // Copy from the buffer into the object.
2806            unsafe {
2807                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
2808            }
2809            Ok(())
2810        }
2811    }
2812
2813    impl fidl::encoding::ValueTypeMarker for SignalProcessingSetElementStateRequest {
2814        type Borrowed<'a> = &'a Self;
2815        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2816            value
2817        }
2818    }
2819
2820    unsafe impl fidl::encoding::TypeMarker for SignalProcessingSetElementStateRequest {
2821        type Owned = Self;
2822
2823        #[inline(always)]
2824        fn inline_align(_context: fidl::encoding::Context) -> usize {
2825            8
2826        }
2827
2828        #[inline(always)]
2829        fn inline_size(_context: fidl::encoding::Context) -> usize {
2830            24
2831        }
2832    }
2833
2834    unsafe impl<D: fidl::encoding::ResourceDialect>
2835        fidl::encoding::Encode<SignalProcessingSetElementStateRequest, D>
2836        for &SignalProcessingSetElementStateRequest
2837    {
2838        #[inline]
2839        unsafe fn encode(
2840            self,
2841            encoder: &mut fidl::encoding::Encoder<'_, D>,
2842            offset: usize,
2843            _depth: fidl::encoding::Depth,
2844        ) -> fidl::Result<()> {
2845            encoder.debug_check_bounds::<SignalProcessingSetElementStateRequest>(offset);
2846            // Delegate to tuple encoding.
2847            fidl::encoding::Encode::<SignalProcessingSetElementStateRequest, D>::encode(
2848                (
2849                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.processing_element_id),
2850                    <SettableElementState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
2851                ),
2852                encoder,
2853                offset,
2854                _depth,
2855            )
2856        }
2857    }
2858    unsafe impl<
2859            D: fidl::encoding::ResourceDialect,
2860            T0: fidl::encoding::Encode<u64, D>,
2861            T1: fidl::encoding::Encode<SettableElementState, D>,
2862        > fidl::encoding::Encode<SignalProcessingSetElementStateRequest, D> for (T0, T1)
2863    {
2864        #[inline]
2865        unsafe fn encode(
2866            self,
2867            encoder: &mut fidl::encoding::Encoder<'_, D>,
2868            offset: usize,
2869            depth: fidl::encoding::Depth,
2870        ) -> fidl::Result<()> {
2871            encoder.debug_check_bounds::<SignalProcessingSetElementStateRequest>(offset);
2872            // Zero out padding regions. There's no need to apply masks
2873            // because the unmasked parts will be overwritten by fields.
2874            // Write the fields.
2875            self.0.encode(encoder, offset + 0, depth)?;
2876            self.1.encode(encoder, offset + 8, depth)?;
2877            Ok(())
2878        }
2879    }
2880
2881    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2882        for SignalProcessingSetElementStateRequest
2883    {
2884        #[inline(always)]
2885        fn new_empty() -> Self {
2886            Self {
2887                processing_element_id: fidl::new_empty!(u64, D),
2888                state: fidl::new_empty!(SettableElementState, D),
2889            }
2890        }
2891
2892        #[inline]
2893        unsafe fn decode(
2894            &mut self,
2895            decoder: &mut fidl::encoding::Decoder<'_, D>,
2896            offset: usize,
2897            _depth: fidl::encoding::Depth,
2898        ) -> fidl::Result<()> {
2899            decoder.debug_check_bounds::<Self>(offset);
2900            // Verify that padding bytes are zero.
2901            fidl::decode!(u64, D, &mut self.processing_element_id, decoder, offset + 0, _depth)?;
2902            fidl::decode!(SettableElementState, D, &mut self.state, decoder, offset + 8, _depth)?;
2903            Ok(())
2904        }
2905    }
2906
2907    impl fidl::encoding::ValueTypeMarker for SignalProcessingSetTopologyRequest {
2908        type Borrowed<'a> = &'a Self;
2909        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2910            value
2911        }
2912    }
2913
2914    unsafe impl fidl::encoding::TypeMarker for SignalProcessingSetTopologyRequest {
2915        type Owned = Self;
2916
2917        #[inline(always)]
2918        fn inline_align(_context: fidl::encoding::Context) -> usize {
2919            8
2920        }
2921
2922        #[inline(always)]
2923        fn inline_size(_context: fidl::encoding::Context) -> usize {
2924            8
2925        }
2926        #[inline(always)]
2927        fn encode_is_copy() -> bool {
2928            true
2929        }
2930
2931        #[inline(always)]
2932        fn decode_is_copy() -> bool {
2933            true
2934        }
2935    }
2936
2937    unsafe impl<D: fidl::encoding::ResourceDialect>
2938        fidl::encoding::Encode<SignalProcessingSetTopologyRequest, D>
2939        for &SignalProcessingSetTopologyRequest
2940    {
2941        #[inline]
2942        unsafe fn encode(
2943            self,
2944            encoder: &mut fidl::encoding::Encoder<'_, D>,
2945            offset: usize,
2946            _depth: fidl::encoding::Depth,
2947        ) -> fidl::Result<()> {
2948            encoder.debug_check_bounds::<SignalProcessingSetTopologyRequest>(offset);
2949            unsafe {
2950                // Copy the object into the buffer.
2951                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2952                (buf_ptr as *mut SignalProcessingSetTopologyRequest)
2953                    .write_unaligned((self as *const SignalProcessingSetTopologyRequest).read());
2954                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2955                // done second because the memcpy will write garbage to these bytes.
2956            }
2957            Ok(())
2958        }
2959    }
2960    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
2961        fidl::encoding::Encode<SignalProcessingSetTopologyRequest, D> for (T0,)
2962    {
2963        #[inline]
2964        unsafe fn encode(
2965            self,
2966            encoder: &mut fidl::encoding::Encoder<'_, D>,
2967            offset: usize,
2968            depth: fidl::encoding::Depth,
2969        ) -> fidl::Result<()> {
2970            encoder.debug_check_bounds::<SignalProcessingSetTopologyRequest>(offset);
2971            // Zero out padding regions. There's no need to apply masks
2972            // because the unmasked parts will be overwritten by fields.
2973            // Write the fields.
2974            self.0.encode(encoder, offset + 0, depth)?;
2975            Ok(())
2976        }
2977    }
2978
2979    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2980        for SignalProcessingSetTopologyRequest
2981    {
2982        #[inline(always)]
2983        fn new_empty() -> Self {
2984            Self { topology_id: fidl::new_empty!(u64, D) }
2985        }
2986
2987        #[inline]
2988        unsafe fn decode(
2989            &mut self,
2990            decoder: &mut fidl::encoding::Decoder<'_, D>,
2991            offset: usize,
2992            _depth: fidl::encoding::Depth,
2993        ) -> fidl::Result<()> {
2994            decoder.debug_check_bounds::<Self>(offset);
2995            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2996            // Verify that padding bytes are zero.
2997            // Copy from the buffer into the object.
2998            unsafe {
2999                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
3000            }
3001            Ok(())
3002        }
3003    }
3004
3005    impl DaiInterconnect {
3006        #[inline(always)]
3007        fn max_ordinal_present(&self) -> u64 {
3008            if let Some(_) = self.plug_detect_capabilities {
3009                return 1;
3010            }
3011            0
3012        }
3013    }
3014
3015    impl fidl::encoding::ValueTypeMarker for DaiInterconnect {
3016        type Borrowed<'a> = &'a Self;
3017        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3018            value
3019        }
3020    }
3021
3022    unsafe impl fidl::encoding::TypeMarker for DaiInterconnect {
3023        type Owned = Self;
3024
3025        #[inline(always)]
3026        fn inline_align(_context: fidl::encoding::Context) -> usize {
3027            8
3028        }
3029
3030        #[inline(always)]
3031        fn inline_size(_context: fidl::encoding::Context) -> usize {
3032            16
3033        }
3034    }
3035
3036    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DaiInterconnect, D>
3037        for &DaiInterconnect
3038    {
3039        unsafe fn encode(
3040            self,
3041            encoder: &mut fidl::encoding::Encoder<'_, D>,
3042            offset: usize,
3043            mut depth: fidl::encoding::Depth,
3044        ) -> fidl::Result<()> {
3045            encoder.debug_check_bounds::<DaiInterconnect>(offset);
3046            // Vector header
3047            let max_ordinal: u64 = self.max_ordinal_present();
3048            encoder.write_num(max_ordinal, offset);
3049            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3050            // Calling encoder.out_of_line_offset(0) is not allowed.
3051            if max_ordinal == 0 {
3052                return Ok(());
3053            }
3054            depth.increment()?;
3055            let envelope_size = 8;
3056            let bytes_len = max_ordinal as usize * envelope_size;
3057            #[allow(unused_variables)]
3058            let offset = encoder.out_of_line_offset(bytes_len);
3059            let mut _prev_end_offset: usize = 0;
3060            if 1 > max_ordinal {
3061                return Ok(());
3062            }
3063
3064            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3065            // are envelope_size bytes.
3066            let cur_offset: usize = (1 - 1) * envelope_size;
3067
3068            // Zero reserved fields.
3069            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3070
3071            // Safety:
3072            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3073            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3074            //   envelope_size bytes, there is always sufficient room.
3075            fidl::encoding::encode_in_envelope_optional::<PlugDetectCapabilities, D>(
3076                self.plug_detect_capabilities
3077                    .as_ref()
3078                    .map(<PlugDetectCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
3079                encoder,
3080                offset + cur_offset,
3081                depth,
3082            )?;
3083
3084            _prev_end_offset = cur_offset + envelope_size;
3085
3086            Ok(())
3087        }
3088    }
3089
3090    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DaiInterconnect {
3091        #[inline(always)]
3092        fn new_empty() -> Self {
3093            Self::default()
3094        }
3095
3096        unsafe fn decode(
3097            &mut self,
3098            decoder: &mut fidl::encoding::Decoder<'_, D>,
3099            offset: usize,
3100            mut depth: fidl::encoding::Depth,
3101        ) -> fidl::Result<()> {
3102            decoder.debug_check_bounds::<Self>(offset);
3103            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3104                None => return Err(fidl::Error::NotNullable),
3105                Some(len) => len,
3106            };
3107            // Calling decoder.out_of_line_offset(0) is not allowed.
3108            if len == 0 {
3109                return Ok(());
3110            };
3111            depth.increment()?;
3112            let envelope_size = 8;
3113            let bytes_len = len * envelope_size;
3114            let offset = decoder.out_of_line_offset(bytes_len)?;
3115            // Decode the envelope for each type.
3116            let mut _next_ordinal_to_read = 0;
3117            let mut next_offset = offset;
3118            let end_offset = offset + bytes_len;
3119            _next_ordinal_to_read += 1;
3120            if next_offset >= end_offset {
3121                return Ok(());
3122            }
3123
3124            // Decode unknown envelopes for gaps in ordinals.
3125            while _next_ordinal_to_read < 1 {
3126                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3127                _next_ordinal_to_read += 1;
3128                next_offset += envelope_size;
3129            }
3130
3131            let next_out_of_line = decoder.next_out_of_line();
3132            let handles_before = decoder.remaining_handles();
3133            if let Some((inlined, num_bytes, num_handles)) =
3134                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3135            {
3136                let member_inline_size =
3137                    <PlugDetectCapabilities as fidl::encoding::TypeMarker>::inline_size(
3138                        decoder.context,
3139                    );
3140                if inlined != (member_inline_size <= 4) {
3141                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3142                }
3143                let inner_offset;
3144                let mut inner_depth = depth.clone();
3145                if inlined {
3146                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3147                    inner_offset = next_offset;
3148                } else {
3149                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3150                    inner_depth.increment()?;
3151                }
3152                let val_ref = self
3153                    .plug_detect_capabilities
3154                    .get_or_insert_with(|| fidl::new_empty!(PlugDetectCapabilities, D));
3155                fidl::decode!(
3156                    PlugDetectCapabilities,
3157                    D,
3158                    val_ref,
3159                    decoder,
3160                    inner_offset,
3161                    inner_depth
3162                )?;
3163                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3164                {
3165                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3166                }
3167                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3168                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3169                }
3170            }
3171
3172            next_offset += envelope_size;
3173
3174            // Decode the remaining unknown envelopes.
3175            while next_offset < end_offset {
3176                _next_ordinal_to_read += 1;
3177                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3178                next_offset += envelope_size;
3179            }
3180
3181            Ok(())
3182        }
3183    }
3184
3185    impl DaiInterconnectElementState {
3186        #[inline(always)]
3187        fn max_ordinal_present(&self) -> u64 {
3188            if let Some(_) = self.external_delay {
3189                return 2;
3190            }
3191            if let Some(_) = self.plug_state {
3192                return 1;
3193            }
3194            0
3195        }
3196    }
3197
3198    impl fidl::encoding::ValueTypeMarker for DaiInterconnectElementState {
3199        type Borrowed<'a> = &'a Self;
3200        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3201            value
3202        }
3203    }
3204
3205    unsafe impl fidl::encoding::TypeMarker for DaiInterconnectElementState {
3206        type Owned = Self;
3207
3208        #[inline(always)]
3209        fn inline_align(_context: fidl::encoding::Context) -> usize {
3210            8
3211        }
3212
3213        #[inline(always)]
3214        fn inline_size(_context: fidl::encoding::Context) -> usize {
3215            16
3216        }
3217    }
3218
3219    unsafe impl<D: fidl::encoding::ResourceDialect>
3220        fidl::encoding::Encode<DaiInterconnectElementState, D> for &DaiInterconnectElementState
3221    {
3222        unsafe fn encode(
3223            self,
3224            encoder: &mut fidl::encoding::Encoder<'_, D>,
3225            offset: usize,
3226            mut depth: fidl::encoding::Depth,
3227        ) -> fidl::Result<()> {
3228            encoder.debug_check_bounds::<DaiInterconnectElementState>(offset);
3229            // Vector header
3230            let max_ordinal: u64 = self.max_ordinal_present();
3231            encoder.write_num(max_ordinal, offset);
3232            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3233            // Calling encoder.out_of_line_offset(0) is not allowed.
3234            if max_ordinal == 0 {
3235                return Ok(());
3236            }
3237            depth.increment()?;
3238            let envelope_size = 8;
3239            let bytes_len = max_ordinal as usize * envelope_size;
3240            #[allow(unused_variables)]
3241            let offset = encoder.out_of_line_offset(bytes_len);
3242            let mut _prev_end_offset: usize = 0;
3243            if 1 > max_ordinal {
3244                return Ok(());
3245            }
3246
3247            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3248            // are envelope_size bytes.
3249            let cur_offset: usize = (1 - 1) * envelope_size;
3250
3251            // Zero reserved fields.
3252            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3253
3254            // Safety:
3255            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3256            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3257            //   envelope_size bytes, there is always sufficient room.
3258            fidl::encoding::encode_in_envelope_optional::<PlugState, D>(
3259                self.plug_state
3260                    .as_ref()
3261                    .map(<PlugState as fidl::encoding::ValueTypeMarker>::borrow),
3262                encoder,
3263                offset + cur_offset,
3264                depth,
3265            )?;
3266
3267            _prev_end_offset = cur_offset + envelope_size;
3268            if 2 > max_ordinal {
3269                return Ok(());
3270            }
3271
3272            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3273            // are envelope_size bytes.
3274            let cur_offset: usize = (2 - 1) * envelope_size;
3275
3276            // Zero reserved fields.
3277            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3278
3279            // Safety:
3280            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3281            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3282            //   envelope_size bytes, there is always sufficient room.
3283            fidl::encoding::encode_in_envelope_optional::<i64, D>(
3284                self.external_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3285                encoder,
3286                offset + cur_offset,
3287                depth,
3288            )?;
3289
3290            _prev_end_offset = cur_offset + envelope_size;
3291
3292            Ok(())
3293        }
3294    }
3295
3296    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3297        for DaiInterconnectElementState
3298    {
3299        #[inline(always)]
3300        fn new_empty() -> Self {
3301            Self::default()
3302        }
3303
3304        unsafe fn decode(
3305            &mut self,
3306            decoder: &mut fidl::encoding::Decoder<'_, D>,
3307            offset: usize,
3308            mut depth: fidl::encoding::Depth,
3309        ) -> fidl::Result<()> {
3310            decoder.debug_check_bounds::<Self>(offset);
3311            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3312                None => return Err(fidl::Error::NotNullable),
3313                Some(len) => len,
3314            };
3315            // Calling decoder.out_of_line_offset(0) is not allowed.
3316            if len == 0 {
3317                return Ok(());
3318            };
3319            depth.increment()?;
3320            let envelope_size = 8;
3321            let bytes_len = len * envelope_size;
3322            let offset = decoder.out_of_line_offset(bytes_len)?;
3323            // Decode the envelope for each type.
3324            let mut _next_ordinal_to_read = 0;
3325            let mut next_offset = offset;
3326            let end_offset = offset + bytes_len;
3327            _next_ordinal_to_read += 1;
3328            if next_offset >= end_offset {
3329                return Ok(());
3330            }
3331
3332            // Decode unknown envelopes for gaps in ordinals.
3333            while _next_ordinal_to_read < 1 {
3334                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3335                _next_ordinal_to_read += 1;
3336                next_offset += envelope_size;
3337            }
3338
3339            let next_out_of_line = decoder.next_out_of_line();
3340            let handles_before = decoder.remaining_handles();
3341            if let Some((inlined, num_bytes, num_handles)) =
3342                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3343            {
3344                let member_inline_size =
3345                    <PlugState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3346                if inlined != (member_inline_size <= 4) {
3347                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3348                }
3349                let inner_offset;
3350                let mut inner_depth = depth.clone();
3351                if inlined {
3352                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3353                    inner_offset = next_offset;
3354                } else {
3355                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3356                    inner_depth.increment()?;
3357                }
3358                let val_ref = self.plug_state.get_or_insert_with(|| fidl::new_empty!(PlugState, D));
3359                fidl::decode!(PlugState, D, val_ref, decoder, inner_offset, inner_depth)?;
3360                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3361                {
3362                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3363                }
3364                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3365                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3366                }
3367            }
3368
3369            next_offset += envelope_size;
3370            _next_ordinal_to_read += 1;
3371            if next_offset >= end_offset {
3372                return Ok(());
3373            }
3374
3375            // Decode unknown envelopes for gaps in ordinals.
3376            while _next_ordinal_to_read < 2 {
3377                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3378                _next_ordinal_to_read += 1;
3379                next_offset += envelope_size;
3380            }
3381
3382            let next_out_of_line = decoder.next_out_of_line();
3383            let handles_before = decoder.remaining_handles();
3384            if let Some((inlined, num_bytes, num_handles)) =
3385                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3386            {
3387                let member_inline_size =
3388                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3389                if inlined != (member_inline_size <= 4) {
3390                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3391                }
3392                let inner_offset;
3393                let mut inner_depth = depth.clone();
3394                if inlined {
3395                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3396                    inner_offset = next_offset;
3397                } else {
3398                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3399                    inner_depth.increment()?;
3400                }
3401                let val_ref = self.external_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
3402                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3403                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3404                {
3405                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3406                }
3407                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3408                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3409                }
3410            }
3411
3412            next_offset += envelope_size;
3413
3414            // Decode the remaining unknown envelopes.
3415            while next_offset < end_offset {
3416                _next_ordinal_to_read += 1;
3417                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3418                next_offset += envelope_size;
3419            }
3420
3421            Ok(())
3422        }
3423    }
3424
3425    impl Dynamics {
3426        #[inline(always)]
3427        fn max_ordinal_present(&self) -> u64 {
3428            if let Some(_) = self.supported_controls {
3429                return 2;
3430            }
3431            if let Some(_) = self.bands {
3432                return 1;
3433            }
3434            0
3435        }
3436    }
3437
3438    impl fidl::encoding::ValueTypeMarker for Dynamics {
3439        type Borrowed<'a> = &'a Self;
3440        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3441            value
3442        }
3443    }
3444
3445    unsafe impl fidl::encoding::TypeMarker for Dynamics {
3446        type Owned = Self;
3447
3448        #[inline(always)]
3449        fn inline_align(_context: fidl::encoding::Context) -> usize {
3450            8
3451        }
3452
3453        #[inline(always)]
3454        fn inline_size(_context: fidl::encoding::Context) -> usize {
3455            16
3456        }
3457    }
3458
3459    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Dynamics, D> for &Dynamics {
3460        unsafe fn encode(
3461            self,
3462            encoder: &mut fidl::encoding::Encoder<'_, D>,
3463            offset: usize,
3464            mut depth: fidl::encoding::Depth,
3465        ) -> fidl::Result<()> {
3466            encoder.debug_check_bounds::<Dynamics>(offset);
3467            // Vector header
3468            let max_ordinal: u64 = self.max_ordinal_present();
3469            encoder.write_num(max_ordinal, offset);
3470            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3471            // Calling encoder.out_of_line_offset(0) is not allowed.
3472            if max_ordinal == 0 {
3473                return Ok(());
3474            }
3475            depth.increment()?;
3476            let envelope_size = 8;
3477            let bytes_len = max_ordinal as usize * envelope_size;
3478            #[allow(unused_variables)]
3479            let offset = encoder.out_of_line_offset(bytes_len);
3480            let mut _prev_end_offset: usize = 0;
3481            if 1 > max_ordinal {
3482                return Ok(());
3483            }
3484
3485            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3486            // are envelope_size bytes.
3487            let cur_offset: usize = (1 - 1) * envelope_size;
3488
3489            // Zero reserved fields.
3490            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3491
3492            // Safety:
3493            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3494            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3495            //   envelope_size bytes, there is always sufficient room.
3496            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<DynamicsBand, 64>, D>(
3497            self.bands.as_ref().map(<fidl::encoding::Vector<DynamicsBand, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3498            encoder, offset + cur_offset, depth
3499        )?;
3500
3501            _prev_end_offset = cur_offset + envelope_size;
3502            if 2 > max_ordinal {
3503                return Ok(());
3504            }
3505
3506            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3507            // are envelope_size bytes.
3508            let cur_offset: usize = (2 - 1) * envelope_size;
3509
3510            // Zero reserved fields.
3511            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3512
3513            // Safety:
3514            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3515            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3516            //   envelope_size bytes, there is always sufficient room.
3517            fidl::encoding::encode_in_envelope_optional::<DynamicsSupportedControls, D>(
3518                self.supported_controls
3519                    .as_ref()
3520                    .map(<DynamicsSupportedControls as fidl::encoding::ValueTypeMarker>::borrow),
3521                encoder,
3522                offset + cur_offset,
3523                depth,
3524            )?;
3525
3526            _prev_end_offset = cur_offset + envelope_size;
3527
3528            Ok(())
3529        }
3530    }
3531
3532    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dynamics {
3533        #[inline(always)]
3534        fn new_empty() -> Self {
3535            Self::default()
3536        }
3537
3538        unsafe fn decode(
3539            &mut self,
3540            decoder: &mut fidl::encoding::Decoder<'_, D>,
3541            offset: usize,
3542            mut depth: fidl::encoding::Depth,
3543        ) -> fidl::Result<()> {
3544            decoder.debug_check_bounds::<Self>(offset);
3545            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3546                None => return Err(fidl::Error::NotNullable),
3547                Some(len) => len,
3548            };
3549            // Calling decoder.out_of_line_offset(0) is not allowed.
3550            if len == 0 {
3551                return Ok(());
3552            };
3553            depth.increment()?;
3554            let envelope_size = 8;
3555            let bytes_len = len * envelope_size;
3556            let offset = decoder.out_of_line_offset(bytes_len)?;
3557            // Decode the envelope for each type.
3558            let mut _next_ordinal_to_read = 0;
3559            let mut next_offset = offset;
3560            let end_offset = offset + bytes_len;
3561            _next_ordinal_to_read += 1;
3562            if next_offset >= end_offset {
3563                return Ok(());
3564            }
3565
3566            // Decode unknown envelopes for gaps in ordinals.
3567            while _next_ordinal_to_read < 1 {
3568                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3569                _next_ordinal_to_read += 1;
3570                next_offset += envelope_size;
3571            }
3572
3573            let next_out_of_line = decoder.next_out_of_line();
3574            let handles_before = decoder.remaining_handles();
3575            if let Some((inlined, num_bytes, num_handles)) =
3576                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3577            {
3578                let member_inline_size = <fidl::encoding::Vector<DynamicsBand, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3579                if inlined != (member_inline_size <= 4) {
3580                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3581                }
3582                let inner_offset;
3583                let mut inner_depth = depth.clone();
3584                if inlined {
3585                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3586                    inner_offset = next_offset;
3587                } else {
3588                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3589                    inner_depth.increment()?;
3590                }
3591                let val_ref = self.bands.get_or_insert_with(
3592                    || fidl::new_empty!(fidl::encoding::Vector<DynamicsBand, 64>, D),
3593                );
3594                fidl::decode!(fidl::encoding::Vector<DynamicsBand, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3595                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3596                {
3597                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3598                }
3599                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3600                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3601                }
3602            }
3603
3604            next_offset += envelope_size;
3605            _next_ordinal_to_read += 1;
3606            if next_offset >= end_offset {
3607                return Ok(());
3608            }
3609
3610            // Decode unknown envelopes for gaps in ordinals.
3611            while _next_ordinal_to_read < 2 {
3612                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3613                _next_ordinal_to_read += 1;
3614                next_offset += envelope_size;
3615            }
3616
3617            let next_out_of_line = decoder.next_out_of_line();
3618            let handles_before = decoder.remaining_handles();
3619            if let Some((inlined, num_bytes, num_handles)) =
3620                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3621            {
3622                let member_inline_size =
3623                    <DynamicsSupportedControls as fidl::encoding::TypeMarker>::inline_size(
3624                        decoder.context,
3625                    );
3626                if inlined != (member_inline_size <= 4) {
3627                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3628                }
3629                let inner_offset;
3630                let mut inner_depth = depth.clone();
3631                if inlined {
3632                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3633                    inner_offset = next_offset;
3634                } else {
3635                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3636                    inner_depth.increment()?;
3637                }
3638                let val_ref = self
3639                    .supported_controls
3640                    .get_or_insert_with(|| fidl::new_empty!(DynamicsSupportedControls, D));
3641                fidl::decode!(
3642                    DynamicsSupportedControls,
3643                    D,
3644                    val_ref,
3645                    decoder,
3646                    inner_offset,
3647                    inner_depth
3648                )?;
3649                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3650                {
3651                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3652                }
3653                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3654                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3655                }
3656            }
3657
3658            next_offset += envelope_size;
3659
3660            // Decode the remaining unknown envelopes.
3661            while next_offset < end_offset {
3662                _next_ordinal_to_read += 1;
3663                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3664                next_offset += envelope_size;
3665            }
3666
3667            Ok(())
3668        }
3669    }
3670
3671    impl DynamicsBand {
3672        #[inline(always)]
3673        fn max_ordinal_present(&self) -> u64 {
3674            if let Some(_) = self.id {
3675                return 1;
3676            }
3677            0
3678        }
3679    }
3680
3681    impl fidl::encoding::ValueTypeMarker for DynamicsBand {
3682        type Borrowed<'a> = &'a Self;
3683        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3684            value
3685        }
3686    }
3687
3688    unsafe impl fidl::encoding::TypeMarker for DynamicsBand {
3689        type Owned = Self;
3690
3691        #[inline(always)]
3692        fn inline_align(_context: fidl::encoding::Context) -> usize {
3693            8
3694        }
3695
3696        #[inline(always)]
3697        fn inline_size(_context: fidl::encoding::Context) -> usize {
3698            16
3699        }
3700    }
3701
3702    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DynamicsBand, D>
3703        for &DynamicsBand
3704    {
3705        unsafe fn encode(
3706            self,
3707            encoder: &mut fidl::encoding::Encoder<'_, D>,
3708            offset: usize,
3709            mut depth: fidl::encoding::Depth,
3710        ) -> fidl::Result<()> {
3711            encoder.debug_check_bounds::<DynamicsBand>(offset);
3712            // Vector header
3713            let max_ordinal: u64 = self.max_ordinal_present();
3714            encoder.write_num(max_ordinal, offset);
3715            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3716            // Calling encoder.out_of_line_offset(0) is not allowed.
3717            if max_ordinal == 0 {
3718                return Ok(());
3719            }
3720            depth.increment()?;
3721            let envelope_size = 8;
3722            let bytes_len = max_ordinal as usize * envelope_size;
3723            #[allow(unused_variables)]
3724            let offset = encoder.out_of_line_offset(bytes_len);
3725            let mut _prev_end_offset: usize = 0;
3726            if 1 > max_ordinal {
3727                return Ok(());
3728            }
3729
3730            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3731            // are envelope_size bytes.
3732            let cur_offset: usize = (1 - 1) * envelope_size;
3733
3734            // Zero reserved fields.
3735            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3736
3737            // Safety:
3738            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3739            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3740            //   envelope_size bytes, there is always sufficient room.
3741            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3742                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3743                encoder,
3744                offset + cur_offset,
3745                depth,
3746            )?;
3747
3748            _prev_end_offset = cur_offset + envelope_size;
3749
3750            Ok(())
3751        }
3752    }
3753
3754    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DynamicsBand {
3755        #[inline(always)]
3756        fn new_empty() -> Self {
3757            Self::default()
3758        }
3759
3760        unsafe fn decode(
3761            &mut self,
3762            decoder: &mut fidl::encoding::Decoder<'_, D>,
3763            offset: usize,
3764            mut depth: fidl::encoding::Depth,
3765        ) -> fidl::Result<()> {
3766            decoder.debug_check_bounds::<Self>(offset);
3767            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3768                None => return Err(fidl::Error::NotNullable),
3769                Some(len) => len,
3770            };
3771            // Calling decoder.out_of_line_offset(0) is not allowed.
3772            if len == 0 {
3773                return Ok(());
3774            };
3775            depth.increment()?;
3776            let envelope_size = 8;
3777            let bytes_len = len * envelope_size;
3778            let offset = decoder.out_of_line_offset(bytes_len)?;
3779            // Decode the envelope for each type.
3780            let mut _next_ordinal_to_read = 0;
3781            let mut next_offset = offset;
3782            let end_offset = offset + bytes_len;
3783            _next_ordinal_to_read += 1;
3784            if next_offset >= end_offset {
3785                return Ok(());
3786            }
3787
3788            // Decode unknown envelopes for gaps in ordinals.
3789            while _next_ordinal_to_read < 1 {
3790                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3791                _next_ordinal_to_read += 1;
3792                next_offset += envelope_size;
3793            }
3794
3795            let next_out_of_line = decoder.next_out_of_line();
3796            let handles_before = decoder.remaining_handles();
3797            if let Some((inlined, num_bytes, num_handles)) =
3798                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3799            {
3800                let member_inline_size =
3801                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3802                if inlined != (member_inline_size <= 4) {
3803                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3804                }
3805                let inner_offset;
3806                let mut inner_depth = depth.clone();
3807                if inlined {
3808                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3809                    inner_offset = next_offset;
3810                } else {
3811                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3812                    inner_depth.increment()?;
3813                }
3814                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
3815                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3816                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3817                {
3818                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3819                }
3820                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3821                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3822                }
3823            }
3824
3825            next_offset += envelope_size;
3826
3827            // Decode the remaining unknown envelopes.
3828            while next_offset < end_offset {
3829                _next_ordinal_to_read += 1;
3830                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3831                next_offset += envelope_size;
3832            }
3833
3834            Ok(())
3835        }
3836    }
3837
3838    impl DynamicsBandState {
3839        #[inline(always)]
3840        fn max_ordinal_present(&self) -> u64 {
3841            if let Some(_) = self.linked_channels {
3842                return 14;
3843            }
3844            if let Some(_) = self.lookahead {
3845                return 13;
3846            }
3847            if let Some(_) = self.level_type {
3848                return 12;
3849            }
3850            if let Some(_) = self.input_gain_db {
3851                return 11;
3852            }
3853            if let Some(_) = self.output_gain_db {
3854                return 10;
3855            }
3856            if let Some(_) = self.release {
3857                return 9;
3858            }
3859            if let Some(_) = self.attack {
3860                return 8;
3861            }
3862            if let Some(_) = self.knee_width_db {
3863                return 7;
3864            }
3865            if let Some(_) = self.ratio {
3866                return 6;
3867            }
3868            if let Some(_) = self.threshold_type {
3869                return 5;
3870            }
3871            if let Some(_) = self.threshold_db {
3872                return 4;
3873            }
3874            if let Some(_) = self.max_frequency {
3875                return 3;
3876            }
3877            if let Some(_) = self.min_frequency {
3878                return 2;
3879            }
3880            if let Some(_) = self.id {
3881                return 1;
3882            }
3883            0
3884        }
3885    }
3886
3887    impl fidl::encoding::ValueTypeMarker for DynamicsBandState {
3888        type Borrowed<'a> = &'a Self;
3889        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3890            value
3891        }
3892    }
3893
3894    unsafe impl fidl::encoding::TypeMarker for DynamicsBandState {
3895        type Owned = Self;
3896
3897        #[inline(always)]
3898        fn inline_align(_context: fidl::encoding::Context) -> usize {
3899            8
3900        }
3901
3902        #[inline(always)]
3903        fn inline_size(_context: fidl::encoding::Context) -> usize {
3904            16
3905        }
3906    }
3907
3908    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DynamicsBandState, D>
3909        for &DynamicsBandState
3910    {
3911        unsafe fn encode(
3912            self,
3913            encoder: &mut fidl::encoding::Encoder<'_, D>,
3914            offset: usize,
3915            mut depth: fidl::encoding::Depth,
3916        ) -> fidl::Result<()> {
3917            encoder.debug_check_bounds::<DynamicsBandState>(offset);
3918            // Vector header
3919            let max_ordinal: u64 = self.max_ordinal_present();
3920            encoder.write_num(max_ordinal, offset);
3921            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3922            // Calling encoder.out_of_line_offset(0) is not allowed.
3923            if max_ordinal == 0 {
3924                return Ok(());
3925            }
3926            depth.increment()?;
3927            let envelope_size = 8;
3928            let bytes_len = max_ordinal as usize * envelope_size;
3929            #[allow(unused_variables)]
3930            let offset = encoder.out_of_line_offset(bytes_len);
3931            let mut _prev_end_offset: usize = 0;
3932            if 1 > max_ordinal {
3933                return Ok(());
3934            }
3935
3936            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3937            // are envelope_size bytes.
3938            let cur_offset: usize = (1 - 1) * envelope_size;
3939
3940            // Zero reserved fields.
3941            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3942
3943            // Safety:
3944            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3945            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3946            //   envelope_size bytes, there is always sufficient room.
3947            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3948                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3949                encoder,
3950                offset + cur_offset,
3951                depth,
3952            )?;
3953
3954            _prev_end_offset = cur_offset + envelope_size;
3955            if 2 > max_ordinal {
3956                return Ok(());
3957            }
3958
3959            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3960            // are envelope_size bytes.
3961            let cur_offset: usize = (2 - 1) * envelope_size;
3962
3963            // Zero reserved fields.
3964            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3965
3966            // Safety:
3967            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3968            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3969            //   envelope_size bytes, there is always sufficient room.
3970            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3971                self.min_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3972                encoder,
3973                offset + cur_offset,
3974                depth,
3975            )?;
3976
3977            _prev_end_offset = cur_offset + envelope_size;
3978            if 3 > max_ordinal {
3979                return Ok(());
3980            }
3981
3982            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3983            // are envelope_size bytes.
3984            let cur_offset: usize = (3 - 1) * envelope_size;
3985
3986            // Zero reserved fields.
3987            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3988
3989            // Safety:
3990            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3991            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3992            //   envelope_size bytes, there is always sufficient room.
3993            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3994                self.max_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3995                encoder,
3996                offset + cur_offset,
3997                depth,
3998            )?;
3999
4000            _prev_end_offset = cur_offset + envelope_size;
4001            if 4 > max_ordinal {
4002                return Ok(());
4003            }
4004
4005            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4006            // are envelope_size bytes.
4007            let cur_offset: usize = (4 - 1) * envelope_size;
4008
4009            // Zero reserved fields.
4010            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4011
4012            // Safety:
4013            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4014            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4015            //   envelope_size bytes, there is always sufficient room.
4016            fidl::encoding::encode_in_envelope_optional::<f32, D>(
4017                self.threshold_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
4018                encoder,
4019                offset + cur_offset,
4020                depth,
4021            )?;
4022
4023            _prev_end_offset = cur_offset + envelope_size;
4024            if 5 > max_ordinal {
4025                return Ok(());
4026            }
4027
4028            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4029            // are envelope_size bytes.
4030            let cur_offset: usize = (5 - 1) * envelope_size;
4031
4032            // Zero reserved fields.
4033            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4034
4035            // Safety:
4036            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4037            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4038            //   envelope_size bytes, there is always sufficient room.
4039            fidl::encoding::encode_in_envelope_optional::<ThresholdType, D>(
4040                self.threshold_type
4041                    .as_ref()
4042                    .map(<ThresholdType as fidl::encoding::ValueTypeMarker>::borrow),
4043                encoder,
4044                offset + cur_offset,
4045                depth,
4046            )?;
4047
4048            _prev_end_offset = cur_offset + envelope_size;
4049            if 6 > max_ordinal {
4050                return Ok(());
4051            }
4052
4053            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4054            // are envelope_size bytes.
4055            let cur_offset: usize = (6 - 1) * envelope_size;
4056
4057            // Zero reserved fields.
4058            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4059
4060            // Safety:
4061            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4062            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4063            //   envelope_size bytes, there is always sufficient room.
4064            fidl::encoding::encode_in_envelope_optional::<f32, D>(
4065                self.ratio.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
4066                encoder,
4067                offset + cur_offset,
4068                depth,
4069            )?;
4070
4071            _prev_end_offset = cur_offset + envelope_size;
4072            if 7 > max_ordinal {
4073                return Ok(());
4074            }
4075
4076            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4077            // are envelope_size bytes.
4078            let cur_offset: usize = (7 - 1) * envelope_size;
4079
4080            // Zero reserved fields.
4081            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4082
4083            // Safety:
4084            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4085            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4086            //   envelope_size bytes, there is always sufficient room.
4087            fidl::encoding::encode_in_envelope_optional::<f32, D>(
4088                self.knee_width_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
4089                encoder,
4090                offset + cur_offset,
4091                depth,
4092            )?;
4093
4094            _prev_end_offset = cur_offset + envelope_size;
4095            if 8 > max_ordinal {
4096                return Ok(());
4097            }
4098
4099            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4100            // are envelope_size bytes.
4101            let cur_offset: usize = (8 - 1) * envelope_size;
4102
4103            // Zero reserved fields.
4104            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4105
4106            // Safety:
4107            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4108            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4109            //   envelope_size bytes, there is always sufficient room.
4110            fidl::encoding::encode_in_envelope_optional::<i64, D>(
4111                self.attack.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4112                encoder,
4113                offset + cur_offset,
4114                depth,
4115            )?;
4116
4117            _prev_end_offset = cur_offset + envelope_size;
4118            if 9 > max_ordinal {
4119                return Ok(());
4120            }
4121
4122            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4123            // are envelope_size bytes.
4124            let cur_offset: usize = (9 - 1) * envelope_size;
4125
4126            // Zero reserved fields.
4127            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4128
4129            // Safety:
4130            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4131            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4132            //   envelope_size bytes, there is always sufficient room.
4133            fidl::encoding::encode_in_envelope_optional::<i64, D>(
4134                self.release.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4135                encoder,
4136                offset + cur_offset,
4137                depth,
4138            )?;
4139
4140            _prev_end_offset = cur_offset + envelope_size;
4141            if 10 > max_ordinal {
4142                return Ok(());
4143            }
4144
4145            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4146            // are envelope_size bytes.
4147            let cur_offset: usize = (10 - 1) * envelope_size;
4148
4149            // Zero reserved fields.
4150            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4151
4152            // Safety:
4153            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4154            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4155            //   envelope_size bytes, there is always sufficient room.
4156            fidl::encoding::encode_in_envelope_optional::<f32, D>(
4157                self.output_gain_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
4158                encoder,
4159                offset + cur_offset,
4160                depth,
4161            )?;
4162
4163            _prev_end_offset = cur_offset + envelope_size;
4164            if 11 > max_ordinal {
4165                return Ok(());
4166            }
4167
4168            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4169            // are envelope_size bytes.
4170            let cur_offset: usize = (11 - 1) * envelope_size;
4171
4172            // Zero reserved fields.
4173            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4174
4175            // Safety:
4176            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4177            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4178            //   envelope_size bytes, there is always sufficient room.
4179            fidl::encoding::encode_in_envelope_optional::<f32, D>(
4180                self.input_gain_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
4181                encoder,
4182                offset + cur_offset,
4183                depth,
4184            )?;
4185
4186            _prev_end_offset = cur_offset + envelope_size;
4187            if 12 > max_ordinal {
4188                return Ok(());
4189            }
4190
4191            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4192            // are envelope_size bytes.
4193            let cur_offset: usize = (12 - 1) * envelope_size;
4194
4195            // Zero reserved fields.
4196            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4197
4198            // Safety:
4199            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4200            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4201            //   envelope_size bytes, there is always sufficient room.
4202            fidl::encoding::encode_in_envelope_optional::<LevelType, D>(
4203                self.level_type
4204                    .as_ref()
4205                    .map(<LevelType as fidl::encoding::ValueTypeMarker>::borrow),
4206                encoder,
4207                offset + cur_offset,
4208                depth,
4209            )?;
4210
4211            _prev_end_offset = cur_offset + envelope_size;
4212            if 13 > max_ordinal {
4213                return Ok(());
4214            }
4215
4216            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4217            // are envelope_size bytes.
4218            let cur_offset: usize = (13 - 1) * envelope_size;
4219
4220            // Zero reserved fields.
4221            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4222
4223            // Safety:
4224            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4225            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4226            //   envelope_size bytes, there is always sufficient room.
4227            fidl::encoding::encode_in_envelope_optional::<i64, D>(
4228                self.lookahead.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4229                encoder,
4230                offset + cur_offset,
4231                depth,
4232            )?;
4233
4234            _prev_end_offset = cur_offset + envelope_size;
4235            if 14 > max_ordinal {
4236                return Ok(());
4237            }
4238
4239            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4240            // are envelope_size bytes.
4241            let cur_offset: usize = (14 - 1) * envelope_size;
4242
4243            // Zero reserved fields.
4244            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4245
4246            // Safety:
4247            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4248            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4249            //   envelope_size bytes, there is always sufficient room.
4250            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4251                self.linked_channels
4252                    .as_ref()
4253                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4254                encoder,
4255                offset + cur_offset,
4256                depth,
4257            )?;
4258
4259            _prev_end_offset = cur_offset + envelope_size;
4260
4261            Ok(())
4262        }
4263    }
4264
4265    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DynamicsBandState {
4266        #[inline(always)]
4267        fn new_empty() -> Self {
4268            Self::default()
4269        }
4270
4271        unsafe fn decode(
4272            &mut self,
4273            decoder: &mut fidl::encoding::Decoder<'_, D>,
4274            offset: usize,
4275            mut depth: fidl::encoding::Depth,
4276        ) -> fidl::Result<()> {
4277            decoder.debug_check_bounds::<Self>(offset);
4278            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4279                None => return Err(fidl::Error::NotNullable),
4280                Some(len) => len,
4281            };
4282            // Calling decoder.out_of_line_offset(0) is not allowed.
4283            if len == 0 {
4284                return Ok(());
4285            };
4286            depth.increment()?;
4287            let envelope_size = 8;
4288            let bytes_len = len * envelope_size;
4289            let offset = decoder.out_of_line_offset(bytes_len)?;
4290            // Decode the envelope for each type.
4291            let mut _next_ordinal_to_read = 0;
4292            let mut next_offset = offset;
4293            let end_offset = offset + bytes_len;
4294            _next_ordinal_to_read += 1;
4295            if next_offset >= end_offset {
4296                return Ok(());
4297            }
4298
4299            // Decode unknown envelopes for gaps in ordinals.
4300            while _next_ordinal_to_read < 1 {
4301                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4302                _next_ordinal_to_read += 1;
4303                next_offset += envelope_size;
4304            }
4305
4306            let next_out_of_line = decoder.next_out_of_line();
4307            let handles_before = decoder.remaining_handles();
4308            if let Some((inlined, num_bytes, num_handles)) =
4309                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4310            {
4311                let member_inline_size =
4312                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4313                if inlined != (member_inline_size <= 4) {
4314                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4315                }
4316                let inner_offset;
4317                let mut inner_depth = depth.clone();
4318                if inlined {
4319                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4320                    inner_offset = next_offset;
4321                } else {
4322                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4323                    inner_depth.increment()?;
4324                }
4325                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
4326                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4327                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4328                {
4329                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4330                }
4331                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4332                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4333                }
4334            }
4335
4336            next_offset += envelope_size;
4337            _next_ordinal_to_read += 1;
4338            if next_offset >= end_offset {
4339                return Ok(());
4340            }
4341
4342            // Decode unknown envelopes for gaps in ordinals.
4343            while _next_ordinal_to_read < 2 {
4344                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4345                _next_ordinal_to_read += 1;
4346                next_offset += envelope_size;
4347            }
4348
4349            let next_out_of_line = decoder.next_out_of_line();
4350            let handles_before = decoder.remaining_handles();
4351            if let Some((inlined, num_bytes, num_handles)) =
4352                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4353            {
4354                let member_inline_size =
4355                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4356                if inlined != (member_inline_size <= 4) {
4357                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4358                }
4359                let inner_offset;
4360                let mut inner_depth = depth.clone();
4361                if inlined {
4362                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4363                    inner_offset = next_offset;
4364                } else {
4365                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4366                    inner_depth.increment()?;
4367                }
4368                let val_ref = self.min_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
4369                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4370                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4371                {
4372                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4373                }
4374                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4375                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4376                }
4377            }
4378
4379            next_offset += envelope_size;
4380            _next_ordinal_to_read += 1;
4381            if next_offset >= end_offset {
4382                return Ok(());
4383            }
4384
4385            // Decode unknown envelopes for gaps in ordinals.
4386            while _next_ordinal_to_read < 3 {
4387                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4388                _next_ordinal_to_read += 1;
4389                next_offset += envelope_size;
4390            }
4391
4392            let next_out_of_line = decoder.next_out_of_line();
4393            let handles_before = decoder.remaining_handles();
4394            if let Some((inlined, num_bytes, num_handles)) =
4395                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4396            {
4397                let member_inline_size =
4398                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4399                if inlined != (member_inline_size <= 4) {
4400                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4401                }
4402                let inner_offset;
4403                let mut inner_depth = depth.clone();
4404                if inlined {
4405                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4406                    inner_offset = next_offset;
4407                } else {
4408                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4409                    inner_depth.increment()?;
4410                }
4411                let val_ref = self.max_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
4412                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4413                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4414                {
4415                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4416                }
4417                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4418                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4419                }
4420            }
4421
4422            next_offset += envelope_size;
4423            _next_ordinal_to_read += 1;
4424            if next_offset >= end_offset {
4425                return Ok(());
4426            }
4427
4428            // Decode unknown envelopes for gaps in ordinals.
4429            while _next_ordinal_to_read < 4 {
4430                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4431                _next_ordinal_to_read += 1;
4432                next_offset += envelope_size;
4433            }
4434
4435            let next_out_of_line = decoder.next_out_of_line();
4436            let handles_before = decoder.remaining_handles();
4437            if let Some((inlined, num_bytes, num_handles)) =
4438                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4439            {
4440                let member_inline_size =
4441                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4442                if inlined != (member_inline_size <= 4) {
4443                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4444                }
4445                let inner_offset;
4446                let mut inner_depth = depth.clone();
4447                if inlined {
4448                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4449                    inner_offset = next_offset;
4450                } else {
4451                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4452                    inner_depth.increment()?;
4453                }
4454                let val_ref = self.threshold_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
4455                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
4456                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4457                {
4458                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4459                }
4460                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4461                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4462                }
4463            }
4464
4465            next_offset += envelope_size;
4466            _next_ordinal_to_read += 1;
4467            if next_offset >= end_offset {
4468                return Ok(());
4469            }
4470
4471            // Decode unknown envelopes for gaps in ordinals.
4472            while _next_ordinal_to_read < 5 {
4473                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4474                _next_ordinal_to_read += 1;
4475                next_offset += envelope_size;
4476            }
4477
4478            let next_out_of_line = decoder.next_out_of_line();
4479            let handles_before = decoder.remaining_handles();
4480            if let Some((inlined, num_bytes, num_handles)) =
4481                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4482            {
4483                let member_inline_size =
4484                    <ThresholdType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4485                if inlined != (member_inline_size <= 4) {
4486                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4487                }
4488                let inner_offset;
4489                let mut inner_depth = depth.clone();
4490                if inlined {
4491                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4492                    inner_offset = next_offset;
4493                } else {
4494                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4495                    inner_depth.increment()?;
4496                }
4497                let val_ref =
4498                    self.threshold_type.get_or_insert_with(|| fidl::new_empty!(ThresholdType, D));
4499                fidl::decode!(ThresholdType, D, val_ref, decoder, inner_offset, inner_depth)?;
4500                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4501                {
4502                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4503                }
4504                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4505                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4506                }
4507            }
4508
4509            next_offset += envelope_size;
4510            _next_ordinal_to_read += 1;
4511            if next_offset >= end_offset {
4512                return Ok(());
4513            }
4514
4515            // Decode unknown envelopes for gaps in ordinals.
4516            while _next_ordinal_to_read < 6 {
4517                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4518                _next_ordinal_to_read += 1;
4519                next_offset += envelope_size;
4520            }
4521
4522            let next_out_of_line = decoder.next_out_of_line();
4523            let handles_before = decoder.remaining_handles();
4524            if let Some((inlined, num_bytes, num_handles)) =
4525                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4526            {
4527                let member_inline_size =
4528                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4529                if inlined != (member_inline_size <= 4) {
4530                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4531                }
4532                let inner_offset;
4533                let mut inner_depth = depth.clone();
4534                if inlined {
4535                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4536                    inner_offset = next_offset;
4537                } else {
4538                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4539                    inner_depth.increment()?;
4540                }
4541                let val_ref = self.ratio.get_or_insert_with(|| fidl::new_empty!(f32, D));
4542                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
4543                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4544                {
4545                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4546                }
4547                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4548                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4549                }
4550            }
4551
4552            next_offset += envelope_size;
4553            _next_ordinal_to_read += 1;
4554            if next_offset >= end_offset {
4555                return Ok(());
4556            }
4557
4558            // Decode unknown envelopes for gaps in ordinals.
4559            while _next_ordinal_to_read < 7 {
4560                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4561                _next_ordinal_to_read += 1;
4562                next_offset += envelope_size;
4563            }
4564
4565            let next_out_of_line = decoder.next_out_of_line();
4566            let handles_before = decoder.remaining_handles();
4567            if let Some((inlined, num_bytes, num_handles)) =
4568                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4569            {
4570                let member_inline_size =
4571                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4572                if inlined != (member_inline_size <= 4) {
4573                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4574                }
4575                let inner_offset;
4576                let mut inner_depth = depth.clone();
4577                if inlined {
4578                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4579                    inner_offset = next_offset;
4580                } else {
4581                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4582                    inner_depth.increment()?;
4583                }
4584                let val_ref = self.knee_width_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
4585                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
4586                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4587                {
4588                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4589                }
4590                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4591                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4592                }
4593            }
4594
4595            next_offset += envelope_size;
4596            _next_ordinal_to_read += 1;
4597            if next_offset >= end_offset {
4598                return Ok(());
4599            }
4600
4601            // Decode unknown envelopes for gaps in ordinals.
4602            while _next_ordinal_to_read < 8 {
4603                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4604                _next_ordinal_to_read += 1;
4605                next_offset += envelope_size;
4606            }
4607
4608            let next_out_of_line = decoder.next_out_of_line();
4609            let handles_before = decoder.remaining_handles();
4610            if let Some((inlined, num_bytes, num_handles)) =
4611                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4612            {
4613                let member_inline_size =
4614                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4615                if inlined != (member_inline_size <= 4) {
4616                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4617                }
4618                let inner_offset;
4619                let mut inner_depth = depth.clone();
4620                if inlined {
4621                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4622                    inner_offset = next_offset;
4623                } else {
4624                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4625                    inner_depth.increment()?;
4626                }
4627                let val_ref = self.attack.get_or_insert_with(|| fidl::new_empty!(i64, D));
4628                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4629                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4630                {
4631                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4632                }
4633                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4634                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4635                }
4636            }
4637
4638            next_offset += envelope_size;
4639            _next_ordinal_to_read += 1;
4640            if next_offset >= end_offset {
4641                return Ok(());
4642            }
4643
4644            // Decode unknown envelopes for gaps in ordinals.
4645            while _next_ordinal_to_read < 9 {
4646                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4647                _next_ordinal_to_read += 1;
4648                next_offset += envelope_size;
4649            }
4650
4651            let next_out_of_line = decoder.next_out_of_line();
4652            let handles_before = decoder.remaining_handles();
4653            if let Some((inlined, num_bytes, num_handles)) =
4654                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4655            {
4656                let member_inline_size =
4657                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4658                if inlined != (member_inline_size <= 4) {
4659                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4660                }
4661                let inner_offset;
4662                let mut inner_depth = depth.clone();
4663                if inlined {
4664                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4665                    inner_offset = next_offset;
4666                } else {
4667                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4668                    inner_depth.increment()?;
4669                }
4670                let val_ref = self.release.get_or_insert_with(|| fidl::new_empty!(i64, D));
4671                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4672                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4673                {
4674                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4675                }
4676                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4677                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4678                }
4679            }
4680
4681            next_offset += envelope_size;
4682            _next_ordinal_to_read += 1;
4683            if next_offset >= end_offset {
4684                return Ok(());
4685            }
4686
4687            // Decode unknown envelopes for gaps in ordinals.
4688            while _next_ordinal_to_read < 10 {
4689                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4690                _next_ordinal_to_read += 1;
4691                next_offset += envelope_size;
4692            }
4693
4694            let next_out_of_line = decoder.next_out_of_line();
4695            let handles_before = decoder.remaining_handles();
4696            if let Some((inlined, num_bytes, num_handles)) =
4697                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4698            {
4699                let member_inline_size =
4700                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4701                if inlined != (member_inline_size <= 4) {
4702                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4703                }
4704                let inner_offset;
4705                let mut inner_depth = depth.clone();
4706                if inlined {
4707                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4708                    inner_offset = next_offset;
4709                } else {
4710                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4711                    inner_depth.increment()?;
4712                }
4713                let val_ref = self.output_gain_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
4714                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
4715                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4716                {
4717                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4718                }
4719                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4720                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4721                }
4722            }
4723
4724            next_offset += envelope_size;
4725            _next_ordinal_to_read += 1;
4726            if next_offset >= end_offset {
4727                return Ok(());
4728            }
4729
4730            // Decode unknown envelopes for gaps in ordinals.
4731            while _next_ordinal_to_read < 11 {
4732                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4733                _next_ordinal_to_read += 1;
4734                next_offset += envelope_size;
4735            }
4736
4737            let next_out_of_line = decoder.next_out_of_line();
4738            let handles_before = decoder.remaining_handles();
4739            if let Some((inlined, num_bytes, num_handles)) =
4740                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4741            {
4742                let member_inline_size =
4743                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4744                if inlined != (member_inline_size <= 4) {
4745                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4746                }
4747                let inner_offset;
4748                let mut inner_depth = depth.clone();
4749                if inlined {
4750                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4751                    inner_offset = next_offset;
4752                } else {
4753                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4754                    inner_depth.increment()?;
4755                }
4756                let val_ref = self.input_gain_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
4757                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
4758                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4759                {
4760                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4761                }
4762                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4763                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4764                }
4765            }
4766
4767            next_offset += envelope_size;
4768            _next_ordinal_to_read += 1;
4769            if next_offset >= end_offset {
4770                return Ok(());
4771            }
4772
4773            // Decode unknown envelopes for gaps in ordinals.
4774            while _next_ordinal_to_read < 12 {
4775                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4776                _next_ordinal_to_read += 1;
4777                next_offset += envelope_size;
4778            }
4779
4780            let next_out_of_line = decoder.next_out_of_line();
4781            let handles_before = decoder.remaining_handles();
4782            if let Some((inlined, num_bytes, num_handles)) =
4783                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4784            {
4785                let member_inline_size =
4786                    <LevelType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4787                if inlined != (member_inline_size <= 4) {
4788                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4789                }
4790                let inner_offset;
4791                let mut inner_depth = depth.clone();
4792                if inlined {
4793                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4794                    inner_offset = next_offset;
4795                } else {
4796                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4797                    inner_depth.increment()?;
4798                }
4799                let val_ref = self.level_type.get_or_insert_with(|| fidl::new_empty!(LevelType, D));
4800                fidl::decode!(LevelType, D, val_ref, decoder, inner_offset, inner_depth)?;
4801                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4802                {
4803                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4804                }
4805                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4806                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4807                }
4808            }
4809
4810            next_offset += envelope_size;
4811            _next_ordinal_to_read += 1;
4812            if next_offset >= end_offset {
4813                return Ok(());
4814            }
4815
4816            // Decode unknown envelopes for gaps in ordinals.
4817            while _next_ordinal_to_read < 13 {
4818                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4819                _next_ordinal_to_read += 1;
4820                next_offset += envelope_size;
4821            }
4822
4823            let next_out_of_line = decoder.next_out_of_line();
4824            let handles_before = decoder.remaining_handles();
4825            if let Some((inlined, num_bytes, num_handles)) =
4826                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4827            {
4828                let member_inline_size =
4829                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4830                if inlined != (member_inline_size <= 4) {
4831                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4832                }
4833                let inner_offset;
4834                let mut inner_depth = depth.clone();
4835                if inlined {
4836                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4837                    inner_offset = next_offset;
4838                } else {
4839                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4840                    inner_depth.increment()?;
4841                }
4842                let val_ref = self.lookahead.get_or_insert_with(|| fidl::new_empty!(i64, D));
4843                fidl::decode!(i64, 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 < 14 {
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.linked_channels.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 DynamicsElementState {
4910        #[inline(always)]
4911        fn max_ordinal_present(&self) -> u64 {
4912            if let Some(_) = self.band_states {
4913                return 1;
4914            }
4915            0
4916        }
4917    }
4918
4919    impl fidl::encoding::ValueTypeMarker for DynamicsElementState {
4920        type Borrowed<'a> = &'a Self;
4921        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4922            value
4923        }
4924    }
4925
4926    unsafe impl fidl::encoding::TypeMarker for DynamicsElementState {
4927        type Owned = Self;
4928
4929        #[inline(always)]
4930        fn inline_align(_context: fidl::encoding::Context) -> usize {
4931            8
4932        }
4933
4934        #[inline(always)]
4935        fn inline_size(_context: fidl::encoding::Context) -> usize {
4936            16
4937        }
4938    }
4939
4940    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DynamicsElementState, D>
4941        for &DynamicsElementState
4942    {
4943        unsafe fn encode(
4944            self,
4945            encoder: &mut fidl::encoding::Encoder<'_, D>,
4946            offset: usize,
4947            mut depth: fidl::encoding::Depth,
4948        ) -> fidl::Result<()> {
4949            encoder.debug_check_bounds::<DynamicsElementState>(offset);
4950            // Vector header
4951            let max_ordinal: u64 = self.max_ordinal_present();
4952            encoder.write_num(max_ordinal, offset);
4953            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4954            // Calling encoder.out_of_line_offset(0) is not allowed.
4955            if max_ordinal == 0 {
4956                return Ok(());
4957            }
4958            depth.increment()?;
4959            let envelope_size = 8;
4960            let bytes_len = max_ordinal as usize * envelope_size;
4961            #[allow(unused_variables)]
4962            let offset = encoder.out_of_line_offset(bytes_len);
4963            let mut _prev_end_offset: usize = 0;
4964            if 1 > max_ordinal {
4965                return Ok(());
4966            }
4967
4968            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4969            // are envelope_size bytes.
4970            let cur_offset: usize = (1 - 1) * envelope_size;
4971
4972            // Zero reserved fields.
4973            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4974
4975            // Safety:
4976            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4977            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4978            //   envelope_size bytes, there is always sufficient room.
4979            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<DynamicsBandState, 64>, D>(
4980            self.band_states.as_ref().map(<fidl::encoding::Vector<DynamicsBandState, 64> as fidl::encoding::ValueTypeMarker>::borrow),
4981            encoder, offset + cur_offset, depth
4982        )?;
4983
4984            _prev_end_offset = cur_offset + envelope_size;
4985
4986            Ok(())
4987        }
4988    }
4989
4990    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DynamicsElementState {
4991        #[inline(always)]
4992        fn new_empty() -> Self {
4993            Self::default()
4994        }
4995
4996        unsafe fn decode(
4997            &mut self,
4998            decoder: &mut fidl::encoding::Decoder<'_, D>,
4999            offset: usize,
5000            mut depth: fidl::encoding::Depth,
5001        ) -> fidl::Result<()> {
5002            decoder.debug_check_bounds::<Self>(offset);
5003            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5004                None => return Err(fidl::Error::NotNullable),
5005                Some(len) => len,
5006            };
5007            // Calling decoder.out_of_line_offset(0) is not allowed.
5008            if len == 0 {
5009                return Ok(());
5010            };
5011            depth.increment()?;
5012            let envelope_size = 8;
5013            let bytes_len = len * envelope_size;
5014            let offset = decoder.out_of_line_offset(bytes_len)?;
5015            // Decode the envelope for each type.
5016            let mut _next_ordinal_to_read = 0;
5017            let mut next_offset = offset;
5018            let end_offset = offset + bytes_len;
5019            _next_ordinal_to_read += 1;
5020            if next_offset >= end_offset {
5021                return Ok(());
5022            }
5023
5024            // Decode unknown envelopes for gaps in ordinals.
5025            while _next_ordinal_to_read < 1 {
5026                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5027                _next_ordinal_to_read += 1;
5028                next_offset += envelope_size;
5029            }
5030
5031            let next_out_of_line = decoder.next_out_of_line();
5032            let handles_before = decoder.remaining_handles();
5033            if let Some((inlined, num_bytes, num_handles)) =
5034                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5035            {
5036                let member_inline_size = <fidl::encoding::Vector<DynamicsBandState, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5037                if inlined != (member_inline_size <= 4) {
5038                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5039                }
5040                let inner_offset;
5041                let mut inner_depth = depth.clone();
5042                if inlined {
5043                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5044                    inner_offset = next_offset;
5045                } else {
5046                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5047                    inner_depth.increment()?;
5048                }
5049                let val_ref = self.band_states.get_or_insert_with(
5050                    || fidl::new_empty!(fidl::encoding::Vector<DynamicsBandState, 64>, D),
5051                );
5052                fidl::decode!(fidl::encoding::Vector<DynamicsBandState, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
5053                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5054                {
5055                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5056                }
5057                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5058                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5059                }
5060            }
5061
5062            next_offset += envelope_size;
5063
5064            // Decode the remaining unknown envelopes.
5065            while next_offset < end_offset {
5066                _next_ordinal_to_read += 1;
5067                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5068                next_offset += envelope_size;
5069            }
5070
5071            Ok(())
5072        }
5073    }
5074
5075    impl Element {
5076        #[inline(always)]
5077        fn max_ordinal_present(&self) -> u64 {
5078            if let Some(_) = self.can_bypass {
5079                return 7;
5080            }
5081            if let Some(_) = self.can_stop {
5082                return 6;
5083            }
5084            if let Some(_) = self.description {
5085                return 5;
5086            }
5087            if let Some(_) = self.can_disable {
5088                return 4;
5089            }
5090            if let Some(_) = self.type_specific {
5091                return 3;
5092            }
5093            if let Some(_) = self.type_ {
5094                return 2;
5095            }
5096            if let Some(_) = self.id {
5097                return 1;
5098            }
5099            0
5100        }
5101    }
5102
5103    impl fidl::encoding::ValueTypeMarker for Element {
5104        type Borrowed<'a> = &'a Self;
5105        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5106            value
5107        }
5108    }
5109
5110    unsafe impl fidl::encoding::TypeMarker for Element {
5111        type Owned = Self;
5112
5113        #[inline(always)]
5114        fn inline_align(_context: fidl::encoding::Context) -> usize {
5115            8
5116        }
5117
5118        #[inline(always)]
5119        fn inline_size(_context: fidl::encoding::Context) -> usize {
5120            16
5121        }
5122    }
5123
5124    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Element, D> for &Element {
5125        unsafe fn encode(
5126            self,
5127            encoder: &mut fidl::encoding::Encoder<'_, D>,
5128            offset: usize,
5129            mut depth: fidl::encoding::Depth,
5130        ) -> fidl::Result<()> {
5131            encoder.debug_check_bounds::<Element>(offset);
5132            // Vector header
5133            let max_ordinal: u64 = self.max_ordinal_present();
5134            encoder.write_num(max_ordinal, offset);
5135            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5136            // Calling encoder.out_of_line_offset(0) is not allowed.
5137            if max_ordinal == 0 {
5138                return Ok(());
5139            }
5140            depth.increment()?;
5141            let envelope_size = 8;
5142            let bytes_len = max_ordinal as usize * envelope_size;
5143            #[allow(unused_variables)]
5144            let offset = encoder.out_of_line_offset(bytes_len);
5145            let mut _prev_end_offset: usize = 0;
5146            if 1 > max_ordinal {
5147                return Ok(());
5148            }
5149
5150            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5151            // are envelope_size bytes.
5152            let cur_offset: usize = (1 - 1) * envelope_size;
5153
5154            // Zero reserved fields.
5155            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5156
5157            // Safety:
5158            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5159            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5160            //   envelope_size bytes, there is always sufficient room.
5161            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5162                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5163                encoder,
5164                offset + cur_offset,
5165                depth,
5166            )?;
5167
5168            _prev_end_offset = cur_offset + envelope_size;
5169            if 2 > max_ordinal {
5170                return Ok(());
5171            }
5172
5173            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5174            // are envelope_size bytes.
5175            let cur_offset: usize = (2 - 1) * envelope_size;
5176
5177            // Zero reserved fields.
5178            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5179
5180            // Safety:
5181            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5182            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5183            //   envelope_size bytes, there is always sufficient room.
5184            fidl::encoding::encode_in_envelope_optional::<ElementType, D>(
5185                self.type_.as_ref().map(<ElementType as fidl::encoding::ValueTypeMarker>::borrow),
5186                encoder,
5187                offset + cur_offset,
5188                depth,
5189            )?;
5190
5191            _prev_end_offset = cur_offset + envelope_size;
5192            if 3 > max_ordinal {
5193                return Ok(());
5194            }
5195
5196            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5197            // are envelope_size bytes.
5198            let cur_offset: usize = (3 - 1) * envelope_size;
5199
5200            // Zero reserved fields.
5201            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5202
5203            // Safety:
5204            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5205            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5206            //   envelope_size bytes, there is always sufficient room.
5207            fidl::encoding::encode_in_envelope_optional::<TypeSpecificElement, D>(
5208                self.type_specific
5209                    .as_ref()
5210                    .map(<TypeSpecificElement as fidl::encoding::ValueTypeMarker>::borrow),
5211                encoder,
5212                offset + cur_offset,
5213                depth,
5214            )?;
5215
5216            _prev_end_offset = cur_offset + envelope_size;
5217            if 4 > max_ordinal {
5218                return Ok(());
5219            }
5220
5221            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5222            // are envelope_size bytes.
5223            let cur_offset: usize = (4 - 1) * envelope_size;
5224
5225            // Zero reserved fields.
5226            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5227
5228            // Safety:
5229            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5230            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5231            //   envelope_size bytes, there is always sufficient room.
5232            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5233                self.can_disable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5234                encoder,
5235                offset + cur_offset,
5236                depth,
5237            )?;
5238
5239            _prev_end_offset = cur_offset + envelope_size;
5240            if 5 > max_ordinal {
5241                return Ok(());
5242            }
5243
5244            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5245            // are envelope_size bytes.
5246            let cur_offset: usize = (5 - 1) * envelope_size;
5247
5248            // Zero reserved fields.
5249            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5250
5251            // Safety:
5252            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5253            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5254            //   envelope_size bytes, there is always sufficient room.
5255            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
5256                self.description.as_ref().map(
5257                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
5258                ),
5259                encoder,
5260                offset + cur_offset,
5261                depth,
5262            )?;
5263
5264            _prev_end_offset = cur_offset + envelope_size;
5265            if 6 > max_ordinal {
5266                return Ok(());
5267            }
5268
5269            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5270            // are envelope_size bytes.
5271            let cur_offset: usize = (6 - 1) * envelope_size;
5272
5273            // Zero reserved fields.
5274            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5275
5276            // Safety:
5277            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5278            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5279            //   envelope_size bytes, there is always sufficient room.
5280            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5281                self.can_stop.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5282                encoder,
5283                offset + cur_offset,
5284                depth,
5285            )?;
5286
5287            _prev_end_offset = cur_offset + envelope_size;
5288            if 7 > max_ordinal {
5289                return Ok(());
5290            }
5291
5292            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5293            // are envelope_size bytes.
5294            let cur_offset: usize = (7 - 1) * envelope_size;
5295
5296            // Zero reserved fields.
5297            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5298
5299            // Safety:
5300            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5301            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5302            //   envelope_size bytes, there is always sufficient room.
5303            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5304                self.can_bypass.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5305                encoder,
5306                offset + cur_offset,
5307                depth,
5308            )?;
5309
5310            _prev_end_offset = cur_offset + envelope_size;
5311
5312            Ok(())
5313        }
5314    }
5315
5316    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Element {
5317        #[inline(always)]
5318        fn new_empty() -> Self {
5319            Self::default()
5320        }
5321
5322        unsafe fn decode(
5323            &mut self,
5324            decoder: &mut fidl::encoding::Decoder<'_, D>,
5325            offset: usize,
5326            mut depth: fidl::encoding::Depth,
5327        ) -> fidl::Result<()> {
5328            decoder.debug_check_bounds::<Self>(offset);
5329            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5330                None => return Err(fidl::Error::NotNullable),
5331                Some(len) => len,
5332            };
5333            // Calling decoder.out_of_line_offset(0) is not allowed.
5334            if len == 0 {
5335                return Ok(());
5336            };
5337            depth.increment()?;
5338            let envelope_size = 8;
5339            let bytes_len = len * envelope_size;
5340            let offset = decoder.out_of_line_offset(bytes_len)?;
5341            // Decode the envelope for each type.
5342            let mut _next_ordinal_to_read = 0;
5343            let mut next_offset = offset;
5344            let end_offset = offset + bytes_len;
5345            _next_ordinal_to_read += 1;
5346            if next_offset >= end_offset {
5347                return Ok(());
5348            }
5349
5350            // Decode unknown envelopes for gaps in ordinals.
5351            while _next_ordinal_to_read < 1 {
5352                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5353                _next_ordinal_to_read += 1;
5354                next_offset += envelope_size;
5355            }
5356
5357            let next_out_of_line = decoder.next_out_of_line();
5358            let handles_before = decoder.remaining_handles();
5359            if let Some((inlined, num_bytes, num_handles)) =
5360                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5361            {
5362                let member_inline_size =
5363                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5364                if inlined != (member_inline_size <= 4) {
5365                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5366                }
5367                let inner_offset;
5368                let mut inner_depth = depth.clone();
5369                if inlined {
5370                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5371                    inner_offset = next_offset;
5372                } else {
5373                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5374                    inner_depth.increment()?;
5375                }
5376                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5377                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5378                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5379                {
5380                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5381                }
5382                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5383                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5384                }
5385            }
5386
5387            next_offset += envelope_size;
5388            _next_ordinal_to_read += 1;
5389            if next_offset >= end_offset {
5390                return Ok(());
5391            }
5392
5393            // Decode unknown envelopes for gaps in ordinals.
5394            while _next_ordinal_to_read < 2 {
5395                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5396                _next_ordinal_to_read += 1;
5397                next_offset += envelope_size;
5398            }
5399
5400            let next_out_of_line = decoder.next_out_of_line();
5401            let handles_before = decoder.remaining_handles();
5402            if let Some((inlined, num_bytes, num_handles)) =
5403                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5404            {
5405                let member_inline_size =
5406                    <ElementType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5407                if inlined != (member_inline_size <= 4) {
5408                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5409                }
5410                let inner_offset;
5411                let mut inner_depth = depth.clone();
5412                if inlined {
5413                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5414                    inner_offset = next_offset;
5415                } else {
5416                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5417                    inner_depth.increment()?;
5418                }
5419                let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(ElementType, D));
5420                fidl::decode!(ElementType, D, val_ref, decoder, inner_offset, inner_depth)?;
5421                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5422                {
5423                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5424                }
5425                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5426                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5427                }
5428            }
5429
5430            next_offset += envelope_size;
5431            _next_ordinal_to_read += 1;
5432            if next_offset >= end_offset {
5433                return Ok(());
5434            }
5435
5436            // Decode unknown envelopes for gaps in ordinals.
5437            while _next_ordinal_to_read < 3 {
5438                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5439                _next_ordinal_to_read += 1;
5440                next_offset += envelope_size;
5441            }
5442
5443            let next_out_of_line = decoder.next_out_of_line();
5444            let handles_before = decoder.remaining_handles();
5445            if let Some((inlined, num_bytes, num_handles)) =
5446                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5447            {
5448                let member_inline_size =
5449                    <TypeSpecificElement as fidl::encoding::TypeMarker>::inline_size(
5450                        decoder.context,
5451                    );
5452                if inlined != (member_inline_size <= 4) {
5453                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5454                }
5455                let inner_offset;
5456                let mut inner_depth = depth.clone();
5457                if inlined {
5458                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5459                    inner_offset = next_offset;
5460                } else {
5461                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5462                    inner_depth.increment()?;
5463                }
5464                let val_ref = self
5465                    .type_specific
5466                    .get_or_insert_with(|| fidl::new_empty!(TypeSpecificElement, D));
5467                fidl::decode!(TypeSpecificElement, D, val_ref, decoder, inner_offset, inner_depth)?;
5468                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5469                {
5470                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5471                }
5472                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5473                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5474                }
5475            }
5476
5477            next_offset += envelope_size;
5478            _next_ordinal_to_read += 1;
5479            if next_offset >= end_offset {
5480                return Ok(());
5481            }
5482
5483            // Decode unknown envelopes for gaps in ordinals.
5484            while _next_ordinal_to_read < 4 {
5485                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5486                _next_ordinal_to_read += 1;
5487                next_offset += envelope_size;
5488            }
5489
5490            let next_out_of_line = decoder.next_out_of_line();
5491            let handles_before = decoder.remaining_handles();
5492            if let Some((inlined, num_bytes, num_handles)) =
5493                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5494            {
5495                let member_inline_size =
5496                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5497                if inlined != (member_inline_size <= 4) {
5498                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5499                }
5500                let inner_offset;
5501                let mut inner_depth = depth.clone();
5502                if inlined {
5503                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5504                    inner_offset = next_offset;
5505                } else {
5506                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5507                    inner_depth.increment()?;
5508                }
5509                let val_ref = self.can_disable.get_or_insert_with(|| fidl::new_empty!(bool, D));
5510                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5511                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5512                {
5513                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5514                }
5515                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5516                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5517                }
5518            }
5519
5520            next_offset += envelope_size;
5521            _next_ordinal_to_read += 1;
5522            if next_offset >= end_offset {
5523                return Ok(());
5524            }
5525
5526            // Decode unknown envelopes for gaps in ordinals.
5527            while _next_ordinal_to_read < 5 {
5528                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5529                _next_ordinal_to_read += 1;
5530                next_offset += envelope_size;
5531            }
5532
5533            let next_out_of_line = decoder.next_out_of_line();
5534            let handles_before = decoder.remaining_handles();
5535            if let Some((inlined, num_bytes, num_handles)) =
5536                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5537            {
5538                let member_inline_size =
5539                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5540                        decoder.context,
5541                    );
5542                if inlined != (member_inline_size <= 4) {
5543                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5544                }
5545                let inner_offset;
5546                let mut inner_depth = depth.clone();
5547                if inlined {
5548                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5549                    inner_offset = next_offset;
5550                } else {
5551                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5552                    inner_depth.increment()?;
5553                }
5554                let val_ref = self
5555                    .description
5556                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
5557                fidl::decode!(
5558                    fidl::encoding::BoundedString<256>,
5559                    D,
5560                    val_ref,
5561                    decoder,
5562                    inner_offset,
5563                    inner_depth
5564                )?;
5565                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5566                {
5567                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5568                }
5569                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5570                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5571                }
5572            }
5573
5574            next_offset += envelope_size;
5575            _next_ordinal_to_read += 1;
5576            if next_offset >= end_offset {
5577                return Ok(());
5578            }
5579
5580            // Decode unknown envelopes for gaps in ordinals.
5581            while _next_ordinal_to_read < 6 {
5582                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5583                _next_ordinal_to_read += 1;
5584                next_offset += envelope_size;
5585            }
5586
5587            let next_out_of_line = decoder.next_out_of_line();
5588            let handles_before = decoder.remaining_handles();
5589            if let Some((inlined, num_bytes, num_handles)) =
5590                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5591            {
5592                let member_inline_size =
5593                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5594                if inlined != (member_inline_size <= 4) {
5595                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5596                }
5597                let inner_offset;
5598                let mut inner_depth = depth.clone();
5599                if inlined {
5600                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5601                    inner_offset = next_offset;
5602                } else {
5603                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5604                    inner_depth.increment()?;
5605                }
5606                let val_ref = self.can_stop.get_or_insert_with(|| fidl::new_empty!(bool, D));
5607                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5608                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5609                {
5610                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5611                }
5612                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5613                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5614                }
5615            }
5616
5617            next_offset += envelope_size;
5618            _next_ordinal_to_read += 1;
5619            if next_offset >= end_offset {
5620                return Ok(());
5621            }
5622
5623            // Decode unknown envelopes for gaps in ordinals.
5624            while _next_ordinal_to_read < 7 {
5625                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5626                _next_ordinal_to_read += 1;
5627                next_offset += envelope_size;
5628            }
5629
5630            let next_out_of_line = decoder.next_out_of_line();
5631            let handles_before = decoder.remaining_handles();
5632            if let Some((inlined, num_bytes, num_handles)) =
5633                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5634            {
5635                let member_inline_size =
5636                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5637                if inlined != (member_inline_size <= 4) {
5638                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5639                }
5640                let inner_offset;
5641                let mut inner_depth = depth.clone();
5642                if inlined {
5643                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5644                    inner_offset = next_offset;
5645                } else {
5646                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5647                    inner_depth.increment()?;
5648                }
5649                let val_ref = self.can_bypass.get_or_insert_with(|| fidl::new_empty!(bool, D));
5650                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5651                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5652                {
5653                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5654                }
5655                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5656                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5657                }
5658            }
5659
5660            next_offset += envelope_size;
5661
5662            // Decode the remaining unknown envelopes.
5663            while next_offset < end_offset {
5664                _next_ordinal_to_read += 1;
5665                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5666                next_offset += envelope_size;
5667            }
5668
5669            Ok(())
5670        }
5671    }
5672
5673    impl ElementState {
5674        #[inline(always)]
5675        fn max_ordinal_present(&self) -> u64 {
5676            if let Some(_) = self.processing_delay {
5677                return 9;
5678            }
5679            if let Some(_) = self.turn_off_delay {
5680                return 8;
5681            }
5682            if let Some(_) = self.turn_on_delay {
5683                return 7;
5684            }
5685            if let Some(_) = self.bypassed {
5686                return 6;
5687            }
5688            if let Some(_) = self.started {
5689                return 5;
5690            }
5691            if let Some(_) = self.vendor_specific_data {
5692                return 4;
5693            }
5694            if let Some(_) = self.latency {
5695                return 3;
5696            }
5697            if let Some(_) = self.enabled {
5698                return 2;
5699            }
5700            if let Some(_) = self.type_specific {
5701                return 1;
5702            }
5703            0
5704        }
5705    }
5706
5707    impl fidl::encoding::ValueTypeMarker for ElementState {
5708        type Borrowed<'a> = &'a Self;
5709        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5710            value
5711        }
5712    }
5713
5714    unsafe impl fidl::encoding::TypeMarker for ElementState {
5715        type Owned = Self;
5716
5717        #[inline(always)]
5718        fn inline_align(_context: fidl::encoding::Context) -> usize {
5719            8
5720        }
5721
5722        #[inline(always)]
5723        fn inline_size(_context: fidl::encoding::Context) -> usize {
5724            16
5725        }
5726    }
5727
5728    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ElementState, D>
5729        for &ElementState
5730    {
5731        unsafe fn encode(
5732            self,
5733            encoder: &mut fidl::encoding::Encoder<'_, D>,
5734            offset: usize,
5735            mut depth: fidl::encoding::Depth,
5736        ) -> fidl::Result<()> {
5737            encoder.debug_check_bounds::<ElementState>(offset);
5738            // Vector header
5739            let max_ordinal: u64 = self.max_ordinal_present();
5740            encoder.write_num(max_ordinal, offset);
5741            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5742            // Calling encoder.out_of_line_offset(0) is not allowed.
5743            if max_ordinal == 0 {
5744                return Ok(());
5745            }
5746            depth.increment()?;
5747            let envelope_size = 8;
5748            let bytes_len = max_ordinal as usize * envelope_size;
5749            #[allow(unused_variables)]
5750            let offset = encoder.out_of_line_offset(bytes_len);
5751            let mut _prev_end_offset: usize = 0;
5752            if 1 > max_ordinal {
5753                return Ok(());
5754            }
5755
5756            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5757            // are envelope_size bytes.
5758            let cur_offset: usize = (1 - 1) * envelope_size;
5759
5760            // Zero reserved fields.
5761            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5762
5763            // Safety:
5764            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5765            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5766            //   envelope_size bytes, there is always sufficient room.
5767            fidl::encoding::encode_in_envelope_optional::<TypeSpecificElementState, D>(
5768                self.type_specific
5769                    .as_ref()
5770                    .map(<TypeSpecificElementState as fidl::encoding::ValueTypeMarker>::borrow),
5771                encoder,
5772                offset + cur_offset,
5773                depth,
5774            )?;
5775
5776            _prev_end_offset = cur_offset + envelope_size;
5777            if 2 > max_ordinal {
5778                return Ok(());
5779            }
5780
5781            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5782            // are envelope_size bytes.
5783            let cur_offset: usize = (2 - 1) * envelope_size;
5784
5785            // Zero reserved fields.
5786            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5787
5788            // Safety:
5789            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5790            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5791            //   envelope_size bytes, there is always sufficient room.
5792            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5793                self.enabled.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5794                encoder,
5795                offset + cur_offset,
5796                depth,
5797            )?;
5798
5799            _prev_end_offset = cur_offset + envelope_size;
5800            if 3 > max_ordinal {
5801                return Ok(());
5802            }
5803
5804            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5805            // are envelope_size bytes.
5806            let cur_offset: usize = (3 - 1) * envelope_size;
5807
5808            // Zero reserved fields.
5809            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5810
5811            // Safety:
5812            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5813            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5814            //   envelope_size bytes, there is always sufficient room.
5815            fidl::encoding::encode_in_envelope_optional::<Latency, D>(
5816                self.latency.as_ref().map(<Latency as fidl::encoding::ValueTypeMarker>::borrow),
5817                encoder,
5818                offset + cur_offset,
5819                depth,
5820            )?;
5821
5822            _prev_end_offset = cur_offset + envelope_size;
5823            if 4 > max_ordinal {
5824                return Ok(());
5825            }
5826
5827            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5828            // are envelope_size bytes.
5829            let cur_offset: usize = (4 - 1) * envelope_size;
5830
5831            // Zero reserved fields.
5832            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5833
5834            // Safety:
5835            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5836            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5837            //   envelope_size bytes, there is always sufficient room.
5838            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 4096>, D>(
5839                self.vendor_specific_data.as_ref().map(
5840                    <fidl::encoding::Vector<u8, 4096> as fidl::encoding::ValueTypeMarker>::borrow,
5841                ),
5842                encoder,
5843                offset + cur_offset,
5844                depth,
5845            )?;
5846
5847            _prev_end_offset = cur_offset + envelope_size;
5848            if 5 > max_ordinal {
5849                return Ok(());
5850            }
5851
5852            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5853            // are envelope_size bytes.
5854            let cur_offset: usize = (5 - 1) * envelope_size;
5855
5856            // Zero reserved fields.
5857            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5858
5859            // Safety:
5860            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5861            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5862            //   envelope_size bytes, there is always sufficient room.
5863            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5864                self.started.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5865                encoder,
5866                offset + cur_offset,
5867                depth,
5868            )?;
5869
5870            _prev_end_offset = cur_offset + envelope_size;
5871            if 6 > max_ordinal {
5872                return Ok(());
5873            }
5874
5875            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5876            // are envelope_size bytes.
5877            let cur_offset: usize = (6 - 1) * envelope_size;
5878
5879            // Zero reserved fields.
5880            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5881
5882            // Safety:
5883            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5884            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5885            //   envelope_size bytes, there is always sufficient room.
5886            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5887                self.bypassed.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5888                encoder,
5889                offset + cur_offset,
5890                depth,
5891            )?;
5892
5893            _prev_end_offset = cur_offset + envelope_size;
5894            if 7 > max_ordinal {
5895                return Ok(());
5896            }
5897
5898            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5899            // are envelope_size bytes.
5900            let cur_offset: usize = (7 - 1) * envelope_size;
5901
5902            // Zero reserved fields.
5903            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5904
5905            // Safety:
5906            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5907            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5908            //   envelope_size bytes, there is always sufficient room.
5909            fidl::encoding::encode_in_envelope_optional::<i64, D>(
5910                self.turn_on_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5911                encoder,
5912                offset + cur_offset,
5913                depth,
5914            )?;
5915
5916            _prev_end_offset = cur_offset + envelope_size;
5917            if 8 > max_ordinal {
5918                return Ok(());
5919            }
5920
5921            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5922            // are envelope_size bytes.
5923            let cur_offset: usize = (8 - 1) * envelope_size;
5924
5925            // Zero reserved fields.
5926            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5927
5928            // Safety:
5929            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5930            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5931            //   envelope_size bytes, there is always sufficient room.
5932            fidl::encoding::encode_in_envelope_optional::<i64, D>(
5933                self.turn_off_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5934                encoder,
5935                offset + cur_offset,
5936                depth,
5937            )?;
5938
5939            _prev_end_offset = cur_offset + envelope_size;
5940            if 9 > max_ordinal {
5941                return Ok(());
5942            }
5943
5944            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5945            // are envelope_size bytes.
5946            let cur_offset: usize = (9 - 1) * envelope_size;
5947
5948            // Zero reserved fields.
5949            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5950
5951            // Safety:
5952            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5953            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5954            //   envelope_size bytes, there is always sufficient room.
5955            fidl::encoding::encode_in_envelope_optional::<i64, D>(
5956                self.processing_delay
5957                    .as_ref()
5958                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5959                encoder,
5960                offset + cur_offset,
5961                depth,
5962            )?;
5963
5964            _prev_end_offset = cur_offset + envelope_size;
5965
5966            Ok(())
5967        }
5968    }
5969
5970    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ElementState {
5971        #[inline(always)]
5972        fn new_empty() -> Self {
5973            Self::default()
5974        }
5975
5976        unsafe fn decode(
5977            &mut self,
5978            decoder: &mut fidl::encoding::Decoder<'_, D>,
5979            offset: usize,
5980            mut depth: fidl::encoding::Depth,
5981        ) -> fidl::Result<()> {
5982            decoder.debug_check_bounds::<Self>(offset);
5983            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5984                None => return Err(fidl::Error::NotNullable),
5985                Some(len) => len,
5986            };
5987            // Calling decoder.out_of_line_offset(0) is not allowed.
5988            if len == 0 {
5989                return Ok(());
5990            };
5991            depth.increment()?;
5992            let envelope_size = 8;
5993            let bytes_len = len * envelope_size;
5994            let offset = decoder.out_of_line_offset(bytes_len)?;
5995            // Decode the envelope for each type.
5996            let mut _next_ordinal_to_read = 0;
5997            let mut next_offset = offset;
5998            let end_offset = offset + bytes_len;
5999            _next_ordinal_to_read += 1;
6000            if next_offset >= end_offset {
6001                return Ok(());
6002            }
6003
6004            // Decode unknown envelopes for gaps in ordinals.
6005            while _next_ordinal_to_read < 1 {
6006                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6007                _next_ordinal_to_read += 1;
6008                next_offset += envelope_size;
6009            }
6010
6011            let next_out_of_line = decoder.next_out_of_line();
6012            let handles_before = decoder.remaining_handles();
6013            if let Some((inlined, num_bytes, num_handles)) =
6014                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6015            {
6016                let member_inline_size =
6017                    <TypeSpecificElementState as fidl::encoding::TypeMarker>::inline_size(
6018                        decoder.context,
6019                    );
6020                if inlined != (member_inline_size <= 4) {
6021                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6022                }
6023                let inner_offset;
6024                let mut inner_depth = depth.clone();
6025                if inlined {
6026                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6027                    inner_offset = next_offset;
6028                } else {
6029                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6030                    inner_depth.increment()?;
6031                }
6032                let val_ref = self
6033                    .type_specific
6034                    .get_or_insert_with(|| fidl::new_empty!(TypeSpecificElementState, D));
6035                fidl::decode!(
6036                    TypeSpecificElementState,
6037                    D,
6038                    val_ref,
6039                    decoder,
6040                    inner_offset,
6041                    inner_depth
6042                )?;
6043                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6044                {
6045                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6046                }
6047                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6048                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6049                }
6050            }
6051
6052            next_offset += envelope_size;
6053            _next_ordinal_to_read += 1;
6054            if next_offset >= end_offset {
6055                return Ok(());
6056            }
6057
6058            // Decode unknown envelopes for gaps in ordinals.
6059            while _next_ordinal_to_read < 2 {
6060                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6061                _next_ordinal_to_read += 1;
6062                next_offset += envelope_size;
6063            }
6064
6065            let next_out_of_line = decoder.next_out_of_line();
6066            let handles_before = decoder.remaining_handles();
6067            if let Some((inlined, num_bytes, num_handles)) =
6068                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6069            {
6070                let member_inline_size =
6071                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6072                if inlined != (member_inline_size <= 4) {
6073                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6074                }
6075                let inner_offset;
6076                let mut inner_depth = depth.clone();
6077                if inlined {
6078                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6079                    inner_offset = next_offset;
6080                } else {
6081                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6082                    inner_depth.increment()?;
6083                }
6084                let val_ref = self.enabled.get_or_insert_with(|| fidl::new_empty!(bool, D));
6085                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6086                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6087                {
6088                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6089                }
6090                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6091                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6092                }
6093            }
6094
6095            next_offset += envelope_size;
6096            _next_ordinal_to_read += 1;
6097            if next_offset >= end_offset {
6098                return Ok(());
6099            }
6100
6101            // Decode unknown envelopes for gaps in ordinals.
6102            while _next_ordinal_to_read < 3 {
6103                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6104                _next_ordinal_to_read += 1;
6105                next_offset += envelope_size;
6106            }
6107
6108            let next_out_of_line = decoder.next_out_of_line();
6109            let handles_before = decoder.remaining_handles();
6110            if let Some((inlined, num_bytes, num_handles)) =
6111                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6112            {
6113                let member_inline_size =
6114                    <Latency as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6115                if inlined != (member_inline_size <= 4) {
6116                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6117                }
6118                let inner_offset;
6119                let mut inner_depth = depth.clone();
6120                if inlined {
6121                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6122                    inner_offset = next_offset;
6123                } else {
6124                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6125                    inner_depth.increment()?;
6126                }
6127                let val_ref = self.latency.get_or_insert_with(|| fidl::new_empty!(Latency, D));
6128                fidl::decode!(Latency, D, val_ref, decoder, inner_offset, inner_depth)?;
6129                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6130                {
6131                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6132                }
6133                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6134                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6135                }
6136            }
6137
6138            next_offset += envelope_size;
6139            _next_ordinal_to_read += 1;
6140            if next_offset >= end_offset {
6141                return Ok(());
6142            }
6143
6144            // Decode unknown envelopes for gaps in ordinals.
6145            while _next_ordinal_to_read < 4 {
6146                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6147                _next_ordinal_to_read += 1;
6148                next_offset += envelope_size;
6149            }
6150
6151            let next_out_of_line = decoder.next_out_of_line();
6152            let handles_before = decoder.remaining_handles();
6153            if let Some((inlined, num_bytes, num_handles)) =
6154                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6155            {
6156                let member_inline_size =
6157                    <fidl::encoding::Vector<u8, 4096> as fidl::encoding::TypeMarker>::inline_size(
6158                        decoder.context,
6159                    );
6160                if inlined != (member_inline_size <= 4) {
6161                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6162                }
6163                let inner_offset;
6164                let mut inner_depth = depth.clone();
6165                if inlined {
6166                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6167                    inner_offset = next_offset;
6168                } else {
6169                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6170                    inner_depth.increment()?;
6171                }
6172                let val_ref = self
6173                    .vendor_specific_data
6174                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 4096>, D));
6175                fidl::decode!(fidl::encoding::Vector<u8, 4096>, D, val_ref, decoder, inner_offset, inner_depth)?;
6176                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6177                {
6178                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6179                }
6180                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6181                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6182                }
6183            }
6184
6185            next_offset += envelope_size;
6186            _next_ordinal_to_read += 1;
6187            if next_offset >= end_offset {
6188                return Ok(());
6189            }
6190
6191            // Decode unknown envelopes for gaps in ordinals.
6192            while _next_ordinal_to_read < 5 {
6193                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6194                _next_ordinal_to_read += 1;
6195                next_offset += envelope_size;
6196            }
6197
6198            let next_out_of_line = decoder.next_out_of_line();
6199            let handles_before = decoder.remaining_handles();
6200            if let Some((inlined, num_bytes, num_handles)) =
6201                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6202            {
6203                let member_inline_size =
6204                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6205                if inlined != (member_inline_size <= 4) {
6206                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6207                }
6208                let inner_offset;
6209                let mut inner_depth = depth.clone();
6210                if inlined {
6211                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6212                    inner_offset = next_offset;
6213                } else {
6214                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6215                    inner_depth.increment()?;
6216                }
6217                let val_ref = self.started.get_or_insert_with(|| fidl::new_empty!(bool, D));
6218                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6219                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6220                {
6221                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6222                }
6223                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6224                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6225                }
6226            }
6227
6228            next_offset += envelope_size;
6229            _next_ordinal_to_read += 1;
6230            if next_offset >= end_offset {
6231                return Ok(());
6232            }
6233
6234            // Decode unknown envelopes for gaps in ordinals.
6235            while _next_ordinal_to_read < 6 {
6236                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6237                _next_ordinal_to_read += 1;
6238                next_offset += envelope_size;
6239            }
6240
6241            let next_out_of_line = decoder.next_out_of_line();
6242            let handles_before = decoder.remaining_handles();
6243            if let Some((inlined, num_bytes, num_handles)) =
6244                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6245            {
6246                let member_inline_size =
6247                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6248                if inlined != (member_inline_size <= 4) {
6249                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6250                }
6251                let inner_offset;
6252                let mut inner_depth = depth.clone();
6253                if inlined {
6254                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6255                    inner_offset = next_offset;
6256                } else {
6257                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6258                    inner_depth.increment()?;
6259                }
6260                let val_ref = self.bypassed.get_or_insert_with(|| fidl::new_empty!(bool, D));
6261                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6262                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6263                {
6264                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6265                }
6266                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6267                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6268                }
6269            }
6270
6271            next_offset += envelope_size;
6272            _next_ordinal_to_read += 1;
6273            if next_offset >= end_offset {
6274                return Ok(());
6275            }
6276
6277            // Decode unknown envelopes for gaps in ordinals.
6278            while _next_ordinal_to_read < 7 {
6279                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6280                _next_ordinal_to_read += 1;
6281                next_offset += envelope_size;
6282            }
6283
6284            let next_out_of_line = decoder.next_out_of_line();
6285            let handles_before = decoder.remaining_handles();
6286            if let Some((inlined, num_bytes, num_handles)) =
6287                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6288            {
6289                let member_inline_size =
6290                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6291                if inlined != (member_inline_size <= 4) {
6292                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6293                }
6294                let inner_offset;
6295                let mut inner_depth = depth.clone();
6296                if inlined {
6297                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6298                    inner_offset = next_offset;
6299                } else {
6300                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6301                    inner_depth.increment()?;
6302                }
6303                let val_ref = self.turn_on_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6304                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6305                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6306                {
6307                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6308                }
6309                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6310                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6311                }
6312            }
6313
6314            next_offset += envelope_size;
6315            _next_ordinal_to_read += 1;
6316            if next_offset >= end_offset {
6317                return Ok(());
6318            }
6319
6320            // Decode unknown envelopes for gaps in ordinals.
6321            while _next_ordinal_to_read < 8 {
6322                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6323                _next_ordinal_to_read += 1;
6324                next_offset += envelope_size;
6325            }
6326
6327            let next_out_of_line = decoder.next_out_of_line();
6328            let handles_before = decoder.remaining_handles();
6329            if let Some((inlined, num_bytes, num_handles)) =
6330                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6331            {
6332                let member_inline_size =
6333                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6334                if inlined != (member_inline_size <= 4) {
6335                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6336                }
6337                let inner_offset;
6338                let mut inner_depth = depth.clone();
6339                if inlined {
6340                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6341                    inner_offset = next_offset;
6342                } else {
6343                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6344                    inner_depth.increment()?;
6345                }
6346                let val_ref = self.turn_off_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6347                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6348                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6349                {
6350                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6351                }
6352                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6353                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6354                }
6355            }
6356
6357            next_offset += envelope_size;
6358            _next_ordinal_to_read += 1;
6359            if next_offset >= end_offset {
6360                return Ok(());
6361            }
6362
6363            // Decode unknown envelopes for gaps in ordinals.
6364            while _next_ordinal_to_read < 9 {
6365                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6366                _next_ordinal_to_read += 1;
6367                next_offset += envelope_size;
6368            }
6369
6370            let next_out_of_line = decoder.next_out_of_line();
6371            let handles_before = decoder.remaining_handles();
6372            if let Some((inlined, num_bytes, num_handles)) =
6373                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6374            {
6375                let member_inline_size =
6376                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6377                if inlined != (member_inline_size <= 4) {
6378                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6379                }
6380                let inner_offset;
6381                let mut inner_depth = depth.clone();
6382                if inlined {
6383                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6384                    inner_offset = next_offset;
6385                } else {
6386                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6387                    inner_depth.increment()?;
6388                }
6389                let val_ref = self.processing_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6390                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6391                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6392                {
6393                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6394                }
6395                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6396                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6397                }
6398            }
6399
6400            next_offset += envelope_size;
6401
6402            // Decode the remaining unknown envelopes.
6403            while next_offset < end_offset {
6404                _next_ordinal_to_read += 1;
6405                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6406                next_offset += envelope_size;
6407            }
6408
6409            Ok(())
6410        }
6411    }
6412
6413    impl Endpoint {
6414        #[inline(always)]
6415        fn max_ordinal_present(&self) -> u64 {
6416            if let Some(_) = self.plug_detect_capabilities {
6417                return 2;
6418            }
6419            if let Some(_) = self.type_ {
6420                return 1;
6421            }
6422            0
6423        }
6424    }
6425
6426    impl fidl::encoding::ValueTypeMarker for Endpoint {
6427        type Borrowed<'a> = &'a Self;
6428        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6429            value
6430        }
6431    }
6432
6433    unsafe impl fidl::encoding::TypeMarker for Endpoint {
6434        type Owned = Self;
6435
6436        #[inline(always)]
6437        fn inline_align(_context: fidl::encoding::Context) -> usize {
6438            8
6439        }
6440
6441        #[inline(always)]
6442        fn inline_size(_context: fidl::encoding::Context) -> usize {
6443            16
6444        }
6445    }
6446
6447    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Endpoint, D> for &Endpoint {
6448        unsafe fn encode(
6449            self,
6450            encoder: &mut fidl::encoding::Encoder<'_, D>,
6451            offset: usize,
6452            mut depth: fidl::encoding::Depth,
6453        ) -> fidl::Result<()> {
6454            encoder.debug_check_bounds::<Endpoint>(offset);
6455            // Vector header
6456            let max_ordinal: u64 = self.max_ordinal_present();
6457            encoder.write_num(max_ordinal, offset);
6458            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6459            // Calling encoder.out_of_line_offset(0) is not allowed.
6460            if max_ordinal == 0 {
6461                return Ok(());
6462            }
6463            depth.increment()?;
6464            let envelope_size = 8;
6465            let bytes_len = max_ordinal as usize * envelope_size;
6466            #[allow(unused_variables)]
6467            let offset = encoder.out_of_line_offset(bytes_len);
6468            let mut _prev_end_offset: usize = 0;
6469            if 1 > max_ordinal {
6470                return Ok(());
6471            }
6472
6473            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6474            // are envelope_size bytes.
6475            let cur_offset: usize = (1 - 1) * envelope_size;
6476
6477            // Zero reserved fields.
6478            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6479
6480            // Safety:
6481            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6482            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6483            //   envelope_size bytes, there is always sufficient room.
6484            fidl::encoding::encode_in_envelope_optional::<EndpointType, D>(
6485                self.type_.as_ref().map(<EndpointType as fidl::encoding::ValueTypeMarker>::borrow),
6486                encoder,
6487                offset + cur_offset,
6488                depth,
6489            )?;
6490
6491            _prev_end_offset = cur_offset + envelope_size;
6492            if 2 > max_ordinal {
6493                return Ok(());
6494            }
6495
6496            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6497            // are envelope_size bytes.
6498            let cur_offset: usize = (2 - 1) * envelope_size;
6499
6500            // Zero reserved fields.
6501            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6502
6503            // Safety:
6504            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6505            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6506            //   envelope_size bytes, there is always sufficient room.
6507            fidl::encoding::encode_in_envelope_optional::<PlugDetectCapabilities, D>(
6508                self.plug_detect_capabilities
6509                    .as_ref()
6510                    .map(<PlugDetectCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
6511                encoder,
6512                offset + cur_offset,
6513                depth,
6514            )?;
6515
6516            _prev_end_offset = cur_offset + envelope_size;
6517
6518            Ok(())
6519        }
6520    }
6521
6522    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Endpoint {
6523        #[inline(always)]
6524        fn new_empty() -> Self {
6525            Self::default()
6526        }
6527
6528        unsafe fn decode(
6529            &mut self,
6530            decoder: &mut fidl::encoding::Decoder<'_, D>,
6531            offset: usize,
6532            mut depth: fidl::encoding::Depth,
6533        ) -> fidl::Result<()> {
6534            decoder.debug_check_bounds::<Self>(offset);
6535            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6536                None => return Err(fidl::Error::NotNullable),
6537                Some(len) => len,
6538            };
6539            // Calling decoder.out_of_line_offset(0) is not allowed.
6540            if len == 0 {
6541                return Ok(());
6542            };
6543            depth.increment()?;
6544            let envelope_size = 8;
6545            let bytes_len = len * envelope_size;
6546            let offset = decoder.out_of_line_offset(bytes_len)?;
6547            // Decode the envelope for each type.
6548            let mut _next_ordinal_to_read = 0;
6549            let mut next_offset = offset;
6550            let end_offset = offset + bytes_len;
6551            _next_ordinal_to_read += 1;
6552            if next_offset >= end_offset {
6553                return Ok(());
6554            }
6555
6556            // Decode unknown envelopes for gaps in ordinals.
6557            while _next_ordinal_to_read < 1 {
6558                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6559                _next_ordinal_to_read += 1;
6560                next_offset += envelope_size;
6561            }
6562
6563            let next_out_of_line = decoder.next_out_of_line();
6564            let handles_before = decoder.remaining_handles();
6565            if let Some((inlined, num_bytes, num_handles)) =
6566                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6567            {
6568                let member_inline_size =
6569                    <EndpointType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6570                if inlined != (member_inline_size <= 4) {
6571                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6572                }
6573                let inner_offset;
6574                let mut inner_depth = depth.clone();
6575                if inlined {
6576                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6577                    inner_offset = next_offset;
6578                } else {
6579                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6580                    inner_depth.increment()?;
6581                }
6582                let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(EndpointType, D));
6583                fidl::decode!(EndpointType, D, val_ref, decoder, inner_offset, inner_depth)?;
6584                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6585                {
6586                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6587                }
6588                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6589                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6590                }
6591            }
6592
6593            next_offset += envelope_size;
6594            _next_ordinal_to_read += 1;
6595            if next_offset >= end_offset {
6596                return Ok(());
6597            }
6598
6599            // Decode unknown envelopes for gaps in ordinals.
6600            while _next_ordinal_to_read < 2 {
6601                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6602                _next_ordinal_to_read += 1;
6603                next_offset += envelope_size;
6604            }
6605
6606            let next_out_of_line = decoder.next_out_of_line();
6607            let handles_before = decoder.remaining_handles();
6608            if let Some((inlined, num_bytes, num_handles)) =
6609                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6610            {
6611                let member_inline_size =
6612                    <PlugDetectCapabilities as fidl::encoding::TypeMarker>::inline_size(
6613                        decoder.context,
6614                    );
6615                if inlined != (member_inline_size <= 4) {
6616                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6617                }
6618                let inner_offset;
6619                let mut inner_depth = depth.clone();
6620                if inlined {
6621                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6622                    inner_offset = next_offset;
6623                } else {
6624                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6625                    inner_depth.increment()?;
6626                }
6627                let val_ref = self
6628                    .plug_detect_capabilities
6629                    .get_or_insert_with(|| fidl::new_empty!(PlugDetectCapabilities, D));
6630                fidl::decode!(
6631                    PlugDetectCapabilities,
6632                    D,
6633                    val_ref,
6634                    decoder,
6635                    inner_offset,
6636                    inner_depth
6637                )?;
6638                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6639                {
6640                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6641                }
6642                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6643                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6644                }
6645            }
6646
6647            next_offset += envelope_size;
6648
6649            // Decode the remaining unknown envelopes.
6650            while next_offset < end_offset {
6651                _next_ordinal_to_read += 1;
6652                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6653                next_offset += envelope_size;
6654            }
6655
6656            Ok(())
6657        }
6658    }
6659
6660    impl EndpointElementState {
6661        #[inline(always)]
6662        fn max_ordinal_present(&self) -> u64 {
6663            if let Some(_) = self.plug_state {
6664                return 1;
6665            }
6666            0
6667        }
6668    }
6669
6670    impl fidl::encoding::ValueTypeMarker for EndpointElementState {
6671        type Borrowed<'a> = &'a Self;
6672        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6673            value
6674        }
6675    }
6676
6677    unsafe impl fidl::encoding::TypeMarker for EndpointElementState {
6678        type Owned = Self;
6679
6680        #[inline(always)]
6681        fn inline_align(_context: fidl::encoding::Context) -> usize {
6682            8
6683        }
6684
6685        #[inline(always)]
6686        fn inline_size(_context: fidl::encoding::Context) -> usize {
6687            16
6688        }
6689    }
6690
6691    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EndpointElementState, D>
6692        for &EndpointElementState
6693    {
6694        unsafe fn encode(
6695            self,
6696            encoder: &mut fidl::encoding::Encoder<'_, D>,
6697            offset: usize,
6698            mut depth: fidl::encoding::Depth,
6699        ) -> fidl::Result<()> {
6700            encoder.debug_check_bounds::<EndpointElementState>(offset);
6701            // Vector header
6702            let max_ordinal: u64 = self.max_ordinal_present();
6703            encoder.write_num(max_ordinal, offset);
6704            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6705            // Calling encoder.out_of_line_offset(0) is not allowed.
6706            if max_ordinal == 0 {
6707                return Ok(());
6708            }
6709            depth.increment()?;
6710            let envelope_size = 8;
6711            let bytes_len = max_ordinal as usize * envelope_size;
6712            #[allow(unused_variables)]
6713            let offset = encoder.out_of_line_offset(bytes_len);
6714            let mut _prev_end_offset: usize = 0;
6715            if 1 > max_ordinal {
6716                return Ok(());
6717            }
6718
6719            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6720            // are envelope_size bytes.
6721            let cur_offset: usize = (1 - 1) * envelope_size;
6722
6723            // Zero reserved fields.
6724            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6725
6726            // Safety:
6727            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6728            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6729            //   envelope_size bytes, there is always sufficient room.
6730            fidl::encoding::encode_in_envelope_optional::<PlugState, D>(
6731                self.plug_state
6732                    .as_ref()
6733                    .map(<PlugState as fidl::encoding::ValueTypeMarker>::borrow),
6734                encoder,
6735                offset + cur_offset,
6736                depth,
6737            )?;
6738
6739            _prev_end_offset = cur_offset + envelope_size;
6740
6741            Ok(())
6742        }
6743    }
6744
6745    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EndpointElementState {
6746        #[inline(always)]
6747        fn new_empty() -> Self {
6748            Self::default()
6749        }
6750
6751        unsafe fn decode(
6752            &mut self,
6753            decoder: &mut fidl::encoding::Decoder<'_, D>,
6754            offset: usize,
6755            mut depth: fidl::encoding::Depth,
6756        ) -> fidl::Result<()> {
6757            decoder.debug_check_bounds::<Self>(offset);
6758            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6759                None => return Err(fidl::Error::NotNullable),
6760                Some(len) => len,
6761            };
6762            // Calling decoder.out_of_line_offset(0) is not allowed.
6763            if len == 0 {
6764                return Ok(());
6765            };
6766            depth.increment()?;
6767            let envelope_size = 8;
6768            let bytes_len = len * envelope_size;
6769            let offset = decoder.out_of_line_offset(bytes_len)?;
6770            // Decode the envelope for each type.
6771            let mut _next_ordinal_to_read = 0;
6772            let mut next_offset = offset;
6773            let end_offset = offset + bytes_len;
6774            _next_ordinal_to_read += 1;
6775            if next_offset >= end_offset {
6776                return Ok(());
6777            }
6778
6779            // Decode unknown envelopes for gaps in ordinals.
6780            while _next_ordinal_to_read < 1 {
6781                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6782                _next_ordinal_to_read += 1;
6783                next_offset += envelope_size;
6784            }
6785
6786            let next_out_of_line = decoder.next_out_of_line();
6787            let handles_before = decoder.remaining_handles();
6788            if let Some((inlined, num_bytes, num_handles)) =
6789                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6790            {
6791                let member_inline_size =
6792                    <PlugState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6793                if inlined != (member_inline_size <= 4) {
6794                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6795                }
6796                let inner_offset;
6797                let mut inner_depth = depth.clone();
6798                if inlined {
6799                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6800                    inner_offset = next_offset;
6801                } else {
6802                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6803                    inner_depth.increment()?;
6804                }
6805                let val_ref = self.plug_state.get_or_insert_with(|| fidl::new_empty!(PlugState, D));
6806                fidl::decode!(PlugState, D, val_ref, decoder, inner_offset, inner_depth)?;
6807                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6808                {
6809                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6810                }
6811                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6812                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6813                }
6814            }
6815
6816            next_offset += envelope_size;
6817
6818            // Decode the remaining unknown envelopes.
6819            while next_offset < end_offset {
6820                _next_ordinal_to_read += 1;
6821                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6822                next_offset += envelope_size;
6823            }
6824
6825            Ok(())
6826        }
6827    }
6828
6829    impl Equalizer {
6830        #[inline(always)]
6831        fn max_ordinal_present(&self) -> u64 {
6832            if let Some(_) = self.max_gain_db {
6833                return 8;
6834            }
6835            if let Some(_) = self.min_gain_db {
6836                return 7;
6837            }
6838            if let Some(_) = self.max_q {
6839                return 6;
6840            }
6841            if let Some(_) = self.max_frequency {
6842                return 5;
6843            }
6844            if let Some(_) = self.min_frequency {
6845                return 4;
6846            }
6847            if let Some(_) = self.can_disable_bands {
6848                return 3;
6849            }
6850            if let Some(_) = self.supported_controls {
6851                return 2;
6852            }
6853            if let Some(_) = self.bands {
6854                return 1;
6855            }
6856            0
6857        }
6858    }
6859
6860    impl fidl::encoding::ValueTypeMarker for Equalizer {
6861        type Borrowed<'a> = &'a Self;
6862        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6863            value
6864        }
6865    }
6866
6867    unsafe impl fidl::encoding::TypeMarker for Equalizer {
6868        type Owned = Self;
6869
6870        #[inline(always)]
6871        fn inline_align(_context: fidl::encoding::Context) -> usize {
6872            8
6873        }
6874
6875        #[inline(always)]
6876        fn inline_size(_context: fidl::encoding::Context) -> usize {
6877            16
6878        }
6879    }
6880
6881    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Equalizer, D>
6882        for &Equalizer
6883    {
6884        unsafe fn encode(
6885            self,
6886            encoder: &mut fidl::encoding::Encoder<'_, D>,
6887            offset: usize,
6888            mut depth: fidl::encoding::Depth,
6889        ) -> fidl::Result<()> {
6890            encoder.debug_check_bounds::<Equalizer>(offset);
6891            // Vector header
6892            let max_ordinal: u64 = self.max_ordinal_present();
6893            encoder.write_num(max_ordinal, offset);
6894            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6895            // Calling encoder.out_of_line_offset(0) is not allowed.
6896            if max_ordinal == 0 {
6897                return Ok(());
6898            }
6899            depth.increment()?;
6900            let envelope_size = 8;
6901            let bytes_len = max_ordinal as usize * envelope_size;
6902            #[allow(unused_variables)]
6903            let offset = encoder.out_of_line_offset(bytes_len);
6904            let mut _prev_end_offset: usize = 0;
6905            if 1 > max_ordinal {
6906                return Ok(());
6907            }
6908
6909            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6910            // are envelope_size bytes.
6911            let cur_offset: usize = (1 - 1) * envelope_size;
6912
6913            // Zero reserved fields.
6914            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6915
6916            // Safety:
6917            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6918            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6919            //   envelope_size bytes, there is always sufficient room.
6920            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<EqualizerBand, 64>, D>(
6921            self.bands.as_ref().map(<fidl::encoding::Vector<EqualizerBand, 64> as fidl::encoding::ValueTypeMarker>::borrow),
6922            encoder, offset + cur_offset, depth
6923        )?;
6924
6925            _prev_end_offset = cur_offset + envelope_size;
6926            if 2 > max_ordinal {
6927                return Ok(());
6928            }
6929
6930            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6931            // are envelope_size bytes.
6932            let cur_offset: usize = (2 - 1) * envelope_size;
6933
6934            // Zero reserved fields.
6935            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6936
6937            // Safety:
6938            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6939            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6940            //   envelope_size bytes, there is always sufficient room.
6941            fidl::encoding::encode_in_envelope_optional::<EqualizerSupportedControls, D>(
6942                self.supported_controls
6943                    .as_ref()
6944                    .map(<EqualizerSupportedControls as fidl::encoding::ValueTypeMarker>::borrow),
6945                encoder,
6946                offset + cur_offset,
6947                depth,
6948            )?;
6949
6950            _prev_end_offset = cur_offset + envelope_size;
6951            if 3 > max_ordinal {
6952                return Ok(());
6953            }
6954
6955            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6956            // are envelope_size bytes.
6957            let cur_offset: usize = (3 - 1) * envelope_size;
6958
6959            // Zero reserved fields.
6960            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6961
6962            // Safety:
6963            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6964            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6965            //   envelope_size bytes, there is always sufficient room.
6966            fidl::encoding::encode_in_envelope_optional::<bool, D>(
6967                self.can_disable_bands
6968                    .as_ref()
6969                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6970                encoder,
6971                offset + cur_offset,
6972                depth,
6973            )?;
6974
6975            _prev_end_offset = cur_offset + envelope_size;
6976            if 4 > max_ordinal {
6977                return Ok(());
6978            }
6979
6980            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6981            // are envelope_size bytes.
6982            let cur_offset: usize = (4 - 1) * envelope_size;
6983
6984            // Zero reserved fields.
6985            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6986
6987            // Safety:
6988            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6989            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6990            //   envelope_size bytes, there is always sufficient room.
6991            fidl::encoding::encode_in_envelope_optional::<u32, D>(
6992                self.min_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6993                encoder,
6994                offset + cur_offset,
6995                depth,
6996            )?;
6997
6998            _prev_end_offset = cur_offset + envelope_size;
6999            if 5 > max_ordinal {
7000                return Ok(());
7001            }
7002
7003            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7004            // are envelope_size bytes.
7005            let cur_offset: usize = (5 - 1) * envelope_size;
7006
7007            // Zero reserved fields.
7008            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7009
7010            // Safety:
7011            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7012            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7013            //   envelope_size bytes, there is always sufficient room.
7014            fidl::encoding::encode_in_envelope_optional::<u32, D>(
7015                self.max_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
7016                encoder,
7017                offset + cur_offset,
7018                depth,
7019            )?;
7020
7021            _prev_end_offset = cur_offset + envelope_size;
7022            if 6 > max_ordinal {
7023                return Ok(());
7024            }
7025
7026            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7027            // are envelope_size bytes.
7028            let cur_offset: usize = (6 - 1) * envelope_size;
7029
7030            // Zero reserved fields.
7031            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7032
7033            // Safety:
7034            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7035            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7036            //   envelope_size bytes, there is always sufficient room.
7037            fidl::encoding::encode_in_envelope_optional::<f32, D>(
7038                self.max_q.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
7039                encoder,
7040                offset + cur_offset,
7041                depth,
7042            )?;
7043
7044            _prev_end_offset = cur_offset + envelope_size;
7045            if 7 > max_ordinal {
7046                return Ok(());
7047            }
7048
7049            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7050            // are envelope_size bytes.
7051            let cur_offset: usize = (7 - 1) * envelope_size;
7052
7053            // Zero reserved fields.
7054            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7055
7056            // Safety:
7057            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7058            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7059            //   envelope_size bytes, there is always sufficient room.
7060            fidl::encoding::encode_in_envelope_optional::<f32, D>(
7061                self.min_gain_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
7062                encoder,
7063                offset + cur_offset,
7064                depth,
7065            )?;
7066
7067            _prev_end_offset = cur_offset + envelope_size;
7068            if 8 > max_ordinal {
7069                return Ok(());
7070            }
7071
7072            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7073            // are envelope_size bytes.
7074            let cur_offset: usize = (8 - 1) * envelope_size;
7075
7076            // Zero reserved fields.
7077            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7078
7079            // Safety:
7080            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7081            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7082            //   envelope_size bytes, there is always sufficient room.
7083            fidl::encoding::encode_in_envelope_optional::<f32, D>(
7084                self.max_gain_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
7085                encoder,
7086                offset + cur_offset,
7087                depth,
7088            )?;
7089
7090            _prev_end_offset = cur_offset + envelope_size;
7091
7092            Ok(())
7093        }
7094    }
7095
7096    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Equalizer {
7097        #[inline(always)]
7098        fn new_empty() -> Self {
7099            Self::default()
7100        }
7101
7102        unsafe fn decode(
7103            &mut self,
7104            decoder: &mut fidl::encoding::Decoder<'_, D>,
7105            offset: usize,
7106            mut depth: fidl::encoding::Depth,
7107        ) -> fidl::Result<()> {
7108            decoder.debug_check_bounds::<Self>(offset);
7109            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7110                None => return Err(fidl::Error::NotNullable),
7111                Some(len) => len,
7112            };
7113            // Calling decoder.out_of_line_offset(0) is not allowed.
7114            if len == 0 {
7115                return Ok(());
7116            };
7117            depth.increment()?;
7118            let envelope_size = 8;
7119            let bytes_len = len * envelope_size;
7120            let offset = decoder.out_of_line_offset(bytes_len)?;
7121            // Decode the envelope for each type.
7122            let mut _next_ordinal_to_read = 0;
7123            let mut next_offset = offset;
7124            let end_offset = offset + bytes_len;
7125            _next_ordinal_to_read += 1;
7126            if next_offset >= end_offset {
7127                return Ok(());
7128            }
7129
7130            // Decode unknown envelopes for gaps in ordinals.
7131            while _next_ordinal_to_read < 1 {
7132                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7133                _next_ordinal_to_read += 1;
7134                next_offset += envelope_size;
7135            }
7136
7137            let next_out_of_line = decoder.next_out_of_line();
7138            let handles_before = decoder.remaining_handles();
7139            if let Some((inlined, num_bytes, num_handles)) =
7140                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7141            {
7142                let member_inline_size = <fidl::encoding::Vector<EqualizerBand, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7143                if inlined != (member_inline_size <= 4) {
7144                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7145                }
7146                let inner_offset;
7147                let mut inner_depth = depth.clone();
7148                if inlined {
7149                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7150                    inner_offset = next_offset;
7151                } else {
7152                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7153                    inner_depth.increment()?;
7154                }
7155                let val_ref = self.bands.get_or_insert_with(
7156                    || fidl::new_empty!(fidl::encoding::Vector<EqualizerBand, 64>, D),
7157                );
7158                fidl::decode!(fidl::encoding::Vector<EqualizerBand, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
7159                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7160                {
7161                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7162                }
7163                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7164                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7165                }
7166            }
7167
7168            next_offset += envelope_size;
7169            _next_ordinal_to_read += 1;
7170            if next_offset >= end_offset {
7171                return Ok(());
7172            }
7173
7174            // Decode unknown envelopes for gaps in ordinals.
7175            while _next_ordinal_to_read < 2 {
7176                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7177                _next_ordinal_to_read += 1;
7178                next_offset += envelope_size;
7179            }
7180
7181            let next_out_of_line = decoder.next_out_of_line();
7182            let handles_before = decoder.remaining_handles();
7183            if let Some((inlined, num_bytes, num_handles)) =
7184                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7185            {
7186                let member_inline_size =
7187                    <EqualizerSupportedControls as fidl::encoding::TypeMarker>::inline_size(
7188                        decoder.context,
7189                    );
7190                if inlined != (member_inline_size <= 4) {
7191                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7192                }
7193                let inner_offset;
7194                let mut inner_depth = depth.clone();
7195                if inlined {
7196                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7197                    inner_offset = next_offset;
7198                } else {
7199                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7200                    inner_depth.increment()?;
7201                }
7202                let val_ref = self
7203                    .supported_controls
7204                    .get_or_insert_with(|| fidl::new_empty!(EqualizerSupportedControls, D));
7205                fidl::decode!(
7206                    EqualizerSupportedControls,
7207                    D,
7208                    val_ref,
7209                    decoder,
7210                    inner_offset,
7211                    inner_depth
7212                )?;
7213                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7214                {
7215                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7216                }
7217                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7218                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7219                }
7220            }
7221
7222            next_offset += envelope_size;
7223            _next_ordinal_to_read += 1;
7224            if next_offset >= end_offset {
7225                return Ok(());
7226            }
7227
7228            // Decode unknown envelopes for gaps in ordinals.
7229            while _next_ordinal_to_read < 3 {
7230                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7231                _next_ordinal_to_read += 1;
7232                next_offset += envelope_size;
7233            }
7234
7235            let next_out_of_line = decoder.next_out_of_line();
7236            let handles_before = decoder.remaining_handles();
7237            if let Some((inlined, num_bytes, num_handles)) =
7238                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7239            {
7240                let member_inline_size =
7241                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7242                if inlined != (member_inline_size <= 4) {
7243                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7244                }
7245                let inner_offset;
7246                let mut inner_depth = depth.clone();
7247                if inlined {
7248                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7249                    inner_offset = next_offset;
7250                } else {
7251                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7252                    inner_depth.increment()?;
7253                }
7254                let val_ref =
7255                    self.can_disable_bands.get_or_insert_with(|| fidl::new_empty!(bool, D));
7256                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7257                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7258                {
7259                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7260                }
7261                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7262                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7263                }
7264            }
7265
7266            next_offset += envelope_size;
7267            _next_ordinal_to_read += 1;
7268            if next_offset >= end_offset {
7269                return Ok(());
7270            }
7271
7272            // Decode unknown envelopes for gaps in ordinals.
7273            while _next_ordinal_to_read < 4 {
7274                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7275                _next_ordinal_to_read += 1;
7276                next_offset += envelope_size;
7277            }
7278
7279            let next_out_of_line = decoder.next_out_of_line();
7280            let handles_before = decoder.remaining_handles();
7281            if let Some((inlined, num_bytes, num_handles)) =
7282                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7283            {
7284                let member_inline_size =
7285                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7286                if inlined != (member_inline_size <= 4) {
7287                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7288                }
7289                let inner_offset;
7290                let mut inner_depth = depth.clone();
7291                if inlined {
7292                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7293                    inner_offset = next_offset;
7294                } else {
7295                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7296                    inner_depth.increment()?;
7297                }
7298                let val_ref = self.min_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
7299                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7300                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7301                {
7302                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7303                }
7304                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7305                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7306                }
7307            }
7308
7309            next_offset += envelope_size;
7310            _next_ordinal_to_read += 1;
7311            if next_offset >= end_offset {
7312                return Ok(());
7313            }
7314
7315            // Decode unknown envelopes for gaps in ordinals.
7316            while _next_ordinal_to_read < 5 {
7317                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7318                _next_ordinal_to_read += 1;
7319                next_offset += envelope_size;
7320            }
7321
7322            let next_out_of_line = decoder.next_out_of_line();
7323            let handles_before = decoder.remaining_handles();
7324            if let Some((inlined, num_bytes, num_handles)) =
7325                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7326            {
7327                let member_inline_size =
7328                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7329                if inlined != (member_inline_size <= 4) {
7330                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7331                }
7332                let inner_offset;
7333                let mut inner_depth = depth.clone();
7334                if inlined {
7335                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7336                    inner_offset = next_offset;
7337                } else {
7338                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7339                    inner_depth.increment()?;
7340                }
7341                let val_ref = self.max_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
7342                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7343                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7344                {
7345                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7346                }
7347                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7348                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7349                }
7350            }
7351
7352            next_offset += envelope_size;
7353            _next_ordinal_to_read += 1;
7354            if next_offset >= end_offset {
7355                return Ok(());
7356            }
7357
7358            // Decode unknown envelopes for gaps in ordinals.
7359            while _next_ordinal_to_read < 6 {
7360                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7361                _next_ordinal_to_read += 1;
7362                next_offset += envelope_size;
7363            }
7364
7365            let next_out_of_line = decoder.next_out_of_line();
7366            let handles_before = decoder.remaining_handles();
7367            if let Some((inlined, num_bytes, num_handles)) =
7368                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7369            {
7370                let member_inline_size =
7371                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7372                if inlined != (member_inline_size <= 4) {
7373                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7374                }
7375                let inner_offset;
7376                let mut inner_depth = depth.clone();
7377                if inlined {
7378                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7379                    inner_offset = next_offset;
7380                } else {
7381                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7382                    inner_depth.increment()?;
7383                }
7384                let val_ref = self.max_q.get_or_insert_with(|| fidl::new_empty!(f32, D));
7385                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
7386                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7387                {
7388                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7389                }
7390                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7391                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7392                }
7393            }
7394
7395            next_offset += envelope_size;
7396            _next_ordinal_to_read += 1;
7397            if next_offset >= end_offset {
7398                return Ok(());
7399            }
7400
7401            // Decode unknown envelopes for gaps in ordinals.
7402            while _next_ordinal_to_read < 7 {
7403                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7404                _next_ordinal_to_read += 1;
7405                next_offset += envelope_size;
7406            }
7407
7408            let next_out_of_line = decoder.next_out_of_line();
7409            let handles_before = decoder.remaining_handles();
7410            if let Some((inlined, num_bytes, num_handles)) =
7411                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7412            {
7413                let member_inline_size =
7414                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7415                if inlined != (member_inline_size <= 4) {
7416                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7417                }
7418                let inner_offset;
7419                let mut inner_depth = depth.clone();
7420                if inlined {
7421                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7422                    inner_offset = next_offset;
7423                } else {
7424                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7425                    inner_depth.increment()?;
7426                }
7427                let val_ref = self.min_gain_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
7428                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
7429                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7430                {
7431                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7432                }
7433                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7434                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7435                }
7436            }
7437
7438            next_offset += envelope_size;
7439            _next_ordinal_to_read += 1;
7440            if next_offset >= end_offset {
7441                return Ok(());
7442            }
7443
7444            // Decode unknown envelopes for gaps in ordinals.
7445            while _next_ordinal_to_read < 8 {
7446                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7447                _next_ordinal_to_read += 1;
7448                next_offset += envelope_size;
7449            }
7450
7451            let next_out_of_line = decoder.next_out_of_line();
7452            let handles_before = decoder.remaining_handles();
7453            if let Some((inlined, num_bytes, num_handles)) =
7454                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7455            {
7456                let member_inline_size =
7457                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7458                if inlined != (member_inline_size <= 4) {
7459                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7460                }
7461                let inner_offset;
7462                let mut inner_depth = depth.clone();
7463                if inlined {
7464                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7465                    inner_offset = next_offset;
7466                } else {
7467                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7468                    inner_depth.increment()?;
7469                }
7470                let val_ref = self.max_gain_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
7471                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
7472                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7473                {
7474                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7475                }
7476                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7477                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7478                }
7479            }
7480
7481            next_offset += envelope_size;
7482
7483            // Decode the remaining unknown envelopes.
7484            while next_offset < end_offset {
7485                _next_ordinal_to_read += 1;
7486                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7487                next_offset += envelope_size;
7488            }
7489
7490            Ok(())
7491        }
7492    }
7493
7494    impl EqualizerBand {
7495        #[inline(always)]
7496        fn max_ordinal_present(&self) -> u64 {
7497            if let Some(_) = self.id {
7498                return 1;
7499            }
7500            0
7501        }
7502    }
7503
7504    impl fidl::encoding::ValueTypeMarker for EqualizerBand {
7505        type Borrowed<'a> = &'a Self;
7506        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7507            value
7508        }
7509    }
7510
7511    unsafe impl fidl::encoding::TypeMarker for EqualizerBand {
7512        type Owned = Self;
7513
7514        #[inline(always)]
7515        fn inline_align(_context: fidl::encoding::Context) -> usize {
7516            8
7517        }
7518
7519        #[inline(always)]
7520        fn inline_size(_context: fidl::encoding::Context) -> usize {
7521            16
7522        }
7523    }
7524
7525    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EqualizerBand, D>
7526        for &EqualizerBand
7527    {
7528        unsafe fn encode(
7529            self,
7530            encoder: &mut fidl::encoding::Encoder<'_, D>,
7531            offset: usize,
7532            mut depth: fidl::encoding::Depth,
7533        ) -> fidl::Result<()> {
7534            encoder.debug_check_bounds::<EqualizerBand>(offset);
7535            // Vector header
7536            let max_ordinal: u64 = self.max_ordinal_present();
7537            encoder.write_num(max_ordinal, offset);
7538            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7539            // Calling encoder.out_of_line_offset(0) is not allowed.
7540            if max_ordinal == 0 {
7541                return Ok(());
7542            }
7543            depth.increment()?;
7544            let envelope_size = 8;
7545            let bytes_len = max_ordinal as usize * envelope_size;
7546            #[allow(unused_variables)]
7547            let offset = encoder.out_of_line_offset(bytes_len);
7548            let mut _prev_end_offset: usize = 0;
7549            if 1 > max_ordinal {
7550                return Ok(());
7551            }
7552
7553            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7554            // are envelope_size bytes.
7555            let cur_offset: usize = (1 - 1) * envelope_size;
7556
7557            // Zero reserved fields.
7558            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7559
7560            // Safety:
7561            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7562            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7563            //   envelope_size bytes, there is always sufficient room.
7564            fidl::encoding::encode_in_envelope_optional::<u64, D>(
7565                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7566                encoder,
7567                offset + cur_offset,
7568                depth,
7569            )?;
7570
7571            _prev_end_offset = cur_offset + envelope_size;
7572
7573            Ok(())
7574        }
7575    }
7576
7577    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EqualizerBand {
7578        #[inline(always)]
7579        fn new_empty() -> Self {
7580            Self::default()
7581        }
7582
7583        unsafe fn decode(
7584            &mut self,
7585            decoder: &mut fidl::encoding::Decoder<'_, D>,
7586            offset: usize,
7587            mut depth: fidl::encoding::Depth,
7588        ) -> fidl::Result<()> {
7589            decoder.debug_check_bounds::<Self>(offset);
7590            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7591                None => return Err(fidl::Error::NotNullable),
7592                Some(len) => len,
7593            };
7594            // Calling decoder.out_of_line_offset(0) is not allowed.
7595            if len == 0 {
7596                return Ok(());
7597            };
7598            depth.increment()?;
7599            let envelope_size = 8;
7600            let bytes_len = len * envelope_size;
7601            let offset = decoder.out_of_line_offset(bytes_len)?;
7602            // Decode the envelope for each type.
7603            let mut _next_ordinal_to_read = 0;
7604            let mut next_offset = offset;
7605            let end_offset = offset + bytes_len;
7606            _next_ordinal_to_read += 1;
7607            if next_offset >= end_offset {
7608                return Ok(());
7609            }
7610
7611            // Decode unknown envelopes for gaps in ordinals.
7612            while _next_ordinal_to_read < 1 {
7613                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7614                _next_ordinal_to_read += 1;
7615                next_offset += envelope_size;
7616            }
7617
7618            let next_out_of_line = decoder.next_out_of_line();
7619            let handles_before = decoder.remaining_handles();
7620            if let Some((inlined, num_bytes, num_handles)) =
7621                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7622            {
7623                let member_inline_size =
7624                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7625                if inlined != (member_inline_size <= 4) {
7626                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7627                }
7628                let inner_offset;
7629                let mut inner_depth = depth.clone();
7630                if inlined {
7631                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7632                    inner_offset = next_offset;
7633                } else {
7634                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7635                    inner_depth.increment()?;
7636                }
7637                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
7638                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
7639                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7640                {
7641                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7642                }
7643                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7644                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7645                }
7646            }
7647
7648            next_offset += envelope_size;
7649
7650            // Decode the remaining unknown envelopes.
7651            while next_offset < end_offset {
7652                _next_ordinal_to_read += 1;
7653                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7654                next_offset += envelope_size;
7655            }
7656
7657            Ok(())
7658        }
7659    }
7660
7661    impl EqualizerBandState {
7662        #[inline(always)]
7663        fn max_ordinal_present(&self) -> u64 {
7664            if let Some(_) = self.enabled {
7665                return 6;
7666            }
7667            if let Some(_) = self.gain_db {
7668                return 5;
7669            }
7670            if let Some(_) = self.q {
7671                return 4;
7672            }
7673            if let Some(_) = self.frequency {
7674                return 3;
7675            }
7676            if let Some(_) = self.type_ {
7677                return 2;
7678            }
7679            if let Some(_) = self.id {
7680                return 1;
7681            }
7682            0
7683        }
7684    }
7685
7686    impl fidl::encoding::ValueTypeMarker for EqualizerBandState {
7687        type Borrowed<'a> = &'a Self;
7688        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7689            value
7690        }
7691    }
7692
7693    unsafe impl fidl::encoding::TypeMarker for EqualizerBandState {
7694        type Owned = Self;
7695
7696        #[inline(always)]
7697        fn inline_align(_context: fidl::encoding::Context) -> usize {
7698            8
7699        }
7700
7701        #[inline(always)]
7702        fn inline_size(_context: fidl::encoding::Context) -> usize {
7703            16
7704        }
7705    }
7706
7707    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EqualizerBandState, D>
7708        for &EqualizerBandState
7709    {
7710        unsafe fn encode(
7711            self,
7712            encoder: &mut fidl::encoding::Encoder<'_, D>,
7713            offset: usize,
7714            mut depth: fidl::encoding::Depth,
7715        ) -> fidl::Result<()> {
7716            encoder.debug_check_bounds::<EqualizerBandState>(offset);
7717            // Vector header
7718            let max_ordinal: u64 = self.max_ordinal_present();
7719            encoder.write_num(max_ordinal, offset);
7720            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7721            // Calling encoder.out_of_line_offset(0) is not allowed.
7722            if max_ordinal == 0 {
7723                return Ok(());
7724            }
7725            depth.increment()?;
7726            let envelope_size = 8;
7727            let bytes_len = max_ordinal as usize * envelope_size;
7728            #[allow(unused_variables)]
7729            let offset = encoder.out_of_line_offset(bytes_len);
7730            let mut _prev_end_offset: usize = 0;
7731            if 1 > max_ordinal {
7732                return Ok(());
7733            }
7734
7735            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7736            // are envelope_size bytes.
7737            let cur_offset: usize = (1 - 1) * envelope_size;
7738
7739            // Zero reserved fields.
7740            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7741
7742            // Safety:
7743            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7744            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7745            //   envelope_size bytes, there is always sufficient room.
7746            fidl::encoding::encode_in_envelope_optional::<u64, D>(
7747                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7748                encoder,
7749                offset + cur_offset,
7750                depth,
7751            )?;
7752
7753            _prev_end_offset = cur_offset + envelope_size;
7754            if 2 > max_ordinal {
7755                return Ok(());
7756            }
7757
7758            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7759            // are envelope_size bytes.
7760            let cur_offset: usize = (2 - 1) * envelope_size;
7761
7762            // Zero reserved fields.
7763            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7764
7765            // Safety:
7766            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7767            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7768            //   envelope_size bytes, there is always sufficient room.
7769            fidl::encoding::encode_in_envelope_optional::<EqualizerBandType, D>(
7770                self.type_
7771                    .as_ref()
7772                    .map(<EqualizerBandType as fidl::encoding::ValueTypeMarker>::borrow),
7773                encoder,
7774                offset + cur_offset,
7775                depth,
7776            )?;
7777
7778            _prev_end_offset = cur_offset + envelope_size;
7779            if 3 > max_ordinal {
7780                return Ok(());
7781            }
7782
7783            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7784            // are envelope_size bytes.
7785            let cur_offset: usize = (3 - 1) * envelope_size;
7786
7787            // Zero reserved fields.
7788            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7789
7790            // Safety:
7791            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7792            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7793            //   envelope_size bytes, there is always sufficient room.
7794            fidl::encoding::encode_in_envelope_optional::<u32, D>(
7795                self.frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
7796                encoder,
7797                offset + cur_offset,
7798                depth,
7799            )?;
7800
7801            _prev_end_offset = cur_offset + envelope_size;
7802            if 4 > max_ordinal {
7803                return Ok(());
7804            }
7805
7806            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7807            // are envelope_size bytes.
7808            let cur_offset: usize = (4 - 1) * envelope_size;
7809
7810            // Zero reserved fields.
7811            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7812
7813            // Safety:
7814            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7815            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7816            //   envelope_size bytes, there is always sufficient room.
7817            fidl::encoding::encode_in_envelope_optional::<f32, D>(
7818                self.q.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
7819                encoder,
7820                offset + cur_offset,
7821                depth,
7822            )?;
7823
7824            _prev_end_offset = cur_offset + envelope_size;
7825            if 5 > max_ordinal {
7826                return Ok(());
7827            }
7828
7829            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7830            // are envelope_size bytes.
7831            let cur_offset: usize = (5 - 1) * envelope_size;
7832
7833            // Zero reserved fields.
7834            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7835
7836            // Safety:
7837            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7838            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7839            //   envelope_size bytes, there is always sufficient room.
7840            fidl::encoding::encode_in_envelope_optional::<f32, D>(
7841                self.gain_db.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
7842                encoder,
7843                offset + cur_offset,
7844                depth,
7845            )?;
7846
7847            _prev_end_offset = cur_offset + envelope_size;
7848            if 6 > max_ordinal {
7849                return Ok(());
7850            }
7851
7852            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7853            // are envelope_size bytes.
7854            let cur_offset: usize = (6 - 1) * envelope_size;
7855
7856            // Zero reserved fields.
7857            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7858
7859            // Safety:
7860            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7861            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7862            //   envelope_size bytes, there is always sufficient room.
7863            fidl::encoding::encode_in_envelope_optional::<bool, D>(
7864                self.enabled.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7865                encoder,
7866                offset + cur_offset,
7867                depth,
7868            )?;
7869
7870            _prev_end_offset = cur_offset + envelope_size;
7871
7872            Ok(())
7873        }
7874    }
7875
7876    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EqualizerBandState {
7877        #[inline(always)]
7878        fn new_empty() -> Self {
7879            Self::default()
7880        }
7881
7882        unsafe fn decode(
7883            &mut self,
7884            decoder: &mut fidl::encoding::Decoder<'_, D>,
7885            offset: usize,
7886            mut depth: fidl::encoding::Depth,
7887        ) -> fidl::Result<()> {
7888            decoder.debug_check_bounds::<Self>(offset);
7889            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7890                None => return Err(fidl::Error::NotNullable),
7891                Some(len) => len,
7892            };
7893            // Calling decoder.out_of_line_offset(0) is not allowed.
7894            if len == 0 {
7895                return Ok(());
7896            };
7897            depth.increment()?;
7898            let envelope_size = 8;
7899            let bytes_len = len * envelope_size;
7900            let offset = decoder.out_of_line_offset(bytes_len)?;
7901            // Decode the envelope for each type.
7902            let mut _next_ordinal_to_read = 0;
7903            let mut next_offset = offset;
7904            let end_offset = offset + bytes_len;
7905            _next_ordinal_to_read += 1;
7906            if next_offset >= end_offset {
7907                return Ok(());
7908            }
7909
7910            // Decode unknown envelopes for gaps in ordinals.
7911            while _next_ordinal_to_read < 1 {
7912                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7913                _next_ordinal_to_read += 1;
7914                next_offset += envelope_size;
7915            }
7916
7917            let next_out_of_line = decoder.next_out_of_line();
7918            let handles_before = decoder.remaining_handles();
7919            if let Some((inlined, num_bytes, num_handles)) =
7920                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7921            {
7922                let member_inline_size =
7923                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7924                if inlined != (member_inline_size <= 4) {
7925                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7926                }
7927                let inner_offset;
7928                let mut inner_depth = depth.clone();
7929                if inlined {
7930                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7931                    inner_offset = next_offset;
7932                } else {
7933                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7934                    inner_depth.increment()?;
7935                }
7936                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
7937                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
7938                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7939                {
7940                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7941                }
7942                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7943                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7944                }
7945            }
7946
7947            next_offset += envelope_size;
7948            _next_ordinal_to_read += 1;
7949            if next_offset >= end_offset {
7950                return Ok(());
7951            }
7952
7953            // Decode unknown envelopes for gaps in ordinals.
7954            while _next_ordinal_to_read < 2 {
7955                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7956                _next_ordinal_to_read += 1;
7957                next_offset += envelope_size;
7958            }
7959
7960            let next_out_of_line = decoder.next_out_of_line();
7961            let handles_before = decoder.remaining_handles();
7962            if let Some((inlined, num_bytes, num_handles)) =
7963                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7964            {
7965                let member_inline_size =
7966                    <EqualizerBandType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7967                if inlined != (member_inline_size <= 4) {
7968                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7969                }
7970                let inner_offset;
7971                let mut inner_depth = depth.clone();
7972                if inlined {
7973                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7974                    inner_offset = next_offset;
7975                } else {
7976                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7977                    inner_depth.increment()?;
7978                }
7979                let val_ref =
7980                    self.type_.get_or_insert_with(|| fidl::new_empty!(EqualizerBandType, D));
7981                fidl::decode!(EqualizerBandType, D, val_ref, decoder, inner_offset, inner_depth)?;
7982                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7983                {
7984                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7985                }
7986                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7987                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7988                }
7989            }
7990
7991            next_offset += envelope_size;
7992            _next_ordinal_to_read += 1;
7993            if next_offset >= end_offset {
7994                return Ok(());
7995            }
7996
7997            // Decode unknown envelopes for gaps in ordinals.
7998            while _next_ordinal_to_read < 3 {
7999                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8000                _next_ordinal_to_read += 1;
8001                next_offset += envelope_size;
8002            }
8003
8004            let next_out_of_line = decoder.next_out_of_line();
8005            let handles_before = decoder.remaining_handles();
8006            if let Some((inlined, num_bytes, num_handles)) =
8007                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8008            {
8009                let member_inline_size =
8010                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8011                if inlined != (member_inline_size <= 4) {
8012                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8013                }
8014                let inner_offset;
8015                let mut inner_depth = depth.clone();
8016                if inlined {
8017                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8018                    inner_offset = next_offset;
8019                } else {
8020                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8021                    inner_depth.increment()?;
8022                }
8023                let val_ref = self.frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
8024                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
8025                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8026                {
8027                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8028                }
8029                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8030                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8031                }
8032            }
8033
8034            next_offset += envelope_size;
8035            _next_ordinal_to_read += 1;
8036            if next_offset >= end_offset {
8037                return Ok(());
8038            }
8039
8040            // Decode unknown envelopes for gaps in ordinals.
8041            while _next_ordinal_to_read < 4 {
8042                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8043                _next_ordinal_to_read += 1;
8044                next_offset += envelope_size;
8045            }
8046
8047            let next_out_of_line = decoder.next_out_of_line();
8048            let handles_before = decoder.remaining_handles();
8049            if let Some((inlined, num_bytes, num_handles)) =
8050                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8051            {
8052                let member_inline_size =
8053                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8054                if inlined != (member_inline_size <= 4) {
8055                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8056                }
8057                let inner_offset;
8058                let mut inner_depth = depth.clone();
8059                if inlined {
8060                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8061                    inner_offset = next_offset;
8062                } else {
8063                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8064                    inner_depth.increment()?;
8065                }
8066                let val_ref = self.q.get_or_insert_with(|| fidl::new_empty!(f32, D));
8067                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
8068                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8069                {
8070                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8071                }
8072                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8073                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8074                }
8075            }
8076
8077            next_offset += envelope_size;
8078            _next_ordinal_to_read += 1;
8079            if next_offset >= end_offset {
8080                return Ok(());
8081            }
8082
8083            // Decode unknown envelopes for gaps in ordinals.
8084            while _next_ordinal_to_read < 5 {
8085                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8086                _next_ordinal_to_read += 1;
8087                next_offset += envelope_size;
8088            }
8089
8090            let next_out_of_line = decoder.next_out_of_line();
8091            let handles_before = decoder.remaining_handles();
8092            if let Some((inlined, num_bytes, num_handles)) =
8093                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8094            {
8095                let member_inline_size =
8096                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8097                if inlined != (member_inline_size <= 4) {
8098                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8099                }
8100                let inner_offset;
8101                let mut inner_depth = depth.clone();
8102                if inlined {
8103                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8104                    inner_offset = next_offset;
8105                } else {
8106                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8107                    inner_depth.increment()?;
8108                }
8109                let val_ref = self.gain_db.get_or_insert_with(|| fidl::new_empty!(f32, D));
8110                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
8111                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8112                {
8113                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8114                }
8115                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8116                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8117                }
8118            }
8119
8120            next_offset += envelope_size;
8121            _next_ordinal_to_read += 1;
8122            if next_offset >= end_offset {
8123                return Ok(());
8124            }
8125
8126            // Decode unknown envelopes for gaps in ordinals.
8127            while _next_ordinal_to_read < 6 {
8128                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8129                _next_ordinal_to_read += 1;
8130                next_offset += envelope_size;
8131            }
8132
8133            let next_out_of_line = decoder.next_out_of_line();
8134            let handles_before = decoder.remaining_handles();
8135            if let Some((inlined, num_bytes, num_handles)) =
8136                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8137            {
8138                let member_inline_size =
8139                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8140                if inlined != (member_inline_size <= 4) {
8141                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8142                }
8143                let inner_offset;
8144                let mut inner_depth = depth.clone();
8145                if inlined {
8146                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8147                    inner_offset = next_offset;
8148                } else {
8149                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8150                    inner_depth.increment()?;
8151                }
8152                let val_ref = self.enabled.get_or_insert_with(|| fidl::new_empty!(bool, D));
8153                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8154                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8155                {
8156                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8157                }
8158                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8159                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8160                }
8161            }
8162
8163            next_offset += envelope_size;
8164
8165            // Decode the remaining unknown envelopes.
8166            while next_offset < end_offset {
8167                _next_ordinal_to_read += 1;
8168                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8169                next_offset += envelope_size;
8170            }
8171
8172            Ok(())
8173        }
8174    }
8175
8176    impl EqualizerElementState {
8177        #[inline(always)]
8178        fn max_ordinal_present(&self) -> u64 {
8179            if let Some(_) = self.band_states {
8180                return 2;
8181            }
8182            if let Some(_) = self.bands_state {
8183                return 1;
8184            }
8185            0
8186        }
8187    }
8188
8189    impl fidl::encoding::ValueTypeMarker for EqualizerElementState {
8190        type Borrowed<'a> = &'a Self;
8191        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8192            value
8193        }
8194    }
8195
8196    unsafe impl fidl::encoding::TypeMarker for EqualizerElementState {
8197        type Owned = Self;
8198
8199        #[inline(always)]
8200        fn inline_align(_context: fidl::encoding::Context) -> usize {
8201            8
8202        }
8203
8204        #[inline(always)]
8205        fn inline_size(_context: fidl::encoding::Context) -> usize {
8206            16
8207        }
8208    }
8209
8210    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EqualizerElementState, D>
8211        for &EqualizerElementState
8212    {
8213        unsafe fn encode(
8214            self,
8215            encoder: &mut fidl::encoding::Encoder<'_, D>,
8216            offset: usize,
8217            mut depth: fidl::encoding::Depth,
8218        ) -> fidl::Result<()> {
8219            encoder.debug_check_bounds::<EqualizerElementState>(offset);
8220            // Vector header
8221            let max_ordinal: u64 = self.max_ordinal_present();
8222            encoder.write_num(max_ordinal, offset);
8223            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8224            // Calling encoder.out_of_line_offset(0) is not allowed.
8225            if max_ordinal == 0 {
8226                return Ok(());
8227            }
8228            depth.increment()?;
8229            let envelope_size = 8;
8230            let bytes_len = max_ordinal as usize * envelope_size;
8231            #[allow(unused_variables)]
8232            let offset = encoder.out_of_line_offset(bytes_len);
8233            let mut _prev_end_offset: usize = 0;
8234            if 1 > max_ordinal {
8235                return Ok(());
8236            }
8237
8238            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8239            // are envelope_size bytes.
8240            let cur_offset: usize = (1 - 1) * envelope_size;
8241
8242            // Zero reserved fields.
8243            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8244
8245            // Safety:
8246            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8247            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8248            //   envelope_size bytes, there is always sufficient room.
8249            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<EqualizerBandState, 64>, D>(
8250            self.bands_state.as_ref().map(<fidl::encoding::Vector<EqualizerBandState, 64> as fidl::encoding::ValueTypeMarker>::borrow),
8251            encoder, offset + cur_offset, depth
8252        )?;
8253
8254            _prev_end_offset = cur_offset + envelope_size;
8255            if 2 > max_ordinal {
8256                return Ok(());
8257            }
8258
8259            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8260            // are envelope_size bytes.
8261            let cur_offset: usize = (2 - 1) * envelope_size;
8262
8263            // Zero reserved fields.
8264            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8265
8266            // Safety:
8267            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8268            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8269            //   envelope_size bytes, there is always sufficient room.
8270            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<EqualizerBandState, 64>, D>(
8271            self.band_states.as_ref().map(<fidl::encoding::Vector<EqualizerBandState, 64> as fidl::encoding::ValueTypeMarker>::borrow),
8272            encoder, offset + cur_offset, depth
8273        )?;
8274
8275            _prev_end_offset = cur_offset + envelope_size;
8276
8277            Ok(())
8278        }
8279    }
8280
8281    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EqualizerElementState {
8282        #[inline(always)]
8283        fn new_empty() -> Self {
8284            Self::default()
8285        }
8286
8287        unsafe fn decode(
8288            &mut self,
8289            decoder: &mut fidl::encoding::Decoder<'_, D>,
8290            offset: usize,
8291            mut depth: fidl::encoding::Depth,
8292        ) -> fidl::Result<()> {
8293            decoder.debug_check_bounds::<Self>(offset);
8294            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8295                None => return Err(fidl::Error::NotNullable),
8296                Some(len) => len,
8297            };
8298            // Calling decoder.out_of_line_offset(0) is not allowed.
8299            if len == 0 {
8300                return Ok(());
8301            };
8302            depth.increment()?;
8303            let envelope_size = 8;
8304            let bytes_len = len * envelope_size;
8305            let offset = decoder.out_of_line_offset(bytes_len)?;
8306            // Decode the envelope for each type.
8307            let mut _next_ordinal_to_read = 0;
8308            let mut next_offset = offset;
8309            let end_offset = offset + bytes_len;
8310            _next_ordinal_to_read += 1;
8311            if next_offset >= end_offset {
8312                return Ok(());
8313            }
8314
8315            // Decode unknown envelopes for gaps in ordinals.
8316            while _next_ordinal_to_read < 1 {
8317                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8318                _next_ordinal_to_read += 1;
8319                next_offset += envelope_size;
8320            }
8321
8322            let next_out_of_line = decoder.next_out_of_line();
8323            let handles_before = decoder.remaining_handles();
8324            if let Some((inlined, num_bytes, num_handles)) =
8325                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8326            {
8327                let member_inline_size = <fidl::encoding::Vector<EqualizerBandState, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8328                if inlined != (member_inline_size <= 4) {
8329                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8330                }
8331                let inner_offset;
8332                let mut inner_depth = depth.clone();
8333                if inlined {
8334                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8335                    inner_offset = next_offset;
8336                } else {
8337                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8338                    inner_depth.increment()?;
8339                }
8340                let val_ref = self.bands_state.get_or_insert_with(
8341                    || fidl::new_empty!(fidl::encoding::Vector<EqualizerBandState, 64>, D),
8342                );
8343                fidl::decode!(fidl::encoding::Vector<EqualizerBandState, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
8344                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8345                {
8346                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8347                }
8348                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8349                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8350                }
8351            }
8352
8353            next_offset += envelope_size;
8354            _next_ordinal_to_read += 1;
8355            if next_offset >= end_offset {
8356                return Ok(());
8357            }
8358
8359            // Decode unknown envelopes for gaps in ordinals.
8360            while _next_ordinal_to_read < 2 {
8361                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8362                _next_ordinal_to_read += 1;
8363                next_offset += envelope_size;
8364            }
8365
8366            let next_out_of_line = decoder.next_out_of_line();
8367            let handles_before = decoder.remaining_handles();
8368            if let Some((inlined, num_bytes, num_handles)) =
8369                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8370            {
8371                let member_inline_size = <fidl::encoding::Vector<EqualizerBandState, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8372                if inlined != (member_inline_size <= 4) {
8373                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8374                }
8375                let inner_offset;
8376                let mut inner_depth = depth.clone();
8377                if inlined {
8378                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8379                    inner_offset = next_offset;
8380                } else {
8381                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8382                    inner_depth.increment()?;
8383                }
8384                let val_ref = self.band_states.get_or_insert_with(
8385                    || fidl::new_empty!(fidl::encoding::Vector<EqualizerBandState, 64>, D),
8386                );
8387                fidl::decode!(fidl::encoding::Vector<EqualizerBandState, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
8388                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8389                {
8390                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8391                }
8392                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8393                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8394                }
8395            }
8396
8397            next_offset += envelope_size;
8398
8399            // Decode the remaining unknown envelopes.
8400            while next_offset < end_offset {
8401                _next_ordinal_to_read += 1;
8402                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8403                next_offset += envelope_size;
8404            }
8405
8406            Ok(())
8407        }
8408    }
8409
8410    impl Gain {
8411        #[inline(always)]
8412        fn max_ordinal_present(&self) -> u64 {
8413            if let Some(_) = self.min_gain_step {
8414                return 5;
8415            }
8416            if let Some(_) = self.max_gain {
8417                return 4;
8418            }
8419            if let Some(_) = self.min_gain {
8420                return 3;
8421            }
8422            if let Some(_) = self.domain {
8423                return 2;
8424            }
8425            if let Some(_) = self.type_ {
8426                return 1;
8427            }
8428            0
8429        }
8430    }
8431
8432    impl fidl::encoding::ValueTypeMarker for Gain {
8433        type Borrowed<'a> = &'a Self;
8434        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8435            value
8436        }
8437    }
8438
8439    unsafe impl fidl::encoding::TypeMarker for Gain {
8440        type Owned = Self;
8441
8442        #[inline(always)]
8443        fn inline_align(_context: fidl::encoding::Context) -> usize {
8444            8
8445        }
8446
8447        #[inline(always)]
8448        fn inline_size(_context: fidl::encoding::Context) -> usize {
8449            16
8450        }
8451    }
8452
8453    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Gain, D> for &Gain {
8454        unsafe fn encode(
8455            self,
8456            encoder: &mut fidl::encoding::Encoder<'_, D>,
8457            offset: usize,
8458            mut depth: fidl::encoding::Depth,
8459        ) -> fidl::Result<()> {
8460            encoder.debug_check_bounds::<Gain>(offset);
8461            // Vector header
8462            let max_ordinal: u64 = self.max_ordinal_present();
8463            encoder.write_num(max_ordinal, offset);
8464            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8465            // Calling encoder.out_of_line_offset(0) is not allowed.
8466            if max_ordinal == 0 {
8467                return Ok(());
8468            }
8469            depth.increment()?;
8470            let envelope_size = 8;
8471            let bytes_len = max_ordinal as usize * envelope_size;
8472            #[allow(unused_variables)]
8473            let offset = encoder.out_of_line_offset(bytes_len);
8474            let mut _prev_end_offset: usize = 0;
8475            if 1 > max_ordinal {
8476                return Ok(());
8477            }
8478
8479            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8480            // are envelope_size bytes.
8481            let cur_offset: usize = (1 - 1) * envelope_size;
8482
8483            // Zero reserved fields.
8484            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8485
8486            // Safety:
8487            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8488            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8489            //   envelope_size bytes, there is always sufficient room.
8490            fidl::encoding::encode_in_envelope_optional::<GainType, D>(
8491                self.type_.as_ref().map(<GainType as fidl::encoding::ValueTypeMarker>::borrow),
8492                encoder,
8493                offset + cur_offset,
8494                depth,
8495            )?;
8496
8497            _prev_end_offset = cur_offset + envelope_size;
8498            if 2 > max_ordinal {
8499                return Ok(());
8500            }
8501
8502            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8503            // are envelope_size bytes.
8504            let cur_offset: usize = (2 - 1) * envelope_size;
8505
8506            // Zero reserved fields.
8507            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8508
8509            // Safety:
8510            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8511            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8512            //   envelope_size bytes, there is always sufficient room.
8513            fidl::encoding::encode_in_envelope_optional::<GainDomain, D>(
8514                self.domain.as_ref().map(<GainDomain as fidl::encoding::ValueTypeMarker>::borrow),
8515                encoder,
8516                offset + cur_offset,
8517                depth,
8518            )?;
8519
8520            _prev_end_offset = cur_offset + envelope_size;
8521            if 3 > max_ordinal {
8522                return Ok(());
8523            }
8524
8525            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8526            // are envelope_size bytes.
8527            let cur_offset: usize = (3 - 1) * envelope_size;
8528
8529            // Zero reserved fields.
8530            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8531
8532            // Safety:
8533            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8534            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8535            //   envelope_size bytes, there is always sufficient room.
8536            fidl::encoding::encode_in_envelope_optional::<f32, D>(
8537                self.min_gain.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
8538                encoder,
8539                offset + cur_offset,
8540                depth,
8541            )?;
8542
8543            _prev_end_offset = cur_offset + envelope_size;
8544            if 4 > max_ordinal {
8545                return Ok(());
8546            }
8547
8548            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8549            // are envelope_size bytes.
8550            let cur_offset: usize = (4 - 1) * envelope_size;
8551
8552            // Zero reserved fields.
8553            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8554
8555            // Safety:
8556            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8557            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8558            //   envelope_size bytes, there is always sufficient room.
8559            fidl::encoding::encode_in_envelope_optional::<f32, D>(
8560                self.max_gain.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
8561                encoder,
8562                offset + cur_offset,
8563                depth,
8564            )?;
8565
8566            _prev_end_offset = cur_offset + envelope_size;
8567            if 5 > max_ordinal {
8568                return Ok(());
8569            }
8570
8571            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8572            // are envelope_size bytes.
8573            let cur_offset: usize = (5 - 1) * envelope_size;
8574
8575            // Zero reserved fields.
8576            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8577
8578            // Safety:
8579            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8580            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8581            //   envelope_size bytes, there is always sufficient room.
8582            fidl::encoding::encode_in_envelope_optional::<f32, D>(
8583                self.min_gain_step.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
8584                encoder,
8585                offset + cur_offset,
8586                depth,
8587            )?;
8588
8589            _prev_end_offset = cur_offset + envelope_size;
8590
8591            Ok(())
8592        }
8593    }
8594
8595    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Gain {
8596        #[inline(always)]
8597        fn new_empty() -> Self {
8598            Self::default()
8599        }
8600
8601        unsafe fn decode(
8602            &mut self,
8603            decoder: &mut fidl::encoding::Decoder<'_, D>,
8604            offset: usize,
8605            mut depth: fidl::encoding::Depth,
8606        ) -> fidl::Result<()> {
8607            decoder.debug_check_bounds::<Self>(offset);
8608            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8609                None => return Err(fidl::Error::NotNullable),
8610                Some(len) => len,
8611            };
8612            // Calling decoder.out_of_line_offset(0) is not allowed.
8613            if len == 0 {
8614                return Ok(());
8615            };
8616            depth.increment()?;
8617            let envelope_size = 8;
8618            let bytes_len = len * envelope_size;
8619            let offset = decoder.out_of_line_offset(bytes_len)?;
8620            // Decode the envelope for each type.
8621            let mut _next_ordinal_to_read = 0;
8622            let mut next_offset = offset;
8623            let end_offset = offset + bytes_len;
8624            _next_ordinal_to_read += 1;
8625            if next_offset >= end_offset {
8626                return Ok(());
8627            }
8628
8629            // Decode unknown envelopes for gaps in ordinals.
8630            while _next_ordinal_to_read < 1 {
8631                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8632                _next_ordinal_to_read += 1;
8633                next_offset += envelope_size;
8634            }
8635
8636            let next_out_of_line = decoder.next_out_of_line();
8637            let handles_before = decoder.remaining_handles();
8638            if let Some((inlined, num_bytes, num_handles)) =
8639                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8640            {
8641                let member_inline_size =
8642                    <GainType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8643                if inlined != (member_inline_size <= 4) {
8644                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8645                }
8646                let inner_offset;
8647                let mut inner_depth = depth.clone();
8648                if inlined {
8649                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8650                    inner_offset = next_offset;
8651                } else {
8652                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8653                    inner_depth.increment()?;
8654                }
8655                let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(GainType, D));
8656                fidl::decode!(GainType, D, val_ref, decoder, inner_offset, inner_depth)?;
8657                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8658                {
8659                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8660                }
8661                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8662                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8663                }
8664            }
8665
8666            next_offset += envelope_size;
8667            _next_ordinal_to_read += 1;
8668            if next_offset >= end_offset {
8669                return Ok(());
8670            }
8671
8672            // Decode unknown envelopes for gaps in ordinals.
8673            while _next_ordinal_to_read < 2 {
8674                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8675                _next_ordinal_to_read += 1;
8676                next_offset += envelope_size;
8677            }
8678
8679            let next_out_of_line = decoder.next_out_of_line();
8680            let handles_before = decoder.remaining_handles();
8681            if let Some((inlined, num_bytes, num_handles)) =
8682                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8683            {
8684                let member_inline_size =
8685                    <GainDomain as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8686                if inlined != (member_inline_size <= 4) {
8687                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8688                }
8689                let inner_offset;
8690                let mut inner_depth = depth.clone();
8691                if inlined {
8692                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8693                    inner_offset = next_offset;
8694                } else {
8695                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8696                    inner_depth.increment()?;
8697                }
8698                let val_ref = self.domain.get_or_insert_with(|| fidl::new_empty!(GainDomain, D));
8699                fidl::decode!(GainDomain, D, val_ref, decoder, inner_offset, inner_depth)?;
8700                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8701                {
8702                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8703                }
8704                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8705                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8706                }
8707            }
8708
8709            next_offset += envelope_size;
8710            _next_ordinal_to_read += 1;
8711            if next_offset >= end_offset {
8712                return Ok(());
8713            }
8714
8715            // Decode unknown envelopes for gaps in ordinals.
8716            while _next_ordinal_to_read < 3 {
8717                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8718                _next_ordinal_to_read += 1;
8719                next_offset += envelope_size;
8720            }
8721
8722            let next_out_of_line = decoder.next_out_of_line();
8723            let handles_before = decoder.remaining_handles();
8724            if let Some((inlined, num_bytes, num_handles)) =
8725                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8726            {
8727                let member_inline_size =
8728                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8729                if inlined != (member_inline_size <= 4) {
8730                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8731                }
8732                let inner_offset;
8733                let mut inner_depth = depth.clone();
8734                if inlined {
8735                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8736                    inner_offset = next_offset;
8737                } else {
8738                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8739                    inner_depth.increment()?;
8740                }
8741                let val_ref = self.min_gain.get_or_insert_with(|| fidl::new_empty!(f32, D));
8742                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
8743                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8744                {
8745                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8746                }
8747                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8748                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8749                }
8750            }
8751
8752            next_offset += envelope_size;
8753            _next_ordinal_to_read += 1;
8754            if next_offset >= end_offset {
8755                return Ok(());
8756            }
8757
8758            // Decode unknown envelopes for gaps in ordinals.
8759            while _next_ordinal_to_read < 4 {
8760                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8761                _next_ordinal_to_read += 1;
8762                next_offset += envelope_size;
8763            }
8764
8765            let next_out_of_line = decoder.next_out_of_line();
8766            let handles_before = decoder.remaining_handles();
8767            if let Some((inlined, num_bytes, num_handles)) =
8768                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8769            {
8770                let member_inline_size =
8771                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8772                if inlined != (member_inline_size <= 4) {
8773                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8774                }
8775                let inner_offset;
8776                let mut inner_depth = depth.clone();
8777                if inlined {
8778                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8779                    inner_offset = next_offset;
8780                } else {
8781                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8782                    inner_depth.increment()?;
8783                }
8784                let val_ref = self.max_gain.get_or_insert_with(|| fidl::new_empty!(f32, D));
8785                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
8786                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8787                {
8788                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8789                }
8790                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8791                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8792                }
8793            }
8794
8795            next_offset += envelope_size;
8796            _next_ordinal_to_read += 1;
8797            if next_offset >= end_offset {
8798                return Ok(());
8799            }
8800
8801            // Decode unknown envelopes for gaps in ordinals.
8802            while _next_ordinal_to_read < 5 {
8803                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8804                _next_ordinal_to_read += 1;
8805                next_offset += envelope_size;
8806            }
8807
8808            let next_out_of_line = decoder.next_out_of_line();
8809            let handles_before = decoder.remaining_handles();
8810            if let Some((inlined, num_bytes, num_handles)) =
8811                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8812            {
8813                let member_inline_size =
8814                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8815                if inlined != (member_inline_size <= 4) {
8816                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8817                }
8818                let inner_offset;
8819                let mut inner_depth = depth.clone();
8820                if inlined {
8821                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8822                    inner_offset = next_offset;
8823                } else {
8824                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8825                    inner_depth.increment()?;
8826                }
8827                let val_ref = self.min_gain_step.get_or_insert_with(|| fidl::new_empty!(f32, D));
8828                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
8829                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8830                {
8831                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8832                }
8833                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8834                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8835                }
8836            }
8837
8838            next_offset += envelope_size;
8839
8840            // Decode the remaining unknown envelopes.
8841            while next_offset < end_offset {
8842                _next_ordinal_to_read += 1;
8843                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8844                next_offset += envelope_size;
8845            }
8846
8847            Ok(())
8848        }
8849    }
8850
8851    impl GainElementState {
8852        #[inline(always)]
8853        fn max_ordinal_present(&self) -> u64 {
8854            if let Some(_) = self.gain {
8855                return 1;
8856            }
8857            0
8858        }
8859    }
8860
8861    impl fidl::encoding::ValueTypeMarker for GainElementState {
8862        type Borrowed<'a> = &'a Self;
8863        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8864            value
8865        }
8866    }
8867
8868    unsafe impl fidl::encoding::TypeMarker for GainElementState {
8869        type Owned = Self;
8870
8871        #[inline(always)]
8872        fn inline_align(_context: fidl::encoding::Context) -> usize {
8873            8
8874        }
8875
8876        #[inline(always)]
8877        fn inline_size(_context: fidl::encoding::Context) -> usize {
8878            16
8879        }
8880    }
8881
8882    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<GainElementState, D>
8883        for &GainElementState
8884    {
8885        unsafe fn encode(
8886            self,
8887            encoder: &mut fidl::encoding::Encoder<'_, D>,
8888            offset: usize,
8889            mut depth: fidl::encoding::Depth,
8890        ) -> fidl::Result<()> {
8891            encoder.debug_check_bounds::<GainElementState>(offset);
8892            // Vector header
8893            let max_ordinal: u64 = self.max_ordinal_present();
8894            encoder.write_num(max_ordinal, offset);
8895            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8896            // Calling encoder.out_of_line_offset(0) is not allowed.
8897            if max_ordinal == 0 {
8898                return Ok(());
8899            }
8900            depth.increment()?;
8901            let envelope_size = 8;
8902            let bytes_len = max_ordinal as usize * envelope_size;
8903            #[allow(unused_variables)]
8904            let offset = encoder.out_of_line_offset(bytes_len);
8905            let mut _prev_end_offset: usize = 0;
8906            if 1 > max_ordinal {
8907                return Ok(());
8908            }
8909
8910            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8911            // are envelope_size bytes.
8912            let cur_offset: usize = (1 - 1) * envelope_size;
8913
8914            // Zero reserved fields.
8915            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8916
8917            // Safety:
8918            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8919            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8920            //   envelope_size bytes, there is always sufficient room.
8921            fidl::encoding::encode_in_envelope_optional::<f32, D>(
8922                self.gain.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
8923                encoder,
8924                offset + cur_offset,
8925                depth,
8926            )?;
8927
8928            _prev_end_offset = cur_offset + envelope_size;
8929
8930            Ok(())
8931        }
8932    }
8933
8934    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GainElementState {
8935        #[inline(always)]
8936        fn new_empty() -> Self {
8937            Self::default()
8938        }
8939
8940        unsafe fn decode(
8941            &mut self,
8942            decoder: &mut fidl::encoding::Decoder<'_, D>,
8943            offset: usize,
8944            mut depth: fidl::encoding::Depth,
8945        ) -> fidl::Result<()> {
8946            decoder.debug_check_bounds::<Self>(offset);
8947            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8948                None => return Err(fidl::Error::NotNullable),
8949                Some(len) => len,
8950            };
8951            // Calling decoder.out_of_line_offset(0) is not allowed.
8952            if len == 0 {
8953                return Ok(());
8954            };
8955            depth.increment()?;
8956            let envelope_size = 8;
8957            let bytes_len = len * envelope_size;
8958            let offset = decoder.out_of_line_offset(bytes_len)?;
8959            // Decode the envelope for each type.
8960            let mut _next_ordinal_to_read = 0;
8961            let mut next_offset = offset;
8962            let end_offset = offset + bytes_len;
8963            _next_ordinal_to_read += 1;
8964            if next_offset >= end_offset {
8965                return Ok(());
8966            }
8967
8968            // Decode unknown envelopes for gaps in ordinals.
8969            while _next_ordinal_to_read < 1 {
8970                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8971                _next_ordinal_to_read += 1;
8972                next_offset += envelope_size;
8973            }
8974
8975            let next_out_of_line = decoder.next_out_of_line();
8976            let handles_before = decoder.remaining_handles();
8977            if let Some((inlined, num_bytes, num_handles)) =
8978                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8979            {
8980                let member_inline_size =
8981                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8982                if inlined != (member_inline_size <= 4) {
8983                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8984                }
8985                let inner_offset;
8986                let mut inner_depth = depth.clone();
8987                if inlined {
8988                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8989                    inner_offset = next_offset;
8990                } else {
8991                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8992                    inner_depth.increment()?;
8993                }
8994                let val_ref = self.gain.get_or_insert_with(|| fidl::new_empty!(f32, D));
8995                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
8996                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8997                {
8998                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8999                }
9000                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9001                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9002                }
9003            }
9004
9005            next_offset += envelope_size;
9006
9007            // Decode the remaining unknown envelopes.
9008            while next_offset < end_offset {
9009                _next_ordinal_to_read += 1;
9010                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9011                next_offset += envelope_size;
9012            }
9013
9014            Ok(())
9015        }
9016    }
9017
9018    impl PlugState {
9019        #[inline(always)]
9020        fn max_ordinal_present(&self) -> u64 {
9021            if let Some(_) = self.plug_state_time {
9022                return 2;
9023            }
9024            if let Some(_) = self.plugged {
9025                return 1;
9026            }
9027            0
9028        }
9029    }
9030
9031    impl fidl::encoding::ValueTypeMarker for PlugState {
9032        type Borrowed<'a> = &'a Self;
9033        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9034            value
9035        }
9036    }
9037
9038    unsafe impl fidl::encoding::TypeMarker for PlugState {
9039        type Owned = Self;
9040
9041        #[inline(always)]
9042        fn inline_align(_context: fidl::encoding::Context) -> usize {
9043            8
9044        }
9045
9046        #[inline(always)]
9047        fn inline_size(_context: fidl::encoding::Context) -> usize {
9048            16
9049        }
9050    }
9051
9052    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PlugState, D>
9053        for &PlugState
9054    {
9055        unsafe fn encode(
9056            self,
9057            encoder: &mut fidl::encoding::Encoder<'_, D>,
9058            offset: usize,
9059            mut depth: fidl::encoding::Depth,
9060        ) -> fidl::Result<()> {
9061            encoder.debug_check_bounds::<PlugState>(offset);
9062            // Vector header
9063            let max_ordinal: u64 = self.max_ordinal_present();
9064            encoder.write_num(max_ordinal, offset);
9065            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9066            // Calling encoder.out_of_line_offset(0) is not allowed.
9067            if max_ordinal == 0 {
9068                return Ok(());
9069            }
9070            depth.increment()?;
9071            let envelope_size = 8;
9072            let bytes_len = max_ordinal as usize * envelope_size;
9073            #[allow(unused_variables)]
9074            let offset = encoder.out_of_line_offset(bytes_len);
9075            let mut _prev_end_offset: usize = 0;
9076            if 1 > max_ordinal {
9077                return Ok(());
9078            }
9079
9080            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9081            // are envelope_size bytes.
9082            let cur_offset: usize = (1 - 1) * envelope_size;
9083
9084            // Zero reserved fields.
9085            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9086
9087            // Safety:
9088            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9089            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9090            //   envelope_size bytes, there is always sufficient room.
9091            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9092                self.plugged.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9093                encoder,
9094                offset + cur_offset,
9095                depth,
9096            )?;
9097
9098            _prev_end_offset = cur_offset + envelope_size;
9099            if 2 > max_ordinal {
9100                return Ok(());
9101            }
9102
9103            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9104            // are envelope_size bytes.
9105            let cur_offset: usize = (2 - 1) * envelope_size;
9106
9107            // Zero reserved fields.
9108            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9109
9110            // Safety:
9111            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9112            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9113            //   envelope_size bytes, there is always sufficient room.
9114            fidl::encoding::encode_in_envelope_optional::<i64, D>(
9115                self.plug_state_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
9116                encoder,
9117                offset + cur_offset,
9118                depth,
9119            )?;
9120
9121            _prev_end_offset = cur_offset + envelope_size;
9122
9123            Ok(())
9124        }
9125    }
9126
9127    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlugState {
9128        #[inline(always)]
9129        fn new_empty() -> Self {
9130            Self::default()
9131        }
9132
9133        unsafe fn decode(
9134            &mut self,
9135            decoder: &mut fidl::encoding::Decoder<'_, D>,
9136            offset: usize,
9137            mut depth: fidl::encoding::Depth,
9138        ) -> fidl::Result<()> {
9139            decoder.debug_check_bounds::<Self>(offset);
9140            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9141                None => return Err(fidl::Error::NotNullable),
9142                Some(len) => len,
9143            };
9144            // Calling decoder.out_of_line_offset(0) is not allowed.
9145            if len == 0 {
9146                return Ok(());
9147            };
9148            depth.increment()?;
9149            let envelope_size = 8;
9150            let bytes_len = len * envelope_size;
9151            let offset = decoder.out_of_line_offset(bytes_len)?;
9152            // Decode the envelope for each type.
9153            let mut _next_ordinal_to_read = 0;
9154            let mut next_offset = offset;
9155            let end_offset = offset + bytes_len;
9156            _next_ordinal_to_read += 1;
9157            if next_offset >= end_offset {
9158                return Ok(());
9159            }
9160
9161            // Decode unknown envelopes for gaps in ordinals.
9162            while _next_ordinal_to_read < 1 {
9163                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9164                _next_ordinal_to_read += 1;
9165                next_offset += envelope_size;
9166            }
9167
9168            let next_out_of_line = decoder.next_out_of_line();
9169            let handles_before = decoder.remaining_handles();
9170            if let Some((inlined, num_bytes, num_handles)) =
9171                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9172            {
9173                let member_inline_size =
9174                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9175                if inlined != (member_inline_size <= 4) {
9176                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9177                }
9178                let inner_offset;
9179                let mut inner_depth = depth.clone();
9180                if inlined {
9181                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9182                    inner_offset = next_offset;
9183                } else {
9184                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9185                    inner_depth.increment()?;
9186                }
9187                let val_ref = self.plugged.get_or_insert_with(|| fidl::new_empty!(bool, D));
9188                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9189                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9190                {
9191                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9192                }
9193                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9194                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9195                }
9196            }
9197
9198            next_offset += envelope_size;
9199            _next_ordinal_to_read += 1;
9200            if next_offset >= end_offset {
9201                return Ok(());
9202            }
9203
9204            // Decode unknown envelopes for gaps in ordinals.
9205            while _next_ordinal_to_read < 2 {
9206                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9207                _next_ordinal_to_read += 1;
9208                next_offset += envelope_size;
9209            }
9210
9211            let next_out_of_line = decoder.next_out_of_line();
9212            let handles_before = decoder.remaining_handles();
9213            if let Some((inlined, num_bytes, num_handles)) =
9214                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9215            {
9216                let member_inline_size =
9217                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9218                if inlined != (member_inline_size <= 4) {
9219                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9220                }
9221                let inner_offset;
9222                let mut inner_depth = depth.clone();
9223                if inlined {
9224                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9225                    inner_offset = next_offset;
9226                } else {
9227                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9228                    inner_depth.increment()?;
9229                }
9230                let val_ref = self.plug_state_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
9231                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
9232                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9233                {
9234                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9235                }
9236                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9237                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9238                }
9239            }
9240
9241            next_offset += envelope_size;
9242
9243            // Decode the remaining unknown envelopes.
9244            while next_offset < end_offset {
9245                _next_ordinal_to_read += 1;
9246                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9247                next_offset += envelope_size;
9248            }
9249
9250            Ok(())
9251        }
9252    }
9253
9254    impl SettableElementState {
9255        #[inline(always)]
9256        fn max_ordinal_present(&self) -> u64 {
9257            if let Some(_) = self.bypassed {
9258                return 4;
9259            }
9260            if let Some(_) = self.started {
9261                return 3;
9262            }
9263            if let Some(_) = self.vendor_specific_data {
9264                return 2;
9265            }
9266            if let Some(_) = self.type_specific {
9267                return 1;
9268            }
9269            0
9270        }
9271    }
9272
9273    impl fidl::encoding::ValueTypeMarker for SettableElementState {
9274        type Borrowed<'a> = &'a Self;
9275        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9276            value
9277        }
9278    }
9279
9280    unsafe impl fidl::encoding::TypeMarker for SettableElementState {
9281        type Owned = Self;
9282
9283        #[inline(always)]
9284        fn inline_align(_context: fidl::encoding::Context) -> usize {
9285            8
9286        }
9287
9288        #[inline(always)]
9289        fn inline_size(_context: fidl::encoding::Context) -> usize {
9290            16
9291        }
9292    }
9293
9294    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SettableElementState, D>
9295        for &SettableElementState
9296    {
9297        unsafe fn encode(
9298            self,
9299            encoder: &mut fidl::encoding::Encoder<'_, D>,
9300            offset: usize,
9301            mut depth: fidl::encoding::Depth,
9302        ) -> fidl::Result<()> {
9303            encoder.debug_check_bounds::<SettableElementState>(offset);
9304            // Vector header
9305            let max_ordinal: u64 = self.max_ordinal_present();
9306            encoder.write_num(max_ordinal, offset);
9307            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9308            // Calling encoder.out_of_line_offset(0) is not allowed.
9309            if max_ordinal == 0 {
9310                return Ok(());
9311            }
9312            depth.increment()?;
9313            let envelope_size = 8;
9314            let bytes_len = max_ordinal as usize * envelope_size;
9315            #[allow(unused_variables)]
9316            let offset = encoder.out_of_line_offset(bytes_len);
9317            let mut _prev_end_offset: usize = 0;
9318            if 1 > max_ordinal {
9319                return Ok(());
9320            }
9321
9322            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9323            // are envelope_size bytes.
9324            let cur_offset: usize = (1 - 1) * envelope_size;
9325
9326            // Zero reserved fields.
9327            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9328
9329            // Safety:
9330            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9331            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9332            //   envelope_size bytes, there is always sufficient room.
9333            fidl::encoding::encode_in_envelope_optional::<SettableTypeSpecificElementState, D>(
9334                self.type_specific.as_ref().map(
9335                    <SettableTypeSpecificElementState as fidl::encoding::ValueTypeMarker>::borrow,
9336                ),
9337                encoder,
9338                offset + cur_offset,
9339                depth,
9340            )?;
9341
9342            _prev_end_offset = cur_offset + envelope_size;
9343            if 2 > max_ordinal {
9344                return Ok(());
9345            }
9346
9347            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9348            // are envelope_size bytes.
9349            let cur_offset: usize = (2 - 1) * envelope_size;
9350
9351            // Zero reserved fields.
9352            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9353
9354            // Safety:
9355            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9356            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9357            //   envelope_size bytes, there is always sufficient room.
9358            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 4096>, D>(
9359                self.vendor_specific_data.as_ref().map(
9360                    <fidl::encoding::Vector<u8, 4096> as fidl::encoding::ValueTypeMarker>::borrow,
9361                ),
9362                encoder,
9363                offset + cur_offset,
9364                depth,
9365            )?;
9366
9367            _prev_end_offset = cur_offset + envelope_size;
9368            if 3 > max_ordinal {
9369                return Ok(());
9370            }
9371
9372            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9373            // are envelope_size bytes.
9374            let cur_offset: usize = (3 - 1) * envelope_size;
9375
9376            // Zero reserved fields.
9377            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9378
9379            // Safety:
9380            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9381            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9382            //   envelope_size bytes, there is always sufficient room.
9383            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9384                self.started.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9385                encoder,
9386                offset + cur_offset,
9387                depth,
9388            )?;
9389
9390            _prev_end_offset = cur_offset + envelope_size;
9391            if 4 > max_ordinal {
9392                return Ok(());
9393            }
9394
9395            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9396            // are envelope_size bytes.
9397            let cur_offset: usize = (4 - 1) * envelope_size;
9398
9399            // Zero reserved fields.
9400            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9401
9402            // Safety:
9403            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9404            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9405            //   envelope_size bytes, there is always sufficient room.
9406            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9407                self.bypassed.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9408                encoder,
9409                offset + cur_offset,
9410                depth,
9411            )?;
9412
9413            _prev_end_offset = cur_offset + envelope_size;
9414
9415            Ok(())
9416        }
9417    }
9418
9419    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SettableElementState {
9420        #[inline(always)]
9421        fn new_empty() -> Self {
9422            Self::default()
9423        }
9424
9425        unsafe fn decode(
9426            &mut self,
9427            decoder: &mut fidl::encoding::Decoder<'_, D>,
9428            offset: usize,
9429            mut depth: fidl::encoding::Depth,
9430        ) -> fidl::Result<()> {
9431            decoder.debug_check_bounds::<Self>(offset);
9432            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9433                None => return Err(fidl::Error::NotNullable),
9434                Some(len) => len,
9435            };
9436            // Calling decoder.out_of_line_offset(0) is not allowed.
9437            if len == 0 {
9438                return Ok(());
9439            };
9440            depth.increment()?;
9441            let envelope_size = 8;
9442            let bytes_len = len * envelope_size;
9443            let offset = decoder.out_of_line_offset(bytes_len)?;
9444            // Decode the envelope for each type.
9445            let mut _next_ordinal_to_read = 0;
9446            let mut next_offset = offset;
9447            let end_offset = offset + bytes_len;
9448            _next_ordinal_to_read += 1;
9449            if next_offset >= end_offset {
9450                return Ok(());
9451            }
9452
9453            // Decode unknown envelopes for gaps in ordinals.
9454            while _next_ordinal_to_read < 1 {
9455                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9456                _next_ordinal_to_read += 1;
9457                next_offset += envelope_size;
9458            }
9459
9460            let next_out_of_line = decoder.next_out_of_line();
9461            let handles_before = decoder.remaining_handles();
9462            if let Some((inlined, num_bytes, num_handles)) =
9463                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9464            {
9465                let member_inline_size =
9466                    <SettableTypeSpecificElementState as fidl::encoding::TypeMarker>::inline_size(
9467                        decoder.context,
9468                    );
9469                if inlined != (member_inline_size <= 4) {
9470                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9471                }
9472                let inner_offset;
9473                let mut inner_depth = depth.clone();
9474                if inlined {
9475                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9476                    inner_offset = next_offset;
9477                } else {
9478                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9479                    inner_depth.increment()?;
9480                }
9481                let val_ref = self
9482                    .type_specific
9483                    .get_or_insert_with(|| fidl::new_empty!(SettableTypeSpecificElementState, D));
9484                fidl::decode!(
9485                    SettableTypeSpecificElementState,
9486                    D,
9487                    val_ref,
9488                    decoder,
9489                    inner_offset,
9490                    inner_depth
9491                )?;
9492                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9493                {
9494                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9495                }
9496                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9497                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9498                }
9499            }
9500
9501            next_offset += envelope_size;
9502            _next_ordinal_to_read += 1;
9503            if next_offset >= end_offset {
9504                return Ok(());
9505            }
9506
9507            // Decode unknown envelopes for gaps in ordinals.
9508            while _next_ordinal_to_read < 2 {
9509                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9510                _next_ordinal_to_read += 1;
9511                next_offset += envelope_size;
9512            }
9513
9514            let next_out_of_line = decoder.next_out_of_line();
9515            let handles_before = decoder.remaining_handles();
9516            if let Some((inlined, num_bytes, num_handles)) =
9517                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9518            {
9519                let member_inline_size =
9520                    <fidl::encoding::Vector<u8, 4096> as fidl::encoding::TypeMarker>::inline_size(
9521                        decoder.context,
9522                    );
9523                if inlined != (member_inline_size <= 4) {
9524                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9525                }
9526                let inner_offset;
9527                let mut inner_depth = depth.clone();
9528                if inlined {
9529                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9530                    inner_offset = next_offset;
9531                } else {
9532                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9533                    inner_depth.increment()?;
9534                }
9535                let val_ref = self
9536                    .vendor_specific_data
9537                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 4096>, D));
9538                fidl::decode!(fidl::encoding::Vector<u8, 4096>, D, val_ref, decoder, inner_offset, inner_depth)?;
9539                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9540                {
9541                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9542                }
9543                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9544                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9545                }
9546            }
9547
9548            next_offset += envelope_size;
9549            _next_ordinal_to_read += 1;
9550            if next_offset >= end_offset {
9551                return Ok(());
9552            }
9553
9554            // Decode unknown envelopes for gaps in ordinals.
9555            while _next_ordinal_to_read < 3 {
9556                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9557                _next_ordinal_to_read += 1;
9558                next_offset += envelope_size;
9559            }
9560
9561            let next_out_of_line = decoder.next_out_of_line();
9562            let handles_before = decoder.remaining_handles();
9563            if let Some((inlined, num_bytes, num_handles)) =
9564                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9565            {
9566                let member_inline_size =
9567                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9568                if inlined != (member_inline_size <= 4) {
9569                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9570                }
9571                let inner_offset;
9572                let mut inner_depth = depth.clone();
9573                if inlined {
9574                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9575                    inner_offset = next_offset;
9576                } else {
9577                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9578                    inner_depth.increment()?;
9579                }
9580                let val_ref = self.started.get_or_insert_with(|| fidl::new_empty!(bool, D));
9581                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9582                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9583                {
9584                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9585                }
9586                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9587                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9588                }
9589            }
9590
9591            next_offset += envelope_size;
9592            _next_ordinal_to_read += 1;
9593            if next_offset >= end_offset {
9594                return Ok(());
9595            }
9596
9597            // Decode unknown envelopes for gaps in ordinals.
9598            while _next_ordinal_to_read < 4 {
9599                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9600                _next_ordinal_to_read += 1;
9601                next_offset += envelope_size;
9602            }
9603
9604            let next_out_of_line = decoder.next_out_of_line();
9605            let handles_before = decoder.remaining_handles();
9606            if let Some((inlined, num_bytes, num_handles)) =
9607                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9608            {
9609                let member_inline_size =
9610                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9611                if inlined != (member_inline_size <= 4) {
9612                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9613                }
9614                let inner_offset;
9615                let mut inner_depth = depth.clone();
9616                if inlined {
9617                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9618                    inner_offset = next_offset;
9619                } else {
9620                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9621                    inner_depth.increment()?;
9622                }
9623                let val_ref = self.bypassed.get_or_insert_with(|| fidl::new_empty!(bool, D));
9624                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9625                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9626                {
9627                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9628                }
9629                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9630                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9631                }
9632            }
9633
9634            next_offset += envelope_size;
9635
9636            // Decode the remaining unknown envelopes.
9637            while next_offset < end_offset {
9638                _next_ordinal_to_read += 1;
9639                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9640                next_offset += envelope_size;
9641            }
9642
9643            Ok(())
9644        }
9645    }
9646
9647    impl Topology {
9648        #[inline(always)]
9649        fn max_ordinal_present(&self) -> u64 {
9650            if let Some(_) = self.processing_elements_edge_pairs {
9651                return 2;
9652            }
9653            if let Some(_) = self.id {
9654                return 1;
9655            }
9656            0
9657        }
9658    }
9659
9660    impl fidl::encoding::ValueTypeMarker for Topology {
9661        type Borrowed<'a> = &'a Self;
9662        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9663            value
9664        }
9665    }
9666
9667    unsafe impl fidl::encoding::TypeMarker for Topology {
9668        type Owned = Self;
9669
9670        #[inline(always)]
9671        fn inline_align(_context: fidl::encoding::Context) -> usize {
9672            8
9673        }
9674
9675        #[inline(always)]
9676        fn inline_size(_context: fidl::encoding::Context) -> usize {
9677            16
9678        }
9679    }
9680
9681    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Topology, D> for &Topology {
9682        unsafe fn encode(
9683            self,
9684            encoder: &mut fidl::encoding::Encoder<'_, D>,
9685            offset: usize,
9686            mut depth: fidl::encoding::Depth,
9687        ) -> fidl::Result<()> {
9688            encoder.debug_check_bounds::<Topology>(offset);
9689            // Vector header
9690            let max_ordinal: u64 = self.max_ordinal_present();
9691            encoder.write_num(max_ordinal, offset);
9692            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9693            // Calling encoder.out_of_line_offset(0) is not allowed.
9694            if max_ordinal == 0 {
9695                return Ok(());
9696            }
9697            depth.increment()?;
9698            let envelope_size = 8;
9699            let bytes_len = max_ordinal as usize * envelope_size;
9700            #[allow(unused_variables)]
9701            let offset = encoder.out_of_line_offset(bytes_len);
9702            let mut _prev_end_offset: usize = 0;
9703            if 1 > max_ordinal {
9704                return Ok(());
9705            }
9706
9707            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9708            // are envelope_size bytes.
9709            let cur_offset: usize = (1 - 1) * envelope_size;
9710
9711            // Zero reserved fields.
9712            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9713
9714            // Safety:
9715            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9716            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9717            //   envelope_size bytes, there is always sufficient room.
9718            fidl::encoding::encode_in_envelope_optional::<u64, D>(
9719                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9720                encoder,
9721                offset + cur_offset,
9722                depth,
9723            )?;
9724
9725            _prev_end_offset = cur_offset + envelope_size;
9726            if 2 > max_ordinal {
9727                return Ok(());
9728            }
9729
9730            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9731            // are envelope_size bytes.
9732            let cur_offset: usize = (2 - 1) * envelope_size;
9733
9734            // Zero reserved fields.
9735            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9736
9737            // Safety:
9738            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9739            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9740            //   envelope_size bytes, there is always sufficient room.
9741            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<EdgePair, 64>, D>(
9742            self.processing_elements_edge_pairs.as_ref().map(<fidl::encoding::Vector<EdgePair, 64> as fidl::encoding::ValueTypeMarker>::borrow),
9743            encoder, offset + cur_offset, depth
9744        )?;
9745
9746            _prev_end_offset = cur_offset + envelope_size;
9747
9748            Ok(())
9749        }
9750    }
9751
9752    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Topology {
9753        #[inline(always)]
9754        fn new_empty() -> Self {
9755            Self::default()
9756        }
9757
9758        unsafe fn decode(
9759            &mut self,
9760            decoder: &mut fidl::encoding::Decoder<'_, D>,
9761            offset: usize,
9762            mut depth: fidl::encoding::Depth,
9763        ) -> fidl::Result<()> {
9764            decoder.debug_check_bounds::<Self>(offset);
9765            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9766                None => return Err(fidl::Error::NotNullable),
9767                Some(len) => len,
9768            };
9769            // Calling decoder.out_of_line_offset(0) is not allowed.
9770            if len == 0 {
9771                return Ok(());
9772            };
9773            depth.increment()?;
9774            let envelope_size = 8;
9775            let bytes_len = len * envelope_size;
9776            let offset = decoder.out_of_line_offset(bytes_len)?;
9777            // Decode the envelope for each type.
9778            let mut _next_ordinal_to_read = 0;
9779            let mut next_offset = offset;
9780            let end_offset = offset + bytes_len;
9781            _next_ordinal_to_read += 1;
9782            if next_offset >= end_offset {
9783                return Ok(());
9784            }
9785
9786            // Decode unknown envelopes for gaps in ordinals.
9787            while _next_ordinal_to_read < 1 {
9788                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9789                _next_ordinal_to_read += 1;
9790                next_offset += envelope_size;
9791            }
9792
9793            let next_out_of_line = decoder.next_out_of_line();
9794            let handles_before = decoder.remaining_handles();
9795            if let Some((inlined, num_bytes, num_handles)) =
9796                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9797            {
9798                let member_inline_size =
9799                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9800                if inlined != (member_inline_size <= 4) {
9801                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9802                }
9803                let inner_offset;
9804                let mut inner_depth = depth.clone();
9805                if inlined {
9806                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9807                    inner_offset = next_offset;
9808                } else {
9809                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9810                    inner_depth.increment()?;
9811                }
9812                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
9813                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9814                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9815                {
9816                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9817                }
9818                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9819                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9820                }
9821            }
9822
9823            next_offset += envelope_size;
9824            _next_ordinal_to_read += 1;
9825            if next_offset >= end_offset {
9826                return Ok(());
9827            }
9828
9829            // Decode unknown envelopes for gaps in ordinals.
9830            while _next_ordinal_to_read < 2 {
9831                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9832                _next_ordinal_to_read += 1;
9833                next_offset += envelope_size;
9834            }
9835
9836            let next_out_of_line = decoder.next_out_of_line();
9837            let handles_before = decoder.remaining_handles();
9838            if let Some((inlined, num_bytes, num_handles)) =
9839                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9840            {
9841                let member_inline_size = <fidl::encoding::Vector<EdgePair, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9842                if inlined != (member_inline_size <= 4) {
9843                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9844                }
9845                let inner_offset;
9846                let mut inner_depth = depth.clone();
9847                if inlined {
9848                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9849                    inner_offset = next_offset;
9850                } else {
9851                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9852                    inner_depth.increment()?;
9853                }
9854                let val_ref = self.processing_elements_edge_pairs.get_or_insert_with(
9855                    || fidl::new_empty!(fidl::encoding::Vector<EdgePair, 64>, D),
9856                );
9857                fidl::decode!(fidl::encoding::Vector<EdgePair, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
9858                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9859                {
9860                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9861                }
9862                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9863                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9864                }
9865            }
9866
9867            next_offset += envelope_size;
9868
9869            // Decode the remaining unknown envelopes.
9870            while next_offset < end_offset {
9871                _next_ordinal_to_read += 1;
9872                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9873                next_offset += envelope_size;
9874            }
9875
9876            Ok(())
9877        }
9878    }
9879
9880    impl VendorSpecific {
9881        #[inline(always)]
9882        fn max_ordinal_present(&self) -> u64 {
9883            0
9884        }
9885    }
9886
9887    impl fidl::encoding::ValueTypeMarker for VendorSpecific {
9888        type Borrowed<'a> = &'a Self;
9889        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9890            value
9891        }
9892    }
9893
9894    unsafe impl fidl::encoding::TypeMarker for VendorSpecific {
9895        type Owned = Self;
9896
9897        #[inline(always)]
9898        fn inline_align(_context: fidl::encoding::Context) -> usize {
9899            8
9900        }
9901
9902        #[inline(always)]
9903        fn inline_size(_context: fidl::encoding::Context) -> usize {
9904            16
9905        }
9906    }
9907
9908    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VendorSpecific, D>
9909        for &VendorSpecific
9910    {
9911        unsafe fn encode(
9912            self,
9913            encoder: &mut fidl::encoding::Encoder<'_, D>,
9914            offset: usize,
9915            mut depth: fidl::encoding::Depth,
9916        ) -> fidl::Result<()> {
9917            encoder.debug_check_bounds::<VendorSpecific>(offset);
9918            // Vector header
9919            let max_ordinal: u64 = self.max_ordinal_present();
9920            encoder.write_num(max_ordinal, offset);
9921            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9922            // Calling encoder.out_of_line_offset(0) is not allowed.
9923            if max_ordinal == 0 {
9924                return Ok(());
9925            }
9926            depth.increment()?;
9927            let envelope_size = 8;
9928            let bytes_len = max_ordinal as usize * envelope_size;
9929            #[allow(unused_variables)]
9930            let offset = encoder.out_of_line_offset(bytes_len);
9931            let mut _prev_end_offset: usize = 0;
9932
9933            Ok(())
9934        }
9935    }
9936
9937    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VendorSpecific {
9938        #[inline(always)]
9939        fn new_empty() -> Self {
9940            Self::default()
9941        }
9942
9943        unsafe fn decode(
9944            &mut self,
9945            decoder: &mut fidl::encoding::Decoder<'_, D>,
9946            offset: usize,
9947            mut depth: fidl::encoding::Depth,
9948        ) -> fidl::Result<()> {
9949            decoder.debug_check_bounds::<Self>(offset);
9950            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9951                None => return Err(fidl::Error::NotNullable),
9952                Some(len) => len,
9953            };
9954            // Calling decoder.out_of_line_offset(0) is not allowed.
9955            if len == 0 {
9956                return Ok(());
9957            };
9958            depth.increment()?;
9959            let envelope_size = 8;
9960            let bytes_len = len * envelope_size;
9961            let offset = decoder.out_of_line_offset(bytes_len)?;
9962            // Decode the envelope for each type.
9963            let mut _next_ordinal_to_read = 0;
9964            let mut next_offset = offset;
9965            let end_offset = offset + bytes_len;
9966
9967            // Decode the remaining unknown envelopes.
9968            while next_offset < end_offset {
9969                _next_ordinal_to_read += 1;
9970                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9971                next_offset += envelope_size;
9972            }
9973
9974            Ok(())
9975        }
9976    }
9977
9978    impl VendorSpecificState {
9979        #[inline(always)]
9980        fn max_ordinal_present(&self) -> u64 {
9981            0
9982        }
9983    }
9984
9985    impl fidl::encoding::ValueTypeMarker for VendorSpecificState {
9986        type Borrowed<'a> = &'a Self;
9987        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9988            value
9989        }
9990    }
9991
9992    unsafe impl fidl::encoding::TypeMarker for VendorSpecificState {
9993        type Owned = Self;
9994
9995        #[inline(always)]
9996        fn inline_align(_context: fidl::encoding::Context) -> usize {
9997            8
9998        }
9999
10000        #[inline(always)]
10001        fn inline_size(_context: fidl::encoding::Context) -> usize {
10002            16
10003        }
10004    }
10005
10006    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VendorSpecificState, D>
10007        for &VendorSpecificState
10008    {
10009        unsafe fn encode(
10010            self,
10011            encoder: &mut fidl::encoding::Encoder<'_, D>,
10012            offset: usize,
10013            mut depth: fidl::encoding::Depth,
10014        ) -> fidl::Result<()> {
10015            encoder.debug_check_bounds::<VendorSpecificState>(offset);
10016            // Vector header
10017            let max_ordinal: u64 = self.max_ordinal_present();
10018            encoder.write_num(max_ordinal, offset);
10019            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10020            // Calling encoder.out_of_line_offset(0) is not allowed.
10021            if max_ordinal == 0 {
10022                return Ok(());
10023            }
10024            depth.increment()?;
10025            let envelope_size = 8;
10026            let bytes_len = max_ordinal as usize * envelope_size;
10027            #[allow(unused_variables)]
10028            let offset = encoder.out_of_line_offset(bytes_len);
10029            let mut _prev_end_offset: usize = 0;
10030
10031            Ok(())
10032        }
10033    }
10034
10035    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VendorSpecificState {
10036        #[inline(always)]
10037        fn new_empty() -> Self {
10038            Self::default()
10039        }
10040
10041        unsafe fn decode(
10042            &mut self,
10043            decoder: &mut fidl::encoding::Decoder<'_, D>,
10044            offset: usize,
10045            mut depth: fidl::encoding::Depth,
10046        ) -> fidl::Result<()> {
10047            decoder.debug_check_bounds::<Self>(offset);
10048            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10049                None => return Err(fidl::Error::NotNullable),
10050                Some(len) => len,
10051            };
10052            // Calling decoder.out_of_line_offset(0) is not allowed.
10053            if len == 0 {
10054                return Ok(());
10055            };
10056            depth.increment()?;
10057            let envelope_size = 8;
10058            let bytes_len = len * envelope_size;
10059            let offset = decoder.out_of_line_offset(bytes_len)?;
10060            // Decode the envelope for each type.
10061            let mut _next_ordinal_to_read = 0;
10062            let mut next_offset = offset;
10063            let end_offset = offset + bytes_len;
10064
10065            // Decode the remaining unknown envelopes.
10066            while next_offset < end_offset {
10067                _next_ordinal_to_read += 1;
10068                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10069                next_offset += envelope_size;
10070            }
10071
10072            Ok(())
10073        }
10074    }
10075
10076    impl fidl::encoding::ValueTypeMarker for Latency {
10077        type Borrowed<'a> = &'a Self;
10078        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10079            value
10080        }
10081    }
10082
10083    unsafe impl fidl::encoding::TypeMarker for Latency {
10084        type Owned = Self;
10085
10086        #[inline(always)]
10087        fn inline_align(_context: fidl::encoding::Context) -> usize {
10088            8
10089        }
10090
10091        #[inline(always)]
10092        fn inline_size(_context: fidl::encoding::Context) -> usize {
10093            16
10094        }
10095    }
10096
10097    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Latency, D> for &Latency {
10098        #[inline]
10099        unsafe fn encode(
10100            self,
10101            encoder: &mut fidl::encoding::Encoder<'_, D>,
10102            offset: usize,
10103            _depth: fidl::encoding::Depth,
10104        ) -> fidl::Result<()> {
10105            encoder.debug_check_bounds::<Latency>(offset);
10106            encoder.write_num::<u64>(self.ordinal(), offset);
10107            match self {
10108                Latency::LatencyTime(ref val) => fidl::encoding::encode_in_envelope::<i64, D>(
10109                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
10110                    encoder,
10111                    offset + 8,
10112                    _depth,
10113                ),
10114                Latency::LatencyFrames(ref val) => fidl::encoding::encode_in_envelope::<u32, D>(
10115                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
10116                    encoder,
10117                    offset + 8,
10118                    _depth,
10119                ),
10120                Latency::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
10121            }
10122        }
10123    }
10124
10125    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Latency {
10126        #[inline(always)]
10127        fn new_empty() -> Self {
10128            Self::__SourceBreaking { unknown_ordinal: 0 }
10129        }
10130
10131        #[inline]
10132        unsafe fn decode(
10133            &mut self,
10134            decoder: &mut fidl::encoding::Decoder<'_, D>,
10135            offset: usize,
10136            mut depth: fidl::encoding::Depth,
10137        ) -> fidl::Result<()> {
10138            decoder.debug_check_bounds::<Self>(offset);
10139            #[allow(unused_variables)]
10140            let next_out_of_line = decoder.next_out_of_line();
10141            let handles_before = decoder.remaining_handles();
10142            let (ordinal, inlined, num_bytes, num_handles) =
10143                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10144
10145            let member_inline_size = match ordinal {
10146                1 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10147                2 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10148                0 => return Err(fidl::Error::UnknownUnionTag),
10149                _ => num_bytes as usize,
10150            };
10151
10152            if inlined != (member_inline_size <= 4) {
10153                return Err(fidl::Error::InvalidInlineBitInEnvelope);
10154            }
10155            let _inner_offset;
10156            if inlined {
10157                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10158                _inner_offset = offset + 8;
10159            } else {
10160                depth.increment()?;
10161                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10162            }
10163            match ordinal {
10164                1 => {
10165                    #[allow(irrefutable_let_patterns)]
10166                    if let Latency::LatencyTime(_) = self {
10167                        // Do nothing, read the value into the object
10168                    } else {
10169                        // Initialize `self` to the right variant
10170                        *self = Latency::LatencyTime(fidl::new_empty!(i64, D));
10171                    }
10172                    #[allow(irrefutable_let_patterns)]
10173                    if let Latency::LatencyTime(ref mut val) = self {
10174                        fidl::decode!(i64, D, val, decoder, _inner_offset, depth)?;
10175                    } else {
10176                        unreachable!()
10177                    }
10178                }
10179                2 => {
10180                    #[allow(irrefutable_let_patterns)]
10181                    if let Latency::LatencyFrames(_) = self {
10182                        // Do nothing, read the value into the object
10183                    } else {
10184                        // Initialize `self` to the right variant
10185                        *self = Latency::LatencyFrames(fidl::new_empty!(u32, D));
10186                    }
10187                    #[allow(irrefutable_let_patterns)]
10188                    if let Latency::LatencyFrames(ref mut val) = self {
10189                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
10190                    } else {
10191                        unreachable!()
10192                    }
10193                }
10194                #[allow(deprecated)]
10195                ordinal => {
10196                    for _ in 0..num_handles {
10197                        decoder.drop_next_handle()?;
10198                    }
10199                    *self = Latency::__SourceBreaking { unknown_ordinal: ordinal };
10200                }
10201            }
10202            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10203                return Err(fidl::Error::InvalidNumBytesInEnvelope);
10204            }
10205            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10206                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10207            }
10208            Ok(())
10209        }
10210    }
10211
10212    impl fidl::encoding::ValueTypeMarker for SettableTypeSpecificElementState {
10213        type Borrowed<'a> = &'a Self;
10214        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10215            value
10216        }
10217    }
10218
10219    unsafe impl fidl::encoding::TypeMarker for SettableTypeSpecificElementState {
10220        type Owned = Self;
10221
10222        #[inline(always)]
10223        fn inline_align(_context: fidl::encoding::Context) -> usize {
10224            8
10225        }
10226
10227        #[inline(always)]
10228        fn inline_size(_context: fidl::encoding::Context) -> usize {
10229            16
10230        }
10231    }
10232
10233    unsafe impl<D: fidl::encoding::ResourceDialect>
10234        fidl::encoding::Encode<SettableTypeSpecificElementState, D>
10235        for &SettableTypeSpecificElementState
10236    {
10237        #[inline]
10238        unsafe fn encode(
10239            self,
10240            encoder: &mut fidl::encoding::Encoder<'_, D>,
10241            offset: usize,
10242            _depth: fidl::encoding::Depth,
10243        ) -> fidl::Result<()> {
10244            encoder.debug_check_bounds::<SettableTypeSpecificElementState>(offset);
10245            encoder.write_num::<u64>(self.ordinal(), offset);
10246            match self {
10247                SettableTypeSpecificElementState::VendorSpecific(ref val) => {
10248                    fidl::encoding::encode_in_envelope::<VendorSpecificState, D>(
10249                        <VendorSpecificState as fidl::encoding::ValueTypeMarker>::borrow(val),
10250                        encoder,
10251                        offset + 8,
10252                        _depth,
10253                    )
10254                }
10255                SettableTypeSpecificElementState::Gain(ref val) => {
10256                    fidl::encoding::encode_in_envelope::<GainElementState, D>(
10257                        <GainElementState as fidl::encoding::ValueTypeMarker>::borrow(val),
10258                        encoder,
10259                        offset + 8,
10260                        _depth,
10261                    )
10262                }
10263                SettableTypeSpecificElementState::Equalizer(ref val) => {
10264                    fidl::encoding::encode_in_envelope::<EqualizerElementState, D>(
10265                        <EqualizerElementState as fidl::encoding::ValueTypeMarker>::borrow(val),
10266                        encoder,
10267                        offset + 8,
10268                        _depth,
10269                    )
10270                }
10271                SettableTypeSpecificElementState::Dynamics(ref val) => {
10272                    fidl::encoding::encode_in_envelope::<DynamicsElementState, D>(
10273                        <DynamicsElementState as fidl::encoding::ValueTypeMarker>::borrow(val),
10274                        encoder,
10275                        offset + 8,
10276                        _depth,
10277                    )
10278                }
10279                SettableTypeSpecificElementState::__SourceBreaking { .. } => {
10280                    Err(fidl::Error::UnknownUnionTag)
10281                }
10282            }
10283        }
10284    }
10285
10286    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10287        for SettableTypeSpecificElementState
10288    {
10289        #[inline(always)]
10290        fn new_empty() -> Self {
10291            Self::__SourceBreaking { unknown_ordinal: 0 }
10292        }
10293
10294        #[inline]
10295        unsafe fn decode(
10296            &mut self,
10297            decoder: &mut fidl::encoding::Decoder<'_, D>,
10298            offset: usize,
10299            mut depth: fidl::encoding::Depth,
10300        ) -> fidl::Result<()> {
10301            decoder.debug_check_bounds::<Self>(offset);
10302            #[allow(unused_variables)]
10303            let next_out_of_line = decoder.next_out_of_line();
10304            let handles_before = decoder.remaining_handles();
10305            let (ordinal, inlined, num_bytes, num_handles) =
10306                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10307
10308            let member_inline_size = match ordinal {
10309                1 => <VendorSpecificState as fidl::encoding::TypeMarker>::inline_size(
10310                    decoder.context,
10311                ),
10312                2 => <GainElementState as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10313                3 => <EqualizerElementState as fidl::encoding::TypeMarker>::inline_size(
10314                    decoder.context,
10315                ),
10316                4 => <DynamicsElementState as fidl::encoding::TypeMarker>::inline_size(
10317                    decoder.context,
10318                ),
10319                0 => return Err(fidl::Error::UnknownUnionTag),
10320                _ => num_bytes as usize,
10321            };
10322
10323            if inlined != (member_inline_size <= 4) {
10324                return Err(fidl::Error::InvalidInlineBitInEnvelope);
10325            }
10326            let _inner_offset;
10327            if inlined {
10328                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10329                _inner_offset = offset + 8;
10330            } else {
10331                depth.increment()?;
10332                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10333            }
10334            match ordinal {
10335                1 => {
10336                    #[allow(irrefutable_let_patterns)]
10337                    if let SettableTypeSpecificElementState::VendorSpecific(_) = self {
10338                        // Do nothing, read the value into the object
10339                    } else {
10340                        // Initialize `self` to the right variant
10341                        *self = SettableTypeSpecificElementState::VendorSpecific(fidl::new_empty!(
10342                            VendorSpecificState,
10343                            D
10344                        ));
10345                    }
10346                    #[allow(irrefutable_let_patterns)]
10347                    if let SettableTypeSpecificElementState::VendorSpecific(ref mut val) = self {
10348                        fidl::decode!(VendorSpecificState, D, val, decoder, _inner_offset, depth)?;
10349                    } else {
10350                        unreachable!()
10351                    }
10352                }
10353                2 => {
10354                    #[allow(irrefutable_let_patterns)]
10355                    if let SettableTypeSpecificElementState::Gain(_) = self {
10356                        // Do nothing, read the value into the object
10357                    } else {
10358                        // Initialize `self` to the right variant
10359                        *self = SettableTypeSpecificElementState::Gain(fidl::new_empty!(
10360                            GainElementState,
10361                            D
10362                        ));
10363                    }
10364                    #[allow(irrefutable_let_patterns)]
10365                    if let SettableTypeSpecificElementState::Gain(ref mut val) = self {
10366                        fidl::decode!(GainElementState, D, val, decoder, _inner_offset, depth)?;
10367                    } else {
10368                        unreachable!()
10369                    }
10370                }
10371                3 => {
10372                    #[allow(irrefutable_let_patterns)]
10373                    if let SettableTypeSpecificElementState::Equalizer(_) = self {
10374                        // Do nothing, read the value into the object
10375                    } else {
10376                        // Initialize `self` to the right variant
10377                        *self = SettableTypeSpecificElementState::Equalizer(fidl::new_empty!(
10378                            EqualizerElementState,
10379                            D
10380                        ));
10381                    }
10382                    #[allow(irrefutable_let_patterns)]
10383                    if let SettableTypeSpecificElementState::Equalizer(ref mut val) = self {
10384                        fidl::decode!(
10385                            EqualizerElementState,
10386                            D,
10387                            val,
10388                            decoder,
10389                            _inner_offset,
10390                            depth
10391                        )?;
10392                    } else {
10393                        unreachable!()
10394                    }
10395                }
10396                4 => {
10397                    #[allow(irrefutable_let_patterns)]
10398                    if let SettableTypeSpecificElementState::Dynamics(_) = self {
10399                        // Do nothing, read the value into the object
10400                    } else {
10401                        // Initialize `self` to the right variant
10402                        *self = SettableTypeSpecificElementState::Dynamics(fidl::new_empty!(
10403                            DynamicsElementState,
10404                            D
10405                        ));
10406                    }
10407                    #[allow(irrefutable_let_patterns)]
10408                    if let SettableTypeSpecificElementState::Dynamics(ref mut val) = self {
10409                        fidl::decode!(DynamicsElementState, D, val, decoder, _inner_offset, depth)?;
10410                    } else {
10411                        unreachable!()
10412                    }
10413                }
10414                #[allow(deprecated)]
10415                ordinal => {
10416                    for _ in 0..num_handles {
10417                        decoder.drop_next_handle()?;
10418                    }
10419                    *self = SettableTypeSpecificElementState::__SourceBreaking {
10420                        unknown_ordinal: ordinal,
10421                    };
10422                }
10423            }
10424            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10425                return Err(fidl::Error::InvalidNumBytesInEnvelope);
10426            }
10427            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10428                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10429            }
10430            Ok(())
10431        }
10432    }
10433
10434    impl fidl::encoding::ValueTypeMarker for TypeSpecificElement {
10435        type Borrowed<'a> = &'a Self;
10436        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10437            value
10438        }
10439    }
10440
10441    unsafe impl fidl::encoding::TypeMarker for TypeSpecificElement {
10442        type Owned = Self;
10443
10444        #[inline(always)]
10445        fn inline_align(_context: fidl::encoding::Context) -> usize {
10446            8
10447        }
10448
10449        #[inline(always)]
10450        fn inline_size(_context: fidl::encoding::Context) -> usize {
10451            16
10452        }
10453    }
10454
10455    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TypeSpecificElement, D>
10456        for &TypeSpecificElement
10457    {
10458        #[inline]
10459        unsafe fn encode(
10460            self,
10461            encoder: &mut fidl::encoding::Encoder<'_, D>,
10462            offset: usize,
10463            _depth: fidl::encoding::Depth,
10464        ) -> fidl::Result<()> {
10465            encoder.debug_check_bounds::<TypeSpecificElement>(offset);
10466            encoder.write_num::<u64>(self.ordinal(), offset);
10467            match self {
10468                TypeSpecificElement::VendorSpecific(ref val) => {
10469                    fidl::encoding::encode_in_envelope::<VendorSpecific, D>(
10470                        <VendorSpecific as fidl::encoding::ValueTypeMarker>::borrow(val),
10471                        encoder,
10472                        offset + 8,
10473                        _depth,
10474                    )
10475                }
10476                TypeSpecificElement::Gain(ref val) => {
10477                    fidl::encoding::encode_in_envelope::<Gain, D>(
10478                        <Gain as fidl::encoding::ValueTypeMarker>::borrow(val),
10479                        encoder,
10480                        offset + 8,
10481                        _depth,
10482                    )
10483                }
10484                TypeSpecificElement::Equalizer(ref val) => {
10485                    fidl::encoding::encode_in_envelope::<Equalizer, D>(
10486                        <Equalizer as fidl::encoding::ValueTypeMarker>::borrow(val),
10487                        encoder,
10488                        offset + 8,
10489                        _depth,
10490                    )
10491                }
10492                TypeSpecificElement::Dynamics(ref val) => {
10493                    fidl::encoding::encode_in_envelope::<Dynamics, D>(
10494                        <Dynamics as fidl::encoding::ValueTypeMarker>::borrow(val),
10495                        encoder,
10496                        offset + 8,
10497                        _depth,
10498                    )
10499                }
10500                TypeSpecificElement::Endpoint(ref val) => {
10501                    fidl::encoding::encode_in_envelope::<Endpoint, D>(
10502                        <Endpoint as fidl::encoding::ValueTypeMarker>::borrow(val),
10503                        encoder,
10504                        offset + 8,
10505                        _depth,
10506                    )
10507                }
10508                TypeSpecificElement::DaiInterconnect(ref val) => {
10509                    fidl::encoding::encode_in_envelope::<DaiInterconnect, D>(
10510                        <DaiInterconnect as fidl::encoding::ValueTypeMarker>::borrow(val),
10511                        encoder,
10512                        offset + 8,
10513                        _depth,
10514                    )
10515                }
10516                TypeSpecificElement::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
10517            }
10518        }
10519    }
10520
10521    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TypeSpecificElement {
10522        #[inline(always)]
10523        fn new_empty() -> Self {
10524            Self::__SourceBreaking { unknown_ordinal: 0 }
10525        }
10526
10527        #[inline]
10528        unsafe fn decode(
10529            &mut self,
10530            decoder: &mut fidl::encoding::Decoder<'_, D>,
10531            offset: usize,
10532            mut depth: fidl::encoding::Depth,
10533        ) -> fidl::Result<()> {
10534            decoder.debug_check_bounds::<Self>(offset);
10535            #[allow(unused_variables)]
10536            let next_out_of_line = decoder.next_out_of_line();
10537            let handles_before = decoder.remaining_handles();
10538            let (ordinal, inlined, num_bytes, num_handles) =
10539                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10540
10541            let member_inline_size = match ordinal {
10542                1 => <VendorSpecific as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10543                2 => <Gain as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10544                3 => <Equalizer as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10545                4 => <Dynamics as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10546                5 => <Endpoint as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10547                6 => <DaiInterconnect as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10548                0 => return Err(fidl::Error::UnknownUnionTag),
10549                _ => num_bytes as usize,
10550            };
10551
10552            if inlined != (member_inline_size <= 4) {
10553                return Err(fidl::Error::InvalidInlineBitInEnvelope);
10554            }
10555            let _inner_offset;
10556            if inlined {
10557                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10558                _inner_offset = offset + 8;
10559            } else {
10560                depth.increment()?;
10561                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10562            }
10563            match ordinal {
10564                1 => {
10565                    #[allow(irrefutable_let_patterns)]
10566                    if let TypeSpecificElement::VendorSpecific(_) = self {
10567                        // Do nothing, read the value into the object
10568                    } else {
10569                        // Initialize `self` to the right variant
10570                        *self = TypeSpecificElement::VendorSpecific(fidl::new_empty!(
10571                            VendorSpecific,
10572                            D
10573                        ));
10574                    }
10575                    #[allow(irrefutable_let_patterns)]
10576                    if let TypeSpecificElement::VendorSpecific(ref mut val) = self {
10577                        fidl::decode!(VendorSpecific, D, val, decoder, _inner_offset, depth)?;
10578                    } else {
10579                        unreachable!()
10580                    }
10581                }
10582                2 => {
10583                    #[allow(irrefutable_let_patterns)]
10584                    if let TypeSpecificElement::Gain(_) = self {
10585                        // Do nothing, read the value into the object
10586                    } else {
10587                        // Initialize `self` to the right variant
10588                        *self = TypeSpecificElement::Gain(fidl::new_empty!(Gain, D));
10589                    }
10590                    #[allow(irrefutable_let_patterns)]
10591                    if let TypeSpecificElement::Gain(ref mut val) = self {
10592                        fidl::decode!(Gain, D, val, decoder, _inner_offset, depth)?;
10593                    } else {
10594                        unreachable!()
10595                    }
10596                }
10597                3 => {
10598                    #[allow(irrefutable_let_patterns)]
10599                    if let TypeSpecificElement::Equalizer(_) = self {
10600                        // Do nothing, read the value into the object
10601                    } else {
10602                        // Initialize `self` to the right variant
10603                        *self = TypeSpecificElement::Equalizer(fidl::new_empty!(Equalizer, D));
10604                    }
10605                    #[allow(irrefutable_let_patterns)]
10606                    if let TypeSpecificElement::Equalizer(ref mut val) = self {
10607                        fidl::decode!(Equalizer, D, val, decoder, _inner_offset, depth)?;
10608                    } else {
10609                        unreachable!()
10610                    }
10611                }
10612                4 => {
10613                    #[allow(irrefutable_let_patterns)]
10614                    if let TypeSpecificElement::Dynamics(_) = self {
10615                        // Do nothing, read the value into the object
10616                    } else {
10617                        // Initialize `self` to the right variant
10618                        *self = TypeSpecificElement::Dynamics(fidl::new_empty!(Dynamics, D));
10619                    }
10620                    #[allow(irrefutable_let_patterns)]
10621                    if let TypeSpecificElement::Dynamics(ref mut val) = self {
10622                        fidl::decode!(Dynamics, D, val, decoder, _inner_offset, depth)?;
10623                    } else {
10624                        unreachable!()
10625                    }
10626                }
10627                5 => {
10628                    #[allow(irrefutable_let_patterns)]
10629                    if let TypeSpecificElement::Endpoint(_) = self {
10630                        // Do nothing, read the value into the object
10631                    } else {
10632                        // Initialize `self` to the right variant
10633                        *self = TypeSpecificElement::Endpoint(fidl::new_empty!(Endpoint, D));
10634                    }
10635                    #[allow(irrefutable_let_patterns)]
10636                    if let TypeSpecificElement::Endpoint(ref mut val) = self {
10637                        fidl::decode!(Endpoint, D, val, decoder, _inner_offset, depth)?;
10638                    } else {
10639                        unreachable!()
10640                    }
10641                }
10642                6 => {
10643                    #[allow(irrefutable_let_patterns)]
10644                    if let TypeSpecificElement::DaiInterconnect(_) = self {
10645                        // Do nothing, read the value into the object
10646                    } else {
10647                        // Initialize `self` to the right variant
10648                        *self = TypeSpecificElement::DaiInterconnect(fidl::new_empty!(
10649                            DaiInterconnect,
10650                            D
10651                        ));
10652                    }
10653                    #[allow(irrefutable_let_patterns)]
10654                    if let TypeSpecificElement::DaiInterconnect(ref mut val) = self {
10655                        fidl::decode!(DaiInterconnect, D, val, decoder, _inner_offset, depth)?;
10656                    } else {
10657                        unreachable!()
10658                    }
10659                }
10660                #[allow(deprecated)]
10661                ordinal => {
10662                    for _ in 0..num_handles {
10663                        decoder.drop_next_handle()?;
10664                    }
10665                    *self = TypeSpecificElement::__SourceBreaking { unknown_ordinal: ordinal };
10666                }
10667            }
10668            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10669                return Err(fidl::Error::InvalidNumBytesInEnvelope);
10670            }
10671            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10672                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10673            }
10674            Ok(())
10675        }
10676    }
10677
10678    impl fidl::encoding::ValueTypeMarker for TypeSpecificElementState {
10679        type Borrowed<'a> = &'a Self;
10680        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10681            value
10682        }
10683    }
10684
10685    unsafe impl fidl::encoding::TypeMarker for TypeSpecificElementState {
10686        type Owned = Self;
10687
10688        #[inline(always)]
10689        fn inline_align(_context: fidl::encoding::Context) -> usize {
10690            8
10691        }
10692
10693        #[inline(always)]
10694        fn inline_size(_context: fidl::encoding::Context) -> usize {
10695            16
10696        }
10697    }
10698
10699    unsafe impl<D: fidl::encoding::ResourceDialect>
10700        fidl::encoding::Encode<TypeSpecificElementState, D> for &TypeSpecificElementState
10701    {
10702        #[inline]
10703        unsafe fn encode(
10704            self,
10705            encoder: &mut fidl::encoding::Encoder<'_, D>,
10706            offset: usize,
10707            _depth: fidl::encoding::Depth,
10708        ) -> fidl::Result<()> {
10709            encoder.debug_check_bounds::<TypeSpecificElementState>(offset);
10710            encoder.write_num::<u64>(self.ordinal(), offset);
10711            match self {
10712                TypeSpecificElementState::VendorSpecific(ref val) => {
10713                    fidl::encoding::encode_in_envelope::<VendorSpecificState, D>(
10714                        <VendorSpecificState as fidl::encoding::ValueTypeMarker>::borrow(val),
10715                        encoder,
10716                        offset + 8,
10717                        _depth,
10718                    )
10719                }
10720                TypeSpecificElementState::Gain(ref val) => {
10721                    fidl::encoding::encode_in_envelope::<GainElementState, D>(
10722                        <GainElementState as fidl::encoding::ValueTypeMarker>::borrow(val),
10723                        encoder,
10724                        offset + 8,
10725                        _depth,
10726                    )
10727                }
10728                TypeSpecificElementState::Equalizer(ref val) => {
10729                    fidl::encoding::encode_in_envelope::<EqualizerElementState, D>(
10730                        <EqualizerElementState as fidl::encoding::ValueTypeMarker>::borrow(val),
10731                        encoder,
10732                        offset + 8,
10733                        _depth,
10734                    )
10735                }
10736                TypeSpecificElementState::Dynamics(ref val) => {
10737                    fidl::encoding::encode_in_envelope::<DynamicsElementState, D>(
10738                        <DynamicsElementState as fidl::encoding::ValueTypeMarker>::borrow(val),
10739                        encoder,
10740                        offset + 8,
10741                        _depth,
10742                    )
10743                }
10744                TypeSpecificElementState::Endpoint(ref val) => {
10745                    fidl::encoding::encode_in_envelope::<EndpointElementState, D>(
10746                        <EndpointElementState as fidl::encoding::ValueTypeMarker>::borrow(val),
10747                        encoder,
10748                        offset + 8,
10749                        _depth,
10750                    )
10751                }
10752                TypeSpecificElementState::DaiInterconnect(ref val) => {
10753                    fidl::encoding::encode_in_envelope::<DaiInterconnectElementState, D>(
10754                        <DaiInterconnectElementState as fidl::encoding::ValueTypeMarker>::borrow(
10755                            val,
10756                        ),
10757                        encoder,
10758                        offset + 8,
10759                        _depth,
10760                    )
10761                }
10762                TypeSpecificElementState::__SourceBreaking { .. } => {
10763                    Err(fidl::Error::UnknownUnionTag)
10764                }
10765            }
10766        }
10767    }
10768
10769    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10770        for TypeSpecificElementState
10771    {
10772        #[inline(always)]
10773        fn new_empty() -> Self {
10774            Self::__SourceBreaking { unknown_ordinal: 0 }
10775        }
10776
10777        #[inline]
10778        unsafe fn decode(
10779            &mut self,
10780            decoder: &mut fidl::encoding::Decoder<'_, D>,
10781            offset: usize,
10782            mut depth: fidl::encoding::Depth,
10783        ) -> fidl::Result<()> {
10784            decoder.debug_check_bounds::<Self>(offset);
10785            #[allow(unused_variables)]
10786            let next_out_of_line = decoder.next_out_of_line();
10787            let handles_before = decoder.remaining_handles();
10788            let (ordinal, inlined, num_bytes, num_handles) =
10789                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
10790
10791            let member_inline_size = match ordinal {
10792                1 => <VendorSpecificState as fidl::encoding::TypeMarker>::inline_size(
10793                    decoder.context,
10794                ),
10795                2 => <GainElementState as fidl::encoding::TypeMarker>::inline_size(decoder.context),
10796                3 => <EqualizerElementState as fidl::encoding::TypeMarker>::inline_size(
10797                    decoder.context,
10798                ),
10799                4 => <DynamicsElementState as fidl::encoding::TypeMarker>::inline_size(
10800                    decoder.context,
10801                ),
10802                5 => <EndpointElementState as fidl::encoding::TypeMarker>::inline_size(
10803                    decoder.context,
10804                ),
10805                6 => <DaiInterconnectElementState as fidl::encoding::TypeMarker>::inline_size(
10806                    decoder.context,
10807                ),
10808                0 => return Err(fidl::Error::UnknownUnionTag),
10809                _ => num_bytes as usize,
10810            };
10811
10812            if inlined != (member_inline_size <= 4) {
10813                return Err(fidl::Error::InvalidInlineBitInEnvelope);
10814            }
10815            let _inner_offset;
10816            if inlined {
10817                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
10818                _inner_offset = offset + 8;
10819            } else {
10820                depth.increment()?;
10821                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10822            }
10823            match ordinal {
10824                1 => {
10825                    #[allow(irrefutable_let_patterns)]
10826                    if let TypeSpecificElementState::VendorSpecific(_) = self {
10827                        // Do nothing, read the value into the object
10828                    } else {
10829                        // Initialize `self` to the right variant
10830                        *self = TypeSpecificElementState::VendorSpecific(fidl::new_empty!(
10831                            VendorSpecificState,
10832                            D
10833                        ));
10834                    }
10835                    #[allow(irrefutable_let_patterns)]
10836                    if let TypeSpecificElementState::VendorSpecific(ref mut val) = self {
10837                        fidl::decode!(VendorSpecificState, D, val, decoder, _inner_offset, depth)?;
10838                    } else {
10839                        unreachable!()
10840                    }
10841                }
10842                2 => {
10843                    #[allow(irrefutable_let_patterns)]
10844                    if let TypeSpecificElementState::Gain(_) = self {
10845                        // Do nothing, read the value into the object
10846                    } else {
10847                        // Initialize `self` to the right variant
10848                        *self =
10849                            TypeSpecificElementState::Gain(fidl::new_empty!(GainElementState, D));
10850                    }
10851                    #[allow(irrefutable_let_patterns)]
10852                    if let TypeSpecificElementState::Gain(ref mut val) = self {
10853                        fidl::decode!(GainElementState, D, val, decoder, _inner_offset, depth)?;
10854                    } else {
10855                        unreachable!()
10856                    }
10857                }
10858                3 => {
10859                    #[allow(irrefutable_let_patterns)]
10860                    if let TypeSpecificElementState::Equalizer(_) = self {
10861                        // Do nothing, read the value into the object
10862                    } else {
10863                        // Initialize `self` to the right variant
10864                        *self = TypeSpecificElementState::Equalizer(fidl::new_empty!(
10865                            EqualizerElementState,
10866                            D
10867                        ));
10868                    }
10869                    #[allow(irrefutable_let_patterns)]
10870                    if let TypeSpecificElementState::Equalizer(ref mut val) = self {
10871                        fidl::decode!(
10872                            EqualizerElementState,
10873                            D,
10874                            val,
10875                            decoder,
10876                            _inner_offset,
10877                            depth
10878                        )?;
10879                    } else {
10880                        unreachable!()
10881                    }
10882                }
10883                4 => {
10884                    #[allow(irrefutable_let_patterns)]
10885                    if let TypeSpecificElementState::Dynamics(_) = self {
10886                        // Do nothing, read the value into the object
10887                    } else {
10888                        // Initialize `self` to the right variant
10889                        *self = TypeSpecificElementState::Dynamics(fidl::new_empty!(
10890                            DynamicsElementState,
10891                            D
10892                        ));
10893                    }
10894                    #[allow(irrefutable_let_patterns)]
10895                    if let TypeSpecificElementState::Dynamics(ref mut val) = self {
10896                        fidl::decode!(DynamicsElementState, D, val, decoder, _inner_offset, depth)?;
10897                    } else {
10898                        unreachable!()
10899                    }
10900                }
10901                5 => {
10902                    #[allow(irrefutable_let_patterns)]
10903                    if let TypeSpecificElementState::Endpoint(_) = self {
10904                        // Do nothing, read the value into the object
10905                    } else {
10906                        // Initialize `self` to the right variant
10907                        *self = TypeSpecificElementState::Endpoint(fidl::new_empty!(
10908                            EndpointElementState,
10909                            D
10910                        ));
10911                    }
10912                    #[allow(irrefutable_let_patterns)]
10913                    if let TypeSpecificElementState::Endpoint(ref mut val) = self {
10914                        fidl::decode!(EndpointElementState, D, val, decoder, _inner_offset, depth)?;
10915                    } else {
10916                        unreachable!()
10917                    }
10918                }
10919                6 => {
10920                    #[allow(irrefutable_let_patterns)]
10921                    if let TypeSpecificElementState::DaiInterconnect(_) = self {
10922                        // Do nothing, read the value into the object
10923                    } else {
10924                        // Initialize `self` to the right variant
10925                        *self = TypeSpecificElementState::DaiInterconnect(fidl::new_empty!(
10926                            DaiInterconnectElementState,
10927                            D
10928                        ));
10929                    }
10930                    #[allow(irrefutable_let_patterns)]
10931                    if let TypeSpecificElementState::DaiInterconnect(ref mut val) = self {
10932                        fidl::decode!(
10933                            DaiInterconnectElementState,
10934                            D,
10935                            val,
10936                            decoder,
10937                            _inner_offset,
10938                            depth
10939                        )?;
10940                    } else {
10941                        unreachable!()
10942                    }
10943                }
10944                #[allow(deprecated)]
10945                ordinal => {
10946                    for _ in 0..num_handles {
10947                        decoder.drop_next_handle()?;
10948                    }
10949                    *self = TypeSpecificElementState::__SourceBreaking { unknown_ordinal: ordinal };
10950                }
10951            }
10952            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
10953                return Err(fidl::Error::InvalidNumBytesInEnvelope);
10954            }
10955            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10956                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10957            }
10958            Ok(())
10959        }
10960    }
10961}