fidl_fuchsia_audio_device__common/
fidl_fuchsia_audio_device__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// Common aliases, consts and types used by more than one of the fuchsia.audio.device protocols.
12pub type ClockDomain = u32;
13
14pub type ElementId = u64;
15
16pub type TokenId = u64;
17
18pub type TopologyId = u64;
19
20/// For devices with Codec drivers, there is only one DAI_INTERCONNECT entity. When a method
21/// requires us to address the interconnect by ID, we use element_id 1. Codec drivers that
22/// implement signalprocessing should not assign this ID to other elements.
23pub const DEFAULT_DAI_INTERCONNECT_ELEMENT_ID: u64 = 1;
24
25/// Maximum number of channels that a device can report as supported.
26pub const MAX_COUNT_CHANNELS: u32 =
27    fidl_fuchsia_hardware_audio__common::MAX_COUNT_CHANNELS_IN_RING_BUFFER as u32;
28
29/// Maximum number of `ChannelSet`s that a device can report in a single PcmFormatSet.
30pub const MAX_COUNT_CHANNEL_SETS: u32 =
31    fidl_fuchsia_hardware_audio__common::MAX_COUNT_CHANNEL_SETS as u32;
32
33pub const MAX_COUNT_DAI_FORMATS: u32 =
34    fidl_fuchsia_hardware_audio__common::MAX_COUNT_DAI_FORMATS as u32;
35
36/// Maximum number of audio devices in the system at any time.
37pub const MAX_COUNT_DEVICES: u32 = 256;
38
39/// Maximum number of `PcmFormatSet`s that a device can report as supported.
40pub const MAX_COUNT_FORMATS: u32 = fidl_fuchsia_hardware_audio__common::MAX_COUNT_FORMATS as u32;
41
42/// Maximum number of processing elements supported by a single device.
43pub const MAX_COUNT_PROCESSING_ELEMENTS: u32 =
44    fidl_fuchsia_hardware_audio_signalprocessing__common::MAX_COUNT_PROCESSING_ELEMENTS as u32;
45
46/// Maximum number of frame rates that a device can report in a PcmFormatSet.
47pub const MAX_COUNT_RATES: u32 =
48    fidl_fuchsia_hardware_audio__common::MAX_COUNT_SUPPORTED_RATES as u32;
49
50/// Maximum number of distinct sample formats that a single PcmFormatSet can contain.
51pub const MAX_COUNT_SAMPLE_TYPES: u32 = 32;
52
53/// Maximum length of the strings for device, manufacturer and product names.
54pub const MAX_STRING_SIZE: u32 = fidl_fuchsia_hardware_audio__common::MAX_UI_STRING_SIZE as u32;
55
56/// The length of the device's unique ID, in bytes.
57pub const UNIQUE_INSTANCE_ID_SIZE: u32 = fidl_fuchsia_hardware_audio__common::UNIQUE_ID_SIZE as u32;
58
59/// Errors returned by `Control/CodecStart`.
60#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
61pub enum ControlCodecStartError {
62    /// This device has encountered an error and can no longer be controlled.
63    DeviceError,
64    /// This device type does not support the method that was called.
65    WrongDeviceType,
66    /// The previous `CodecStart` call has not yet completed.
67    AlreadyPending,
68    /// `SetDaiFormat` was not called before making this call.
69    DaiFormatNotSet,
70    /// The device was already started when this call was made.
71    AlreadyStarted,
72    /// The driver returned some other error. This call may be retried.
73    Other,
74    #[doc(hidden)]
75    __SourceBreaking { unknown_ordinal: u32 },
76}
77
78/// Pattern that matches an unknown `ControlCodecStartError` member.
79#[macro_export]
80macro_rules! ControlCodecStartErrorUnknown {
81    () => {
82        _
83    };
84}
85
86impl ControlCodecStartError {
87    #[inline]
88    pub fn from_primitive(prim: u32) -> Option<Self> {
89        match prim {
90            1 => Some(Self::DeviceError),
91            2 => Some(Self::WrongDeviceType),
92            3 => Some(Self::AlreadyPending),
93            4 => Some(Self::DaiFormatNotSet),
94            5 => Some(Self::AlreadyStarted),
95            6 => Some(Self::Other),
96            _ => None,
97        }
98    }
99
100    #[inline]
101    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
102        match prim {
103            1 => Self::DeviceError,
104            2 => Self::WrongDeviceType,
105            3 => Self::AlreadyPending,
106            4 => Self::DaiFormatNotSet,
107            5 => Self::AlreadyStarted,
108            6 => Self::Other,
109            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
110        }
111    }
112
113    #[inline]
114    pub fn unknown() -> Self {
115        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
116    }
117
118    #[inline]
119    pub const fn into_primitive(self) -> u32 {
120        match self {
121            Self::DeviceError => 1,
122            Self::WrongDeviceType => 2,
123            Self::AlreadyPending => 3,
124            Self::DaiFormatNotSet => 4,
125            Self::AlreadyStarted => 5,
126            Self::Other => 6,
127            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
128        }
129    }
130
131    #[inline]
132    pub fn is_unknown(&self) -> bool {
133        match self {
134            Self::__SourceBreaking { unknown_ordinal: _ } => true,
135            _ => false,
136        }
137    }
138}
139
140/// Errors returned by `Control/CodecStop`.
141#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
142pub enum ControlCodecStopError {
143    /// This device has encountered an error and can no longer be controlled.
144    DeviceError,
145    /// This device type does not support the method that was called.
146    WrongDeviceType,
147    /// The previous `CodecStop` call has not yet completed.
148    AlreadyPending,
149    /// `SetDaiFormat` was not called before making this call.
150    DaiFormatNotSet,
151    /// The device was already stopped when this call was made.
152    AlreadyStopped,
153    /// The driver returned some other error. This call may be retried.
154    Other,
155    #[doc(hidden)]
156    __SourceBreaking { unknown_ordinal: u32 },
157}
158
159/// Pattern that matches an unknown `ControlCodecStopError` member.
160#[macro_export]
161macro_rules! ControlCodecStopErrorUnknown {
162    () => {
163        _
164    };
165}
166
167impl ControlCodecStopError {
168    #[inline]
169    pub fn from_primitive(prim: u32) -> Option<Self> {
170        match prim {
171            1 => Some(Self::DeviceError),
172            2 => Some(Self::WrongDeviceType),
173            3 => Some(Self::AlreadyPending),
174            4 => Some(Self::DaiFormatNotSet),
175            5 => Some(Self::AlreadyStopped),
176            6 => Some(Self::Other),
177            _ => None,
178        }
179    }
180
181    #[inline]
182    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
183        match prim {
184            1 => Self::DeviceError,
185            2 => Self::WrongDeviceType,
186            3 => Self::AlreadyPending,
187            4 => Self::DaiFormatNotSet,
188            5 => Self::AlreadyStopped,
189            6 => Self::Other,
190            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
191        }
192    }
193
194    #[inline]
195    pub fn unknown() -> Self {
196        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
197    }
198
199    #[inline]
200    pub const fn into_primitive(self) -> u32 {
201        match self {
202            Self::DeviceError => 1,
203            Self::WrongDeviceType => 2,
204            Self::AlreadyPending => 3,
205            Self::DaiFormatNotSet => 4,
206            Self::AlreadyStopped => 5,
207            Self::Other => 6,
208            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
209        }
210    }
211
212    #[inline]
213    pub fn is_unknown(&self) -> bool {
214        match self {
215            Self::__SourceBreaking { unknown_ordinal: _ } => true,
216            _ => false,
217        }
218    }
219}
220
221/// Errors returned by `Control/CreateRingBuffer`.
222#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
223pub enum ControlCreateRingBufferError {
224    /// This device has encountered an error and can no longer be controlled.
225    DeviceError,
226    /// This device type does not support the method that was called.
227    WrongDeviceType,
228    /// The previous `CreateRingBuffer` call has not yet completed.
229    AlreadyPending,
230    /// The required `element_id` is missing or does not refer to a `RING_BUFFER` element.
231    InvalidElementId,
232    /// The required `options` is missing.
233    InvalidOptions,
234    /// The required `options.format` is missing.
235    InvalidFormat,
236    /// The required `options.ring_buffer_min_bytes` is missing.
237    InvalidMinBytes,
238    /// The required `ring_buffer_server` is missing.
239    InvalidRingBuffer,
240    /// An active `RingBuffer` instance already exists for this `Control`.
241    AlreadyAllocated,
242    /// The device does not support the specified format.
243    FormatMismatch,
244    /// The device cannot create a ring buffer with the specified options.
245    BadRingBufferOption,
246    /// The driver returned some other error. This call may be retried.
247    Other,
248    #[doc(hidden)]
249    __SourceBreaking { unknown_ordinal: u32 },
250}
251
252/// Pattern that matches an unknown `ControlCreateRingBufferError` member.
253#[macro_export]
254macro_rules! ControlCreateRingBufferErrorUnknown {
255    () => {
256        _
257    };
258}
259
260impl ControlCreateRingBufferError {
261    #[inline]
262    pub fn from_primitive(prim: u32) -> Option<Self> {
263        match prim {
264            1 => Some(Self::DeviceError),
265            2 => Some(Self::WrongDeviceType),
266            3 => Some(Self::AlreadyPending),
267            4 => Some(Self::InvalidElementId),
268            5 => Some(Self::InvalidOptions),
269            6 => Some(Self::InvalidFormat),
270            7 => Some(Self::InvalidMinBytes),
271            8 => Some(Self::InvalidRingBuffer),
272            9 => Some(Self::AlreadyAllocated),
273            10 => Some(Self::FormatMismatch),
274            11 => Some(Self::BadRingBufferOption),
275            12 => Some(Self::Other),
276            _ => None,
277        }
278    }
279
280    #[inline]
281    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
282        match prim {
283            1 => Self::DeviceError,
284            2 => Self::WrongDeviceType,
285            3 => Self::AlreadyPending,
286            4 => Self::InvalidElementId,
287            5 => Self::InvalidOptions,
288            6 => Self::InvalidFormat,
289            7 => Self::InvalidMinBytes,
290            8 => Self::InvalidRingBuffer,
291            9 => Self::AlreadyAllocated,
292            10 => Self::FormatMismatch,
293            11 => Self::BadRingBufferOption,
294            12 => Self::Other,
295            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
296        }
297    }
298
299    #[inline]
300    pub fn unknown() -> Self {
301        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
302    }
303
304    #[inline]
305    pub const fn into_primitive(self) -> u32 {
306        match self {
307            Self::DeviceError => 1,
308            Self::WrongDeviceType => 2,
309            Self::AlreadyPending => 3,
310            Self::InvalidElementId => 4,
311            Self::InvalidOptions => 5,
312            Self::InvalidFormat => 6,
313            Self::InvalidMinBytes => 7,
314            Self::InvalidRingBuffer => 8,
315            Self::AlreadyAllocated => 9,
316            Self::FormatMismatch => 10,
317            Self::BadRingBufferOption => 11,
318            Self::Other => 12,
319            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
320        }
321    }
322
323    #[inline]
324    pub fn is_unknown(&self) -> bool {
325        match self {
326            Self::__SourceBreaking { unknown_ordinal: _ } => true,
327            _ => false,
328        }
329    }
330}
331
332/// Errors returned by `ControlCreator/Create`.
333#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
334pub enum ControlCreatorError {
335    /// The required `token_id` is missing.
336    InvalidTokenId,
337    /// The required `control_server` is missing.
338    InvalidControl,
339    /// No device with `token_id` was found. Either this token has never been
340    /// used, or the device with `token_id` has been removed.
341    DeviceNotFound,
342    /// The device with `token_id` encountered an error and cannot be controlled.
343    DeviceError,
344    /// A `Control` associated with `token_id` already exists. This device is
345    /// already being actively controlled.
346    AlreadyAllocated,
347    #[doc(hidden)]
348    __SourceBreaking { unknown_ordinal: u32 },
349}
350
351/// Pattern that matches an unknown `ControlCreatorError` member.
352#[macro_export]
353macro_rules! ControlCreatorErrorUnknown {
354    () => {
355        _
356    };
357}
358
359impl ControlCreatorError {
360    #[inline]
361    pub fn from_primitive(prim: u32) -> Option<Self> {
362        match prim {
363            1 => Some(Self::InvalidTokenId),
364            2 => Some(Self::InvalidControl),
365            3 => Some(Self::DeviceNotFound),
366            4 => Some(Self::DeviceError),
367            5 => Some(Self::AlreadyAllocated),
368            _ => None,
369        }
370    }
371
372    #[inline]
373    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
374        match prim {
375            1 => Self::InvalidTokenId,
376            2 => Self::InvalidControl,
377            3 => Self::DeviceNotFound,
378            4 => Self::DeviceError,
379            5 => Self::AlreadyAllocated,
380            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
381        }
382    }
383
384    #[inline]
385    pub fn unknown() -> Self {
386        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
387    }
388
389    #[inline]
390    pub const fn into_primitive(self) -> u32 {
391        match self {
392            Self::InvalidTokenId => 1,
393            Self::InvalidControl => 2,
394            Self::DeviceNotFound => 3,
395            Self::DeviceError => 4,
396            Self::AlreadyAllocated => 5,
397            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
398        }
399    }
400
401    #[inline]
402    pub fn is_unknown(&self) -> bool {
403        match self {
404            Self::__SourceBreaking { unknown_ordinal: _ } => true,
405            _ => false,
406        }
407    }
408}
409
410/// Errors returned by `Control/Reset`.
411#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
412pub enum ControlResetError {
413    /// This device has encountered an error and can no longer be controlled.
414    DeviceError,
415    /// This device type does not support the method that was called.
416    WrongDeviceType,
417    /// The previous `Reset` call has not yet completed.
418    AlreadyPending,
419    #[doc(hidden)]
420    __SourceBreaking { unknown_ordinal: u32 },
421}
422
423/// Pattern that matches an unknown `ControlResetError` member.
424#[macro_export]
425macro_rules! ControlResetErrorUnknown {
426    () => {
427        _
428    };
429}
430
431impl ControlResetError {
432    #[inline]
433    pub fn from_primitive(prim: u32) -> Option<Self> {
434        match prim {
435            1 => Some(Self::DeviceError),
436            2 => Some(Self::WrongDeviceType),
437            3 => Some(Self::AlreadyPending),
438            _ => None,
439        }
440    }
441
442    #[inline]
443    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
444        match prim {
445            1 => Self::DeviceError,
446            2 => Self::WrongDeviceType,
447            3 => Self::AlreadyPending,
448            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
449        }
450    }
451
452    #[inline]
453    pub fn unknown() -> Self {
454        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
455    }
456
457    #[inline]
458    pub const fn into_primitive(self) -> u32 {
459        match self {
460            Self::DeviceError => 1,
461            Self::WrongDeviceType => 2,
462            Self::AlreadyPending => 3,
463            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
464        }
465    }
466
467    #[inline]
468    pub fn is_unknown(&self) -> bool {
469        match self {
470            Self::__SourceBreaking { unknown_ordinal: _ } => true,
471            _ => false,
472        }
473    }
474}
475
476/// Errors returned by `Control/SetDaiFormat`.
477#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
478pub enum ControlSetDaiFormatError {
479    /// This device has encountered an error and can no longer be controlled.
480    DeviceError,
481    /// This device type does not support the method that was called.
482    WrongDeviceType,
483    /// The previous `SetDaiFormat` call has not yet completed.
484    AlreadyPending,
485    /// The required `element_id` is missing or does not refer to a `DAI_INTERCONNECT` element.
486    InvalidElementId,
487    /// The required `dai_format` is missing or invalid.
488    InvalidDaiFormat,
489    /// The device does not support the specified dai_format.
490    FormatMismatch,
491    /// The driver returned some other error. This call may be retried.
492    Other,
493    #[doc(hidden)]
494    __SourceBreaking { unknown_ordinal: u32 },
495}
496
497/// Pattern that matches an unknown `ControlSetDaiFormatError` member.
498#[macro_export]
499macro_rules! ControlSetDaiFormatErrorUnknown {
500    () => {
501        _
502    };
503}
504
505impl ControlSetDaiFormatError {
506    #[inline]
507    pub fn from_primitive(prim: u32) -> Option<Self> {
508        match prim {
509            1 => Some(Self::DeviceError),
510            2 => Some(Self::WrongDeviceType),
511            3 => Some(Self::AlreadyPending),
512            4 => Some(Self::InvalidElementId),
513            5 => Some(Self::InvalidDaiFormat),
514            6 => Some(Self::FormatMismatch),
515            7 => Some(Self::Other),
516            _ => None,
517        }
518    }
519
520    #[inline]
521    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
522        match prim {
523            1 => Self::DeviceError,
524            2 => Self::WrongDeviceType,
525            3 => Self::AlreadyPending,
526            4 => Self::InvalidElementId,
527            5 => Self::InvalidDaiFormat,
528            6 => Self::FormatMismatch,
529            7 => Self::Other,
530            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
531        }
532    }
533
534    #[inline]
535    pub fn unknown() -> Self {
536        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
537    }
538
539    #[inline]
540    pub const fn into_primitive(self) -> u32 {
541        match self {
542            Self::DeviceError => 1,
543            Self::WrongDeviceType => 2,
544            Self::AlreadyPending => 3,
545            Self::InvalidElementId => 4,
546            Self::InvalidDaiFormat => 5,
547            Self::FormatMismatch => 6,
548            Self::Other => 7,
549            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
550        }
551    }
552
553    #[inline]
554    pub fn is_unknown(&self) -> bool {
555        match self {
556            Self::__SourceBreaking { unknown_ordinal: _ } => true,
557            _ => false,
558        }
559    }
560}
561
562/// The protocol used by the driver.
563#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
564pub enum DeviceType {
565    /// The device uses the `fuchsia.hardware.audio/Codec` protocol.
566    Codec,
567    /// The device uses the `fuchsia.hardware.audio/Composite` protocol.
568    Composite,
569    #[doc(hidden)]
570    __SourceBreaking { unknown_ordinal: u32 },
571}
572
573/// Pattern that matches an unknown `DeviceType` member.
574#[macro_export]
575macro_rules! DeviceTypeUnknown {
576    () => {
577        _
578    };
579}
580
581impl DeviceType {
582    #[inline]
583    pub fn from_primitive(prim: u32) -> Option<Self> {
584        match prim {
585            1 => Some(Self::Codec),
586            2 => Some(Self::Composite),
587            _ => None,
588        }
589    }
590
591    #[inline]
592    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
593        match prim {
594            1 => Self::Codec,
595            2 => Self::Composite,
596            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
597        }
598    }
599
600    #[inline]
601    pub fn unknown() -> Self {
602        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
603    }
604
605    #[inline]
606    pub const fn into_primitive(self) -> u32 {
607        match self {
608            Self::Codec => 1,
609            Self::Composite => 2,
610            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
611        }
612    }
613
614    #[inline]
615    pub fn is_unknown(&self) -> bool {
616        match self {
617            Self::__SourceBreaking { unknown_ordinal: _ } => true,
618            _ => false,
619        }
620    }
621}
622
623/// Errors returned by `Observer/GetReferenceClock`.
624#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
625pub enum ObserverGetReferenceClockError {
626    /// This device has encountered an error and can no longer be observed.
627    DeviceError,
628    /// This device type does not support the method that was called.
629    WrongDeviceType,
630    /// The device's reference clock could not be returned.
631    DeviceClockUnavailable,
632    #[doc(hidden)]
633    __SourceBreaking { unknown_ordinal: u32 },
634}
635
636/// Pattern that matches an unknown `ObserverGetReferenceClockError` member.
637#[macro_export]
638macro_rules! ObserverGetReferenceClockErrorUnknown {
639    () => {
640        _
641    };
642}
643
644impl ObserverGetReferenceClockError {
645    #[inline]
646    pub fn from_primitive(prim: u32) -> Option<Self> {
647        match prim {
648            1 => Some(Self::DeviceError),
649            2 => Some(Self::WrongDeviceType),
650            3 => Some(Self::DeviceClockUnavailable),
651            _ => None,
652        }
653    }
654
655    #[inline]
656    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
657        match prim {
658            1 => Self::DeviceError,
659            2 => Self::WrongDeviceType,
660            3 => Self::DeviceClockUnavailable,
661            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
662        }
663    }
664
665    #[inline]
666    pub fn unknown() -> Self {
667        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
668    }
669
670    #[inline]
671    pub const fn into_primitive(self) -> u32 {
672        match self {
673            Self::DeviceError => 1,
674            Self::WrongDeviceType => 2,
675            Self::DeviceClockUnavailable => 3,
676            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
677        }
678    }
679
680    #[inline]
681    pub fn is_unknown(&self) -> bool {
682        match self {
683            Self::__SourceBreaking { unknown_ordinal: _ } => true,
684            _ => false,
685        }
686    }
687}
688
689/// Errors returned by `Observer/WatchPlugState`.
690#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
691pub enum ObserverWatchPlugStateError {
692    /// This device has encountered an error and can no longer be observed.
693    DeviceError,
694    /// This device type does not support the method that was called.
695    WrongDeviceType,
696    /// The previous `WatchPlugState` call has not yet completed.
697    AlreadyPending,
698    #[doc(hidden)]
699    __SourceBreaking { unknown_ordinal: u32 },
700}
701
702/// Pattern that matches an unknown `ObserverWatchPlugStateError` member.
703#[macro_export]
704macro_rules! ObserverWatchPlugStateErrorUnknown {
705    () => {
706        _
707    };
708}
709
710impl ObserverWatchPlugStateError {
711    #[inline]
712    pub fn from_primitive(prim: u32) -> Option<Self> {
713        match prim {
714            1 => Some(Self::DeviceError),
715            2 => Some(Self::WrongDeviceType),
716            3 => Some(Self::AlreadyPending),
717            _ => None,
718        }
719    }
720
721    #[inline]
722    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
723        match prim {
724            1 => Self::DeviceError,
725            2 => Self::WrongDeviceType,
726            3 => Self::AlreadyPending,
727            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
728        }
729    }
730
731    #[inline]
732    pub fn unknown() -> Self {
733        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
734    }
735
736    #[inline]
737    pub const fn into_primitive(self) -> u32 {
738        match self {
739            Self::DeviceError => 1,
740            Self::WrongDeviceType => 2,
741            Self::AlreadyPending => 3,
742            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
743        }
744    }
745
746    #[inline]
747    pub fn is_unknown(&self) -> bool {
748        match self {
749            Self::__SourceBreaking { unknown_ordinal: _ } => true,
750            _ => false,
751        }
752    }
753}
754
755/// The device's hot-plug capabilities.
756#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
757pub enum PlugDetectCapabilities {
758    /// Device is always plugged in. Plug state cannot change.
759    Hardwired,
760    /// Device can be un/plugged and can asynchronously notify of changes.
761    Pluggable,
762    #[doc(hidden)]
763    __SourceBreaking { unknown_ordinal: u32 },
764}
765
766/// Pattern that matches an unknown `PlugDetectCapabilities` member.
767#[macro_export]
768macro_rules! PlugDetectCapabilitiesUnknown {
769    () => {
770        _
771    };
772}
773
774impl PlugDetectCapabilities {
775    #[inline]
776    pub fn from_primitive(prim: u32) -> Option<Self> {
777        match prim {
778            0 => Some(Self::Hardwired),
779            1 => Some(Self::Pluggable),
780            _ => None,
781        }
782    }
783
784    #[inline]
785    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
786        match prim {
787            0 => Self::Hardwired,
788            1 => Self::Pluggable,
789            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
790        }
791    }
792
793    #[inline]
794    pub fn unknown() -> Self {
795        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
796    }
797
798    #[inline]
799    pub const fn into_primitive(self) -> u32 {
800        match self {
801            Self::Hardwired => 0,
802            Self::Pluggable => 1,
803            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
804        }
805    }
806
807    #[inline]
808    pub fn is_unknown(&self) -> bool {
809        match self {
810            Self::__SourceBreaking { unknown_ordinal: _ } => true,
811            _ => false,
812        }
813    }
814}
815
816/// The current plugged-in state for the device.
817#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
818pub enum PlugState {
819    /// Connected and available for audio streaming.
820    Plugged,
821    /// Not connected; unavailable for audio streaming.
822    Unplugged,
823    #[doc(hidden)]
824    __SourceBreaking { unknown_ordinal: u32 },
825}
826
827/// Pattern that matches an unknown `PlugState` member.
828#[macro_export]
829macro_rules! PlugStateUnknown {
830    () => {
831        _
832    };
833}
834
835impl PlugState {
836    #[inline]
837    pub fn from_primitive(prim: u32) -> Option<Self> {
838        match prim {
839            1 => Some(Self::Plugged),
840            2 => Some(Self::Unplugged),
841            _ => None,
842        }
843    }
844
845    #[inline]
846    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
847        match prim {
848            1 => Self::Plugged,
849            2 => Self::Unplugged,
850            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
851        }
852    }
853
854    #[inline]
855    pub fn unknown() -> Self {
856        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
857    }
858
859    #[inline]
860    pub const fn into_primitive(self) -> u32 {
861        match self {
862            Self::Plugged => 1,
863            Self::Unplugged => 2,
864            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
865        }
866    }
867
868    #[inline]
869    pub fn is_unknown(&self) -> bool {
870        match self {
871            Self::__SourceBreaking { unknown_ordinal: _ } => true,
872            _ => false,
873        }
874    }
875}
876
877/// Errors returned by the `Provider` protocol.
878#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
879pub enum ProviderAddDeviceError {
880    /// The required `device_name` is incorrectly formed, empty or missing.
881    InvalidName,
882    /// The required `device_type` is missing.
883    InvalidType,
884    /// The required `driver_client` is invalid or missing.
885    InvalidDriverClient,
886    /// The protocol in `driver_client` is incompatible with `device_type` or is not supported yet.
887    WrongClientType,
888    #[doc(hidden)]
889    __SourceBreaking { unknown_ordinal: u32 },
890}
891
892/// Pattern that matches an unknown `ProviderAddDeviceError` member.
893#[macro_export]
894macro_rules! ProviderAddDeviceErrorUnknown {
895    () => {
896        _
897    };
898}
899
900impl ProviderAddDeviceError {
901    #[inline]
902    pub fn from_primitive(prim: u32) -> Option<Self> {
903        match prim {
904            1 => Some(Self::InvalidName),
905            2 => Some(Self::InvalidType),
906            3 => Some(Self::InvalidDriverClient),
907            4 => Some(Self::WrongClientType),
908            _ => None,
909        }
910    }
911
912    #[inline]
913    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
914        match prim {
915            1 => Self::InvalidName,
916            2 => Self::InvalidType,
917            3 => Self::InvalidDriverClient,
918            4 => Self::WrongClientType,
919            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
920        }
921    }
922
923    #[inline]
924    pub fn unknown() -> Self {
925        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
926    }
927
928    #[inline]
929    pub const fn into_primitive(self) -> u32 {
930        match self {
931            Self::InvalidName => 1,
932            Self::InvalidType => 2,
933            Self::InvalidDriverClient => 3,
934            Self::WrongClientType => 4,
935            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
936        }
937    }
938
939    #[inline]
940    pub fn is_unknown(&self) -> bool {
941        match self {
942            Self::__SourceBreaking { unknown_ordinal: _ } => true,
943            _ => false,
944        }
945    }
946}
947
948/// Errors returned by `Registry/CreateObserver`.
949#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
950pub enum RegistryCreateObserverError {
951    /// The required `token_id` is missing.
952    InvalidTokenId,
953    /// The required `observer_server` is missing.
954    InvalidObserver,
955    /// No device with `token_id` was found. Either this token has never been
956    /// used, or the device with `token_id` has been removed.
957    DeviceNotFound,
958    /// The device with `token_id` has encountered an error and can no longer be observed.
959    DeviceError,
960    #[doc(hidden)]
961    __SourceBreaking { unknown_ordinal: u32 },
962}
963
964/// Pattern that matches an unknown `RegistryCreateObserverError` member.
965#[macro_export]
966macro_rules! RegistryCreateObserverErrorUnknown {
967    () => {
968        _
969    };
970}
971
972impl RegistryCreateObserverError {
973    #[inline]
974    pub fn from_primitive(prim: u32) -> Option<Self> {
975        match prim {
976            1 => Some(Self::InvalidTokenId),
977            2 => Some(Self::InvalidObserver),
978            3 => Some(Self::DeviceNotFound),
979            4 => Some(Self::DeviceError),
980            _ => None,
981        }
982    }
983
984    #[inline]
985    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
986        match prim {
987            1 => Self::InvalidTokenId,
988            2 => Self::InvalidObserver,
989            3 => Self::DeviceNotFound,
990            4 => Self::DeviceError,
991            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
992        }
993    }
994
995    #[inline]
996    pub fn unknown() -> Self {
997        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
998    }
999
1000    #[inline]
1001    pub const fn into_primitive(self) -> u32 {
1002        match self {
1003            Self::InvalidTokenId => 1,
1004            Self::InvalidObserver => 2,
1005            Self::DeviceNotFound => 3,
1006            Self::DeviceError => 4,
1007            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1008        }
1009    }
1010
1011    #[inline]
1012    pub fn is_unknown(&self) -> bool {
1013        match self {
1014            Self::__SourceBreaking { unknown_ordinal: _ } => true,
1015            _ => false,
1016        }
1017    }
1018}
1019
1020/// Errors returned by `Registry/WatchDeviceRemoved`.
1021#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1022pub enum RegistryWatchDeviceRemovedError {
1023    /// The previous `WatchDeviceRemoved` call has not yet completed.
1024    AlreadyPending,
1025    #[doc(hidden)]
1026    __SourceBreaking { unknown_ordinal: u32 },
1027}
1028
1029/// Pattern that matches an unknown `RegistryWatchDeviceRemovedError` member.
1030#[macro_export]
1031macro_rules! RegistryWatchDeviceRemovedErrorUnknown {
1032    () => {
1033        _
1034    };
1035}
1036
1037impl RegistryWatchDeviceRemovedError {
1038    #[inline]
1039    pub fn from_primitive(prim: u32) -> Option<Self> {
1040        match prim {
1041            1 => Some(Self::AlreadyPending),
1042            _ => None,
1043        }
1044    }
1045
1046    #[inline]
1047    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1048        match prim {
1049            1 => Self::AlreadyPending,
1050            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1051        }
1052    }
1053
1054    #[inline]
1055    pub fn unknown() -> Self {
1056        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1057    }
1058
1059    #[inline]
1060    pub const fn into_primitive(self) -> u32 {
1061        match self {
1062            Self::AlreadyPending => 1,
1063            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1064        }
1065    }
1066
1067    #[inline]
1068    pub fn is_unknown(&self) -> bool {
1069        match self {
1070            Self::__SourceBreaking { unknown_ordinal: _ } => true,
1071            _ => false,
1072        }
1073    }
1074}
1075
1076/// Errors returned by `Registry/WatchDevicesAdded`.
1077#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1078pub enum RegistryWatchDevicesAddedError {
1079    /// The previous `WatchDevicesAdded` call has not yet completed.
1080    AlreadyPending,
1081    #[doc(hidden)]
1082    __SourceBreaking { unknown_ordinal: u32 },
1083}
1084
1085/// Pattern that matches an unknown `RegistryWatchDevicesAddedError` member.
1086#[macro_export]
1087macro_rules! RegistryWatchDevicesAddedErrorUnknown {
1088    () => {
1089        _
1090    };
1091}
1092
1093impl RegistryWatchDevicesAddedError {
1094    #[inline]
1095    pub fn from_primitive(prim: u32) -> Option<Self> {
1096        match prim {
1097            1 => Some(Self::AlreadyPending),
1098            _ => None,
1099        }
1100    }
1101
1102    #[inline]
1103    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1104        match prim {
1105            1 => Self::AlreadyPending,
1106            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1107        }
1108    }
1109
1110    #[inline]
1111    pub fn unknown() -> Self {
1112        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1113    }
1114
1115    #[inline]
1116    pub const fn into_primitive(self) -> u32 {
1117        match self {
1118            Self::AlreadyPending => 1,
1119            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1120        }
1121    }
1122
1123    #[inline]
1124    pub fn is_unknown(&self) -> bool {
1125        match self {
1126            Self::__SourceBreaking { unknown_ordinal: _ } => true,
1127            _ => false,
1128        }
1129    }
1130}
1131
1132/// Errors returned by `RingBuffer/SetActiveChannels`.
1133#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1134pub enum RingBufferSetActiveChannelsError {
1135    /// This device has encountered an error and can no longer be controlled.
1136    DeviceError,
1137    /// The previous `SetActiveChannels` call has not yet completed.
1138    AlreadyPending,
1139    /// The device does not support `SetActiveChannels`. Individual channels
1140    /// cannot be deactivated (all channels are always active).
1141    MethodNotSupported,
1142    /// The required `channel_bitmask` is missing.
1143    InvalidChannelBitmask,
1144    /// The passed `channel_bitmask` specifies channels that are beyond the
1145    /// range of channels currently configured for this ring buffer.
1146    ChannelOutOfRange,
1147    #[doc(hidden)]
1148    __SourceBreaking { unknown_ordinal: u32 },
1149}
1150
1151/// Pattern that matches an unknown `RingBufferSetActiveChannelsError` member.
1152#[macro_export]
1153macro_rules! RingBufferSetActiveChannelsErrorUnknown {
1154    () => {
1155        _
1156    };
1157}
1158
1159impl RingBufferSetActiveChannelsError {
1160    #[inline]
1161    pub fn from_primitive(prim: u32) -> Option<Self> {
1162        match prim {
1163            1 => Some(Self::DeviceError),
1164            2 => Some(Self::AlreadyPending),
1165            3 => Some(Self::MethodNotSupported),
1166            4 => Some(Self::InvalidChannelBitmask),
1167            5 => Some(Self::ChannelOutOfRange),
1168            _ => None,
1169        }
1170    }
1171
1172    #[inline]
1173    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1174        match prim {
1175            1 => Self::DeviceError,
1176            2 => Self::AlreadyPending,
1177            3 => Self::MethodNotSupported,
1178            4 => Self::InvalidChannelBitmask,
1179            5 => Self::ChannelOutOfRange,
1180            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1181        }
1182    }
1183
1184    #[inline]
1185    pub fn unknown() -> Self {
1186        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1187    }
1188
1189    #[inline]
1190    pub const fn into_primitive(self) -> u32 {
1191        match self {
1192            Self::DeviceError => 1,
1193            Self::AlreadyPending => 2,
1194            Self::MethodNotSupported => 3,
1195            Self::InvalidChannelBitmask => 4,
1196            Self::ChannelOutOfRange => 5,
1197            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1198        }
1199    }
1200
1201    #[inline]
1202    pub fn is_unknown(&self) -> bool {
1203        match self {
1204            Self::__SourceBreaking { unknown_ordinal: _ } => true,
1205            _ => false,
1206        }
1207    }
1208}
1209
1210/// Errors returned by `RingBuffer/Start`.
1211#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1212pub enum RingBufferStartError {
1213    /// This device has encountered an error and can no longer be controlled.
1214    DeviceError,
1215    /// The previous `Start` call has not yet completed.
1216    AlreadyPending,
1217    /// `Start` was called on a ring buffer that is already started.
1218    AlreadyStarted,
1219    #[doc(hidden)]
1220    __SourceBreaking { unknown_ordinal: u32 },
1221}
1222
1223/// Pattern that matches an unknown `RingBufferStartError` member.
1224#[macro_export]
1225macro_rules! RingBufferStartErrorUnknown {
1226    () => {
1227        _
1228    };
1229}
1230
1231impl RingBufferStartError {
1232    #[inline]
1233    pub fn from_primitive(prim: u32) -> Option<Self> {
1234        match prim {
1235            1 => Some(Self::DeviceError),
1236            2 => Some(Self::AlreadyPending),
1237            3 => Some(Self::AlreadyStarted),
1238            _ => None,
1239        }
1240    }
1241
1242    #[inline]
1243    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1244        match prim {
1245            1 => Self::DeviceError,
1246            2 => Self::AlreadyPending,
1247            3 => Self::AlreadyStarted,
1248            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1249        }
1250    }
1251
1252    #[inline]
1253    pub fn unknown() -> Self {
1254        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1255    }
1256
1257    #[inline]
1258    pub const fn into_primitive(self) -> u32 {
1259        match self {
1260            Self::DeviceError => 1,
1261            Self::AlreadyPending => 2,
1262            Self::AlreadyStarted => 3,
1263            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1264        }
1265    }
1266
1267    #[inline]
1268    pub fn is_unknown(&self) -> bool {
1269        match self {
1270            Self::__SourceBreaking { unknown_ordinal: _ } => true,
1271            _ => false,
1272        }
1273    }
1274}
1275
1276/// Errors returned by `RingBuffer/Stop`.
1277#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1278pub enum RingBufferStopError {
1279    /// This device has encountered an error and can no longer be controlled.
1280    DeviceError,
1281    /// The previous `Stop` call has not yet completed.
1282    AlreadyPending,
1283    /// `Stop` was called on a ring buffer that is already stopped.
1284    AlreadyStopped,
1285    #[doc(hidden)]
1286    __SourceBreaking { unknown_ordinal: u32 },
1287}
1288
1289/// Pattern that matches an unknown `RingBufferStopError` member.
1290#[macro_export]
1291macro_rules! RingBufferStopErrorUnknown {
1292    () => {
1293        _
1294    };
1295}
1296
1297impl RingBufferStopError {
1298    #[inline]
1299    pub fn from_primitive(prim: u32) -> Option<Self> {
1300        match prim {
1301            1 => Some(Self::DeviceError),
1302            2 => Some(Self::AlreadyPending),
1303            3 => Some(Self::AlreadyStopped),
1304            _ => None,
1305        }
1306    }
1307
1308    #[inline]
1309    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1310        match prim {
1311            1 => Self::DeviceError,
1312            2 => Self::AlreadyPending,
1313            3 => Self::AlreadyStopped,
1314            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1315        }
1316    }
1317
1318    #[inline]
1319    pub fn unknown() -> Self {
1320        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1321    }
1322
1323    #[inline]
1324    pub const fn into_primitive(self) -> u32 {
1325        match self {
1326            Self::DeviceError => 1,
1327            Self::AlreadyPending => 2,
1328            Self::AlreadyStopped => 3,
1329            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1330        }
1331    }
1332
1333    #[inline]
1334    pub fn is_unknown(&self) -> bool {
1335        match self {
1336            Self::__SourceBreaking { unknown_ordinal: _ } => true,
1337            _ => false,
1338        }
1339    }
1340}
1341
1342/// Errors returned by `RingBuffer/WatchDelayInfo`.
1343#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
1344pub enum RingBufferWatchDelayInfoError {
1345    /// This device has encountered an error and can no longer be observed.
1346    DeviceError,
1347    /// The previous `WatchDelayInfo` call has not yet completed.
1348    AlreadyPending,
1349    #[doc(hidden)]
1350    __SourceBreaking { unknown_ordinal: u32 },
1351}
1352
1353/// Pattern that matches an unknown `RingBufferWatchDelayInfoError` member.
1354#[macro_export]
1355macro_rules! RingBufferWatchDelayInfoErrorUnknown {
1356    () => {
1357        _
1358    };
1359}
1360
1361impl RingBufferWatchDelayInfoError {
1362    #[inline]
1363    pub fn from_primitive(prim: u32) -> Option<Self> {
1364        match prim {
1365            1 => Some(Self::DeviceError),
1366            2 => Some(Self::AlreadyPending),
1367            _ => None,
1368        }
1369    }
1370
1371    #[inline]
1372    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
1373        match prim {
1374            1 => Self::DeviceError,
1375            2 => Self::AlreadyPending,
1376            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
1377        }
1378    }
1379
1380    #[inline]
1381    pub fn unknown() -> Self {
1382        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
1383    }
1384
1385    #[inline]
1386    pub const fn into_primitive(self) -> u32 {
1387        match self {
1388            Self::DeviceError => 1,
1389            Self::AlreadyPending => 2,
1390            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1391        }
1392    }
1393
1394    #[inline]
1395    pub fn is_unknown(&self) -> bool {
1396        match self {
1397            Self::__SourceBreaking { unknown_ordinal: _ } => true,
1398            _ => false,
1399        }
1400    }
1401}
1402
1403/// The attributes (e.g. frequency range) of a single channel.
1404#[derive(Clone, Debug, Default, PartialEq)]
1405pub struct ChannelAttributes {
1406    /// Minimum frequency that this channel guarantees to emit/capture, in Hz.
1407    /// If absent, this channel extends to the bottom of the device range.
1408    ///
1409    /// Optional.
1410    pub min_frequency: Option<u32>,
1411    /// Maximum frequency that this channel guarantees to emit/capture, in Hz.
1412    /// If absent, this channel extends to the top of the device range.
1413    ///
1414    /// Optional.
1415    pub max_frequency: Option<u32>,
1416    #[doc(hidden)]
1417    pub __source_breaking: fidl::marker::SourceBreaking,
1418}
1419
1420impl fidl::Persistable for ChannelAttributes {}
1421
1422/// One possible channel configuration for the device.
1423#[derive(Clone, Debug, Default, PartialEq)]
1424pub struct ChannelSet {
1425    /// Each item in this vector describes the attributes (e.g. frequency range)
1426    /// of that channel. The length of this vector defines the number of
1427    /// channels supported by this ChannelSet. Must contain at least one entry.
1428    ///
1429    /// Required.
1430    pub attributes: Option<Vec<ChannelAttributes>>,
1431    #[doc(hidden)]
1432    pub __source_breaking: fidl::marker::SourceBreaking,
1433}
1434
1435impl fidl::Persistable for ChannelSet {}
1436
1437#[derive(Clone, Debug, Default, PartialEq)]
1438pub struct ControlCreatorCreateResponse {
1439    #[doc(hidden)]
1440    pub __source_breaking: fidl::marker::SourceBreaking,
1441}
1442
1443impl fidl::Persistable for ControlCreatorCreateResponse {}
1444
1445#[derive(Clone, Debug, Default, PartialEq)]
1446pub struct ControlSetDaiFormatRequest {
1447    /// The element ID for an `ENDPOINT` of type `DAI_INTERCONNECT`.
1448    ///
1449    /// Required for Composite; ignored for Codec.
1450    pub element_id: Option<u64>,
1451    pub dai_format: Option<fidl_fuchsia_hardware_audio__common::DaiFormat>,
1452    #[doc(hidden)]
1453    pub __source_breaking: fidl::marker::SourceBreaking,
1454}
1455
1456impl fidl::Persistable for ControlSetDaiFormatRequest {}
1457
1458#[derive(Clone, Debug, Default, PartialEq)]
1459pub struct ControlCodecStartResponse {
1460    pub start_time: Option<i64>,
1461    #[doc(hidden)]
1462    pub __source_breaking: fidl::marker::SourceBreaking,
1463}
1464
1465impl fidl::Persistable for ControlCodecStartResponse {}
1466
1467#[derive(Clone, Debug, Default, PartialEq)]
1468pub struct ControlCodecStopResponse {
1469    pub stop_time: Option<i64>,
1470    #[doc(hidden)]
1471    pub __source_breaking: fidl::marker::SourceBreaking,
1472}
1473
1474impl fidl::Persistable for ControlCodecStopResponse {}
1475
1476#[derive(Clone, Debug, Default, PartialEq)]
1477pub struct ControlResetResponse {
1478    #[doc(hidden)]
1479    pub __source_breaking: fidl::marker::SourceBreaking,
1480}
1481
1482impl fidl::Persistable for ControlResetResponse {}
1483
1484#[derive(Clone, Debug, Default, PartialEq)]
1485pub struct ControlSetDaiFormatResponse {
1486    pub state: Option<fidl_fuchsia_hardware_audio__common::CodecFormatInfo>,
1487    #[doc(hidden)]
1488    pub __source_breaking: fidl::marker::SourceBreaking,
1489}
1490
1491impl fidl::Persistable for ControlSetDaiFormatResponse {}
1492
1493#[derive(Clone, Debug, Default, PartialEq)]
1494pub struct DelayInfo {
1495    /// The driver's best estimate of the delay internal to the hardware it abstracts for
1496    /// the chosen format. This duration must be non-negative.
1497    ///
1498    /// Required.
1499    pub internal_delay: Option<i64>,
1500    /// The amount of pipeline delay beyond the interconnect (subsequent to the
1501    /// DMA "read" position for output devices, or prior to the DMA "write"
1502    /// position for input devices). If present, this duration must be non-negative.
1503    ///
1504    /// Optional.
1505    pub external_delay: Option<i64>,
1506    #[doc(hidden)]
1507    pub __source_breaking: fidl::marker::SourceBreaking,
1508}
1509
1510impl fidl::Persistable for DelayInfo {}
1511
1512/// This table represents the possible Dai formats that this endpoint can support.
1513#[derive(Clone, Debug, Default, PartialEq)]
1514pub struct ElementDaiFormatSet {
1515    /// The ID of the element being described. This must match an ENDPOINT (DAI_INTERCONNECT)
1516    /// entry in the list of elements contained in the device's `Info` table. If describing the
1517    /// supported DAI formats for a Codec device, this value should be
1518    /// `DEFAULT_DAI_INTERCONNECT_ELEMENT_ID` (1).
1519    ///
1520    /// Required.
1521    pub element_id: Option<u64>,
1522    /// The dai_format_set entries that this element supports.
1523    ///
1524    /// Required. Must contain at least one entry.
1525    pub format_sets: Option<Vec<fidl_fuchsia_hardware_audio__common::DaiSupportedFormats>>,
1526    #[doc(hidden)]
1527    pub __source_breaking: fidl::marker::SourceBreaking,
1528}
1529
1530impl fidl::Persistable for ElementDaiFormatSet {}
1531
1532/// This table represents the possible RingBuffer formats that this endpoint can support.
1533#[derive(Clone, Debug, Default, PartialEq)]
1534pub struct ElementRingBufferFormatSet {
1535    /// The ID of the element being described. This must match an ENDPOINT (RING_BUFFER) entry
1536    /// in the list of elements contained in the device's `Info` table.
1537    ///
1538    /// Required.
1539    pub element_id: Option<u64>,
1540    /// The ring_buffer_format_set entries that this element supports.
1541    ///
1542    /// Required. Must contain at least one entry.
1543    pub format_sets: Option<Vec<PcmFormatSet>>,
1544    #[doc(hidden)]
1545    pub __source_breaking: fidl::marker::SourceBreaking,
1546}
1547
1548impl fidl::Persistable for ElementRingBufferFormatSet {}
1549
1550/// When a device is detected (or added via `Provider/AddDevice`), it is
1551/// queried for its properties and capabilities. Once this enumeration process
1552/// completes, it is announced to clients that are watching for device arrivals
1553/// via `Registry/WatchDevicesAdded`.
1554///
1555/// An `Info` table is returned for each audio device that has been added.
1556#[derive(Clone, Debug, Default, PartialEq)]
1557pub struct Info {
1558    /// A device identifier that is guaranteed unique for this boot session, but
1559    /// may change across reboots.
1560    ///
1561    /// Required.
1562    pub token_id: Option<u64>,
1563    /// The protocol used by the driver.
1564    ///
1565    /// Required.
1566    pub device_type: Option<DeviceType>,
1567    /// The device's high-level name, as received from devfs or the `Provider/AddDevice` caller.
1568    /// This string must be non-empty.
1569    ///
1570    /// Required.
1571    pub device_name: Option<String>,
1572    /// The name of the device's manufacturer.
1573    /// If present, this string must be non-empty.
1574    ///
1575    /// Optional.
1576    pub manufacturer: Option<String>,
1577    /// The device's high-level product name.
1578    /// If present, this string must be non-empty.
1579    ///
1580    /// Optional.
1581    pub product: Option<String>,
1582    /// A 16-character ID provided by the driver that (if present) can be used
1583    /// to differentiate instances of the same device. This value should not
1584    /// change across system reboots.
1585    ///
1586    /// Optional.
1587    pub unique_instance_id: Option<[u8; 16]>,
1588    /// Whether the device is a source (is_input TRUE) or destination (is_input FALSE) of audio.
1589    ///
1590    /// Optional for Codec; absent for Composite.
1591    pub is_input: Option<bool>,
1592    /// The union of all formats the device can support, across all combinations of device
1593    /// configuration settings.
1594    /// If the device exposes one or more RingBuffer ENDPOINT elements, this field must be present
1595    /// and its vector must contain exactly one entry for each relevant ENDPOINT element.
1596    /// If the device exposes NO RingBuffer ENDPOINT elements, this field must be omitted (entirely
1597    /// absent, rather than populated with an empty vector).
1598    /// If present, must contain at least one element.
1599    ///
1600    /// Optional for Composite; absent for Codec.
1601    pub ring_buffer_format_sets: Option<Vec<ElementRingBufferFormatSet>>,
1602    /// The union of all DAI formats the device can support, across all combinations
1603    /// of device configuration settings.
1604    /// If the device exposes one or more Dai ENDPOINT elements, this field must be present and its
1605    /// vector must contain exactly one entry for each relevant ENDPOINT element.
1606    /// If the device exposes NO Dai ENDPOINT elements, this field must be omitted (entirely absent,
1607    /// rather than populated with an empty vector).
1608    /// If present, must contain at least one element.
1609    ///
1610    /// Required for Codec; optional for Composite.
1611    pub dai_format_sets: Option<Vec<ElementDaiFormatSet>>,
1612    /// The device's hot-plug capabilities.
1613    ///
1614    /// Required for Codec; absent for Composite.
1615    pub plug_detect_caps: Option<PlugDetectCapabilities>,
1616    /// An identifier for the clock domain in which the device's clock hardware
1617    /// operates. Devices in the same clock domain remain perfectly
1618    /// synchronized. They may drift relative to some other clock domain, but
1619    /// all clocks in that domain will do so perfectly  _together_. Although
1620    /// their clocks have the same rate, their positions may be offset by an
1621    /// arbitrary, fixed amount.
1622    ///
1623    /// There are two special values for clock domain:
1624    ///
1625    /// *  `CLOCK_DOMAIN_MONOTONIC` means the hardware is driven by the system
1626    ///    montonic clock and will always be synchronized with that timeline.
1627    ///
1628    /// *  `CLOCK_DOMAIN_EXTERNAL` means the hardware is not synchronized with any
1629    ///    other known clocks (even any other clocks in `CLOCK_DOMAIN_EXTERNAL`).
1630    ///
1631    /// Required for Composite; absent for Codec.
1632    pub clock_domain: Option<u32>,
1633    /// The vector of supported signal-processing elements.
1634    /// If present, must contain at least one element.
1635    ///
1636    /// Required for Composite; optional for Codec.
1637    pub signal_processing_elements:
1638        Option<Vec<fidl_fuchsia_hardware_audio_signalprocessing__common::Element>>,
1639    /// The vector of supported signal-processing topologies.
1640    /// If present, must contain at least one element.
1641    ///
1642    /// Required for Composite; optional for Codec.
1643    pub signal_processing_topologies:
1644        Option<Vec<fidl_fuchsia_hardware_audio_signalprocessing__common::Topology>>,
1645    #[doc(hidden)]
1646    pub __source_breaking: fidl::marker::SourceBreaking,
1647}
1648
1649impl fidl::Persistable for Info {}
1650
1651#[derive(Clone, Debug, Default, PartialEq)]
1652pub struct ObserverWatchPlugStateResponse {
1653    /// The device's current plug state.
1654    pub state: Option<PlugState>,
1655    /// The time (in CLOCK_MONOTONIC) of the most-recent change in plug state.
1656    pub plug_time: Option<i64>,
1657    #[doc(hidden)]
1658    pub __source_breaking: fidl::marker::SourceBreaking,
1659}
1660
1661impl fidl::Persistable for ObserverWatchPlugStateResponse {}
1662
1663/// This table contains vectors representing three dimensions of device
1664/// configuration (channelization, sample format, frame rate). The device should
1665/// support all combinations of the items in these vectors.
1666#[derive(Clone, Debug, Default, PartialEq)]
1667pub struct PcmFormatSet {
1668    /// The number of channel sets that the device supports. This must contain
1669    /// at least one `ChannelSet` entry.
1670    ///
1671    /// Required.
1672    pub channel_sets: Option<Vec<ChannelSet>>,
1673    /// The number of sample formats that the device supports. This must
1674    /// contain least one `AudioSampleFormat` entry.
1675    ///
1676    /// Required.
1677    pub sample_types: Option<Vec<fidl_fuchsia_audio__common::SampleType>>,
1678    /// The number of frame rates that the device supports. This must contain at
1679    /// least one frame rate entry.
1680    ///
1681    /// Required.
1682    pub frame_rates: Option<Vec<u32>>,
1683    #[doc(hidden)]
1684    pub __source_breaking: fidl::marker::SourceBreaking,
1685}
1686
1687impl fidl::Persistable for PcmFormatSet {}
1688
1689#[derive(Clone, Debug, Default, PartialEq)]
1690pub struct ProviderAddDeviceResponse {
1691    #[doc(hidden)]
1692    pub __source_breaking: fidl::marker::SourceBreaking,
1693}
1694
1695impl fidl::Persistable for ProviderAddDeviceResponse {}
1696
1697#[derive(Clone, Debug, Default, PartialEq)]
1698pub struct RegistryCreateObserverResponse {
1699    #[doc(hidden)]
1700    pub __source_breaking: fidl::marker::SourceBreaking,
1701}
1702
1703impl fidl::Persistable for RegistryCreateObserverResponse {}
1704
1705#[derive(Clone, Debug, Default, PartialEq)]
1706pub struct RegistryWatchDeviceRemovedResponse {
1707    /// The token of the device least-recently removed.
1708    pub token_id: Option<u64>,
1709    #[doc(hidden)]
1710    pub __source_breaking: fidl::marker::SourceBreaking,
1711}
1712
1713impl fidl::Persistable for RegistryWatchDeviceRemovedResponse {}
1714
1715#[derive(Clone, Debug, Default, PartialEq)]
1716pub struct RegistryWatchDevicesAddedResponse {
1717    /// Devices added since `WatchDevicesAdded` was last called. When called
1718    /// for the first time, this method returns all available audio devices
1719    /// (even an empty vector, if no audio devices are present). Subsequent
1720    /// calls will pend until additional devices become available.
1721    pub devices: Option<Vec<Info>>,
1722    #[doc(hidden)]
1723    pub __source_breaking: fidl::marker::SourceBreaking,
1724}
1725
1726impl fidl::Persistable for RegistryWatchDevicesAddedResponse {}
1727
1728/// Parameters specified by a caller when creating a ring buffer.
1729#[derive(Clone, Debug, Default, PartialEq)]
1730pub struct RingBufferOptions {
1731    /// The format (sample format, channelization, frame rate) of the ring
1732    /// buffer to be created.
1733    ///
1734    /// Required.
1735    pub format: Option<fidl_fuchsia_audio__common::Format>,
1736    /// The minimum number of bytes required in the ring buffer. The actual
1737    /// buffer may be larger, as required by the encoding, driver, device or OS.
1738    ///
1739    /// Required.
1740    pub ring_buffer_min_bytes: Option<u32>,
1741    #[doc(hidden)]
1742    pub __source_breaking: fidl::marker::SourceBreaking,
1743}
1744
1745impl fidl::Persistable for RingBufferOptions {}
1746
1747/// Information about the ring buffer or associated audio stream.
1748#[derive(Clone, Debug, Default, PartialEq)]
1749pub struct RingBufferProperties {
1750    /// The number of bits (starting with the most significant) that are valid,
1751    /// within each individual sample. This may be be smaller than the actual
1752    /// sample size, in the case of an input ring buffer fed by an 18-bit ADC
1753    /// for example. Any additional bits of precision should be ignored.
1754    ///
1755    /// Required.
1756    pub valid_bits_per_sample: Option<u8>,
1757    /// The maximum delay until disabled channels become fully operational,
1758    /// after calling `SetActiveChannels`. This is the worst-case duration when
1759    /// reenabling all channels. The value must be non-negative.
1760    ///
1761    /// Required.
1762    pub turn_on_delay: Option<i64>,
1763    #[doc(hidden)]
1764    pub __source_breaking: fidl::marker::SourceBreaking,
1765}
1766
1767impl fidl::Persistable for RingBufferProperties {}
1768
1769#[derive(Clone, Debug, Default, PartialEq)]
1770pub struct RingBufferSetActiveChannelsRequest {
1771    /// The channels to be activated (all others should be deactivated). No
1772    /// bit should be set above the `channel_count` specified in the ring
1773    /// buffer format (e.g. for a four-channel stream, `channel_bitmask`
1774    /// must be in the [0x00, 0x0F] range).
1775    ///
1776    /// Required.
1777    pub channel_bitmask: Option<u64>,
1778    #[doc(hidden)]
1779    pub __source_breaking: fidl::marker::SourceBreaking,
1780}
1781
1782impl fidl::Persistable for RingBufferSetActiveChannelsRequest {}
1783
1784#[derive(Clone, Debug, Default, PartialEq)]
1785pub struct RingBufferStartRequest {
1786    #[doc(hidden)]
1787    pub __source_breaking: fidl::marker::SourceBreaking,
1788}
1789
1790impl fidl::Persistable for RingBufferStartRequest {}
1791
1792#[derive(Clone, Debug, Default, PartialEq)]
1793pub struct RingBufferStopRequest {
1794    #[doc(hidden)]
1795    pub __source_breaking: fidl::marker::SourceBreaking,
1796}
1797
1798impl fidl::Persistable for RingBufferStopRequest {}
1799
1800#[derive(Clone, Debug, Default, PartialEq)]
1801pub struct RingBufferSetActiveChannelsResponse {
1802    /// The CLOCK_MONOTONIC time when the hardware was configured. Note:
1803    /// this does not include the effects of `turn_on_delay` on streams.
1804    ///
1805    /// Required.
1806    pub set_time: Option<i64>,
1807    #[doc(hidden)]
1808    pub __source_breaking: fidl::marker::SourceBreaking,
1809}
1810
1811impl fidl::Persistable for RingBufferSetActiveChannelsResponse {}
1812
1813#[derive(Clone, Debug, Default, PartialEq)]
1814pub struct RingBufferStartResponse {
1815    /// The CLOCK_MONOTONIC time when the stream was started.
1816    ///
1817    /// Required.
1818    pub start_time: Option<i64>,
1819    #[doc(hidden)]
1820    pub __source_breaking: fidl::marker::SourceBreaking,
1821}
1822
1823impl fidl::Persistable for RingBufferStartResponse {}
1824
1825#[derive(Clone, Debug, Default, PartialEq)]
1826pub struct RingBufferStopResponse {
1827    #[doc(hidden)]
1828    pub __source_breaking: fidl::marker::SourceBreaking,
1829}
1830
1831impl fidl::Persistable for RingBufferStopResponse {}
1832
1833#[derive(Clone, Debug, Default, PartialEq)]
1834pub struct RingBufferWatchDelayInfoResponse {
1835    /// Required.
1836    pub delay_info: Option<DelayInfo>,
1837    #[doc(hidden)]
1838    pub __source_breaking: fidl::marker::SourceBreaking,
1839}
1840
1841impl fidl::Persistable for RingBufferWatchDelayInfoResponse {}
1842
1843pub mod control_ordinals {
1844    pub const GET_ELEMENTS: u64 = 0x1b14ff4adf5dc6f8;
1845    pub const WATCH_ELEMENT_STATE: u64 = 0x524da8772a69056f;
1846    pub const GET_TOPOLOGIES: u64 = 0x73ffb73af24d30b6;
1847    pub const WATCH_TOPOLOGY: u64 = 0x66d172acdb36a729;
1848    pub const SET_TOPOLOGY: u64 = 0x1d9a7f9b8fee790c;
1849    pub const SET_ELEMENT_STATE: u64 = 0x38c3b2d4bae698f4;
1850    pub const CREATE_RING_BUFFER: u64 = 0x7462941cedb333db;
1851    pub const SET_DAI_FORMAT: u64 = 0x1d84f5a456a92216;
1852    pub const CODEC_START: u64 = 0x2a90a9d2958b997b;
1853    pub const CODEC_STOP: u64 = 0x387297bb6bcad25f;
1854    pub const RESET: u64 = 0x49840db00a698996;
1855}
1856
1857pub mod control_creator_ordinals {
1858    pub const CREATE: u64 = 0x341bdc9f49103a31;
1859}
1860
1861pub mod observer_ordinals {
1862    pub const GET_ELEMENTS: u64 = 0x1b14ff4adf5dc6f8;
1863    pub const WATCH_ELEMENT_STATE: u64 = 0x524da8772a69056f;
1864    pub const GET_TOPOLOGIES: u64 = 0x73ffb73af24d30b6;
1865    pub const WATCH_TOPOLOGY: u64 = 0x66d172acdb36a729;
1866    pub const WATCH_PLUG_STATE: u64 = 0x6312bce495d2907a;
1867    pub const GET_REFERENCE_CLOCK: u64 = 0x3819c5e0f9574c39;
1868}
1869
1870pub mod provider_ordinals {
1871    pub const ADD_DEVICE: u64 = 0x685fdfd91937758b;
1872}
1873
1874pub mod registry_ordinals {
1875    pub const WATCH_DEVICES_ADDED: u64 = 0x562ca31f7c149def;
1876    pub const WATCH_DEVICE_REMOVED: u64 = 0x6e67aabc99a502af;
1877    pub const CREATE_OBSERVER: u64 = 0x577bc322eb8d2bd1;
1878}
1879
1880pub mod ring_buffer_ordinals {
1881    pub const SET_ACTIVE_CHANNELS: u64 = 0x4276c43e4a3b59ee;
1882    pub const START: u64 = 0x5365a8609dc2dc5;
1883    pub const STOP: u64 = 0x5a238810af11e6e1;
1884    pub const WATCH_DELAY_INFO: u64 = 0x6d1dc5a928f38ad6;
1885}
1886
1887mod internal {
1888    use super::*;
1889    unsafe impl fidl::encoding::TypeMarker for ControlCodecStartError {
1890        type Owned = Self;
1891
1892        #[inline(always)]
1893        fn inline_align(_context: fidl::encoding::Context) -> usize {
1894            std::mem::align_of::<u32>()
1895        }
1896
1897        #[inline(always)]
1898        fn inline_size(_context: fidl::encoding::Context) -> usize {
1899            std::mem::size_of::<u32>()
1900        }
1901
1902        #[inline(always)]
1903        fn encode_is_copy() -> bool {
1904            false
1905        }
1906
1907        #[inline(always)]
1908        fn decode_is_copy() -> bool {
1909            false
1910        }
1911    }
1912
1913    impl fidl::encoding::ValueTypeMarker for ControlCodecStartError {
1914        type Borrowed<'a> = Self;
1915        #[inline(always)]
1916        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1917            *value
1918        }
1919    }
1920
1921    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1922        for ControlCodecStartError
1923    {
1924        #[inline]
1925        unsafe fn encode(
1926            self,
1927            encoder: &mut fidl::encoding::Encoder<'_, D>,
1928            offset: usize,
1929            _depth: fidl::encoding::Depth,
1930        ) -> fidl::Result<()> {
1931            encoder.debug_check_bounds::<Self>(offset);
1932            encoder.write_num(self.into_primitive(), offset);
1933            Ok(())
1934        }
1935    }
1936
1937    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1938        for ControlCodecStartError
1939    {
1940        #[inline(always)]
1941        fn new_empty() -> Self {
1942            Self::unknown()
1943        }
1944
1945        #[inline]
1946        unsafe fn decode(
1947            &mut self,
1948            decoder: &mut fidl::encoding::Decoder<'_, D>,
1949            offset: usize,
1950            _depth: fidl::encoding::Depth,
1951        ) -> fidl::Result<()> {
1952            decoder.debug_check_bounds::<Self>(offset);
1953            let prim = decoder.read_num::<u32>(offset);
1954
1955            *self = Self::from_primitive_allow_unknown(prim);
1956            Ok(())
1957        }
1958    }
1959    unsafe impl fidl::encoding::TypeMarker for ControlCodecStopError {
1960        type Owned = Self;
1961
1962        #[inline(always)]
1963        fn inline_align(_context: fidl::encoding::Context) -> usize {
1964            std::mem::align_of::<u32>()
1965        }
1966
1967        #[inline(always)]
1968        fn inline_size(_context: fidl::encoding::Context) -> usize {
1969            std::mem::size_of::<u32>()
1970        }
1971
1972        #[inline(always)]
1973        fn encode_is_copy() -> bool {
1974            false
1975        }
1976
1977        #[inline(always)]
1978        fn decode_is_copy() -> bool {
1979            false
1980        }
1981    }
1982
1983    impl fidl::encoding::ValueTypeMarker for ControlCodecStopError {
1984        type Borrowed<'a> = Self;
1985        #[inline(always)]
1986        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1987            *value
1988        }
1989    }
1990
1991    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1992        for ControlCodecStopError
1993    {
1994        #[inline]
1995        unsafe fn encode(
1996            self,
1997            encoder: &mut fidl::encoding::Encoder<'_, D>,
1998            offset: usize,
1999            _depth: fidl::encoding::Depth,
2000        ) -> fidl::Result<()> {
2001            encoder.debug_check_bounds::<Self>(offset);
2002            encoder.write_num(self.into_primitive(), offset);
2003            Ok(())
2004        }
2005    }
2006
2007    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlCodecStopError {
2008        #[inline(always)]
2009        fn new_empty() -> Self {
2010            Self::unknown()
2011        }
2012
2013        #[inline]
2014        unsafe fn decode(
2015            &mut self,
2016            decoder: &mut fidl::encoding::Decoder<'_, D>,
2017            offset: usize,
2018            _depth: fidl::encoding::Depth,
2019        ) -> fidl::Result<()> {
2020            decoder.debug_check_bounds::<Self>(offset);
2021            let prim = decoder.read_num::<u32>(offset);
2022
2023            *self = Self::from_primitive_allow_unknown(prim);
2024            Ok(())
2025        }
2026    }
2027    unsafe impl fidl::encoding::TypeMarker for ControlCreateRingBufferError {
2028        type Owned = Self;
2029
2030        #[inline(always)]
2031        fn inline_align(_context: fidl::encoding::Context) -> usize {
2032            std::mem::align_of::<u32>()
2033        }
2034
2035        #[inline(always)]
2036        fn inline_size(_context: fidl::encoding::Context) -> usize {
2037            std::mem::size_of::<u32>()
2038        }
2039
2040        #[inline(always)]
2041        fn encode_is_copy() -> bool {
2042            false
2043        }
2044
2045        #[inline(always)]
2046        fn decode_is_copy() -> bool {
2047            false
2048        }
2049    }
2050
2051    impl fidl::encoding::ValueTypeMarker for ControlCreateRingBufferError {
2052        type Borrowed<'a> = Self;
2053        #[inline(always)]
2054        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2055            *value
2056        }
2057    }
2058
2059    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2060        for ControlCreateRingBufferError
2061    {
2062        #[inline]
2063        unsafe fn encode(
2064            self,
2065            encoder: &mut fidl::encoding::Encoder<'_, D>,
2066            offset: usize,
2067            _depth: fidl::encoding::Depth,
2068        ) -> fidl::Result<()> {
2069            encoder.debug_check_bounds::<Self>(offset);
2070            encoder.write_num(self.into_primitive(), offset);
2071            Ok(())
2072        }
2073    }
2074
2075    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2076        for ControlCreateRingBufferError
2077    {
2078        #[inline(always)]
2079        fn new_empty() -> Self {
2080            Self::unknown()
2081        }
2082
2083        #[inline]
2084        unsafe fn decode(
2085            &mut self,
2086            decoder: &mut fidl::encoding::Decoder<'_, D>,
2087            offset: usize,
2088            _depth: fidl::encoding::Depth,
2089        ) -> fidl::Result<()> {
2090            decoder.debug_check_bounds::<Self>(offset);
2091            let prim = decoder.read_num::<u32>(offset);
2092
2093            *self = Self::from_primitive_allow_unknown(prim);
2094            Ok(())
2095        }
2096    }
2097    unsafe impl fidl::encoding::TypeMarker for ControlCreatorError {
2098        type Owned = Self;
2099
2100        #[inline(always)]
2101        fn inline_align(_context: fidl::encoding::Context) -> usize {
2102            std::mem::align_of::<u32>()
2103        }
2104
2105        #[inline(always)]
2106        fn inline_size(_context: fidl::encoding::Context) -> usize {
2107            std::mem::size_of::<u32>()
2108        }
2109
2110        #[inline(always)]
2111        fn encode_is_copy() -> bool {
2112            false
2113        }
2114
2115        #[inline(always)]
2116        fn decode_is_copy() -> bool {
2117            false
2118        }
2119    }
2120
2121    impl fidl::encoding::ValueTypeMarker for ControlCreatorError {
2122        type Borrowed<'a> = Self;
2123        #[inline(always)]
2124        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2125            *value
2126        }
2127    }
2128
2129    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2130        for ControlCreatorError
2131    {
2132        #[inline]
2133        unsafe fn encode(
2134            self,
2135            encoder: &mut fidl::encoding::Encoder<'_, D>,
2136            offset: usize,
2137            _depth: fidl::encoding::Depth,
2138        ) -> fidl::Result<()> {
2139            encoder.debug_check_bounds::<Self>(offset);
2140            encoder.write_num(self.into_primitive(), offset);
2141            Ok(())
2142        }
2143    }
2144
2145    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlCreatorError {
2146        #[inline(always)]
2147        fn new_empty() -> Self {
2148            Self::unknown()
2149        }
2150
2151        #[inline]
2152        unsafe fn decode(
2153            &mut self,
2154            decoder: &mut fidl::encoding::Decoder<'_, D>,
2155            offset: usize,
2156            _depth: fidl::encoding::Depth,
2157        ) -> fidl::Result<()> {
2158            decoder.debug_check_bounds::<Self>(offset);
2159            let prim = decoder.read_num::<u32>(offset);
2160
2161            *self = Self::from_primitive_allow_unknown(prim);
2162            Ok(())
2163        }
2164    }
2165    unsafe impl fidl::encoding::TypeMarker for ControlResetError {
2166        type Owned = Self;
2167
2168        #[inline(always)]
2169        fn inline_align(_context: fidl::encoding::Context) -> usize {
2170            std::mem::align_of::<u32>()
2171        }
2172
2173        #[inline(always)]
2174        fn inline_size(_context: fidl::encoding::Context) -> usize {
2175            std::mem::size_of::<u32>()
2176        }
2177
2178        #[inline(always)]
2179        fn encode_is_copy() -> bool {
2180            false
2181        }
2182
2183        #[inline(always)]
2184        fn decode_is_copy() -> bool {
2185            false
2186        }
2187    }
2188
2189    impl fidl::encoding::ValueTypeMarker for ControlResetError {
2190        type Borrowed<'a> = Self;
2191        #[inline(always)]
2192        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2193            *value
2194        }
2195    }
2196
2197    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2198        for ControlResetError
2199    {
2200        #[inline]
2201        unsafe fn encode(
2202            self,
2203            encoder: &mut fidl::encoding::Encoder<'_, D>,
2204            offset: usize,
2205            _depth: fidl::encoding::Depth,
2206        ) -> fidl::Result<()> {
2207            encoder.debug_check_bounds::<Self>(offset);
2208            encoder.write_num(self.into_primitive(), offset);
2209            Ok(())
2210        }
2211    }
2212
2213    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlResetError {
2214        #[inline(always)]
2215        fn new_empty() -> Self {
2216            Self::unknown()
2217        }
2218
2219        #[inline]
2220        unsafe fn decode(
2221            &mut self,
2222            decoder: &mut fidl::encoding::Decoder<'_, D>,
2223            offset: usize,
2224            _depth: fidl::encoding::Depth,
2225        ) -> fidl::Result<()> {
2226            decoder.debug_check_bounds::<Self>(offset);
2227            let prim = decoder.read_num::<u32>(offset);
2228
2229            *self = Self::from_primitive_allow_unknown(prim);
2230            Ok(())
2231        }
2232    }
2233    unsafe impl fidl::encoding::TypeMarker for ControlSetDaiFormatError {
2234        type Owned = Self;
2235
2236        #[inline(always)]
2237        fn inline_align(_context: fidl::encoding::Context) -> usize {
2238            std::mem::align_of::<u32>()
2239        }
2240
2241        #[inline(always)]
2242        fn inline_size(_context: fidl::encoding::Context) -> usize {
2243            std::mem::size_of::<u32>()
2244        }
2245
2246        #[inline(always)]
2247        fn encode_is_copy() -> bool {
2248            false
2249        }
2250
2251        #[inline(always)]
2252        fn decode_is_copy() -> bool {
2253            false
2254        }
2255    }
2256
2257    impl fidl::encoding::ValueTypeMarker for ControlSetDaiFormatError {
2258        type Borrowed<'a> = Self;
2259        #[inline(always)]
2260        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2261            *value
2262        }
2263    }
2264
2265    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2266        for ControlSetDaiFormatError
2267    {
2268        #[inline]
2269        unsafe fn encode(
2270            self,
2271            encoder: &mut fidl::encoding::Encoder<'_, D>,
2272            offset: usize,
2273            _depth: fidl::encoding::Depth,
2274        ) -> fidl::Result<()> {
2275            encoder.debug_check_bounds::<Self>(offset);
2276            encoder.write_num(self.into_primitive(), offset);
2277            Ok(())
2278        }
2279    }
2280
2281    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2282        for ControlSetDaiFormatError
2283    {
2284        #[inline(always)]
2285        fn new_empty() -> Self {
2286            Self::unknown()
2287        }
2288
2289        #[inline]
2290        unsafe fn decode(
2291            &mut self,
2292            decoder: &mut fidl::encoding::Decoder<'_, D>,
2293            offset: usize,
2294            _depth: fidl::encoding::Depth,
2295        ) -> fidl::Result<()> {
2296            decoder.debug_check_bounds::<Self>(offset);
2297            let prim = decoder.read_num::<u32>(offset);
2298
2299            *self = Self::from_primitive_allow_unknown(prim);
2300            Ok(())
2301        }
2302    }
2303    unsafe impl fidl::encoding::TypeMarker for DeviceType {
2304        type Owned = Self;
2305
2306        #[inline(always)]
2307        fn inline_align(_context: fidl::encoding::Context) -> usize {
2308            std::mem::align_of::<u32>()
2309        }
2310
2311        #[inline(always)]
2312        fn inline_size(_context: fidl::encoding::Context) -> usize {
2313            std::mem::size_of::<u32>()
2314        }
2315
2316        #[inline(always)]
2317        fn encode_is_copy() -> bool {
2318            false
2319        }
2320
2321        #[inline(always)]
2322        fn decode_is_copy() -> bool {
2323            false
2324        }
2325    }
2326
2327    impl fidl::encoding::ValueTypeMarker for DeviceType {
2328        type Borrowed<'a> = Self;
2329        #[inline(always)]
2330        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2331            *value
2332        }
2333    }
2334
2335    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DeviceType {
2336        #[inline]
2337        unsafe fn encode(
2338            self,
2339            encoder: &mut fidl::encoding::Encoder<'_, D>,
2340            offset: usize,
2341            _depth: fidl::encoding::Depth,
2342        ) -> fidl::Result<()> {
2343            encoder.debug_check_bounds::<Self>(offset);
2344            encoder.write_num(self.into_primitive(), offset);
2345            Ok(())
2346        }
2347    }
2348
2349    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceType {
2350        #[inline(always)]
2351        fn new_empty() -> Self {
2352            Self::unknown()
2353        }
2354
2355        #[inline]
2356        unsafe fn decode(
2357            &mut self,
2358            decoder: &mut fidl::encoding::Decoder<'_, D>,
2359            offset: usize,
2360            _depth: fidl::encoding::Depth,
2361        ) -> fidl::Result<()> {
2362            decoder.debug_check_bounds::<Self>(offset);
2363            let prim = decoder.read_num::<u32>(offset);
2364
2365            *self = Self::from_primitive_allow_unknown(prim);
2366            Ok(())
2367        }
2368    }
2369    unsafe impl fidl::encoding::TypeMarker for ObserverGetReferenceClockError {
2370        type Owned = Self;
2371
2372        #[inline(always)]
2373        fn inline_align(_context: fidl::encoding::Context) -> usize {
2374            std::mem::align_of::<u32>()
2375        }
2376
2377        #[inline(always)]
2378        fn inline_size(_context: fidl::encoding::Context) -> usize {
2379            std::mem::size_of::<u32>()
2380        }
2381
2382        #[inline(always)]
2383        fn encode_is_copy() -> bool {
2384            false
2385        }
2386
2387        #[inline(always)]
2388        fn decode_is_copy() -> bool {
2389            false
2390        }
2391    }
2392
2393    impl fidl::encoding::ValueTypeMarker for ObserverGetReferenceClockError {
2394        type Borrowed<'a> = Self;
2395        #[inline(always)]
2396        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2397            *value
2398        }
2399    }
2400
2401    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2402        for ObserverGetReferenceClockError
2403    {
2404        #[inline]
2405        unsafe fn encode(
2406            self,
2407            encoder: &mut fidl::encoding::Encoder<'_, D>,
2408            offset: usize,
2409            _depth: fidl::encoding::Depth,
2410        ) -> fidl::Result<()> {
2411            encoder.debug_check_bounds::<Self>(offset);
2412            encoder.write_num(self.into_primitive(), offset);
2413            Ok(())
2414        }
2415    }
2416
2417    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2418        for ObserverGetReferenceClockError
2419    {
2420        #[inline(always)]
2421        fn new_empty() -> Self {
2422            Self::unknown()
2423        }
2424
2425        #[inline]
2426        unsafe fn decode(
2427            &mut self,
2428            decoder: &mut fidl::encoding::Decoder<'_, D>,
2429            offset: usize,
2430            _depth: fidl::encoding::Depth,
2431        ) -> fidl::Result<()> {
2432            decoder.debug_check_bounds::<Self>(offset);
2433            let prim = decoder.read_num::<u32>(offset);
2434
2435            *self = Self::from_primitive_allow_unknown(prim);
2436            Ok(())
2437        }
2438    }
2439    unsafe impl fidl::encoding::TypeMarker for ObserverWatchPlugStateError {
2440        type Owned = Self;
2441
2442        #[inline(always)]
2443        fn inline_align(_context: fidl::encoding::Context) -> usize {
2444            std::mem::align_of::<u32>()
2445        }
2446
2447        #[inline(always)]
2448        fn inline_size(_context: fidl::encoding::Context) -> usize {
2449            std::mem::size_of::<u32>()
2450        }
2451
2452        #[inline(always)]
2453        fn encode_is_copy() -> bool {
2454            false
2455        }
2456
2457        #[inline(always)]
2458        fn decode_is_copy() -> bool {
2459            false
2460        }
2461    }
2462
2463    impl fidl::encoding::ValueTypeMarker for ObserverWatchPlugStateError {
2464        type Borrowed<'a> = Self;
2465        #[inline(always)]
2466        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2467            *value
2468        }
2469    }
2470
2471    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2472        for ObserverWatchPlugStateError
2473    {
2474        #[inline]
2475        unsafe fn encode(
2476            self,
2477            encoder: &mut fidl::encoding::Encoder<'_, D>,
2478            offset: usize,
2479            _depth: fidl::encoding::Depth,
2480        ) -> fidl::Result<()> {
2481            encoder.debug_check_bounds::<Self>(offset);
2482            encoder.write_num(self.into_primitive(), offset);
2483            Ok(())
2484        }
2485    }
2486
2487    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2488        for ObserverWatchPlugStateError
2489    {
2490        #[inline(always)]
2491        fn new_empty() -> Self {
2492            Self::unknown()
2493        }
2494
2495        #[inline]
2496        unsafe fn decode(
2497            &mut self,
2498            decoder: &mut fidl::encoding::Decoder<'_, D>,
2499            offset: usize,
2500            _depth: fidl::encoding::Depth,
2501        ) -> fidl::Result<()> {
2502            decoder.debug_check_bounds::<Self>(offset);
2503            let prim = decoder.read_num::<u32>(offset);
2504
2505            *self = Self::from_primitive_allow_unknown(prim);
2506            Ok(())
2507        }
2508    }
2509    unsafe impl fidl::encoding::TypeMarker for PlugDetectCapabilities {
2510        type Owned = Self;
2511
2512        #[inline(always)]
2513        fn inline_align(_context: fidl::encoding::Context) -> usize {
2514            std::mem::align_of::<u32>()
2515        }
2516
2517        #[inline(always)]
2518        fn inline_size(_context: fidl::encoding::Context) -> usize {
2519            std::mem::size_of::<u32>()
2520        }
2521
2522        #[inline(always)]
2523        fn encode_is_copy() -> bool {
2524            false
2525        }
2526
2527        #[inline(always)]
2528        fn decode_is_copy() -> bool {
2529            false
2530        }
2531    }
2532
2533    impl fidl::encoding::ValueTypeMarker for PlugDetectCapabilities {
2534        type Borrowed<'a> = Self;
2535        #[inline(always)]
2536        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2537            *value
2538        }
2539    }
2540
2541    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2542        for PlugDetectCapabilities
2543    {
2544        #[inline]
2545        unsafe fn encode(
2546            self,
2547            encoder: &mut fidl::encoding::Encoder<'_, D>,
2548            offset: usize,
2549            _depth: fidl::encoding::Depth,
2550        ) -> fidl::Result<()> {
2551            encoder.debug_check_bounds::<Self>(offset);
2552            encoder.write_num(self.into_primitive(), offset);
2553            Ok(())
2554        }
2555    }
2556
2557    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2558        for PlugDetectCapabilities
2559    {
2560        #[inline(always)]
2561        fn new_empty() -> Self {
2562            Self::unknown()
2563        }
2564
2565        #[inline]
2566        unsafe fn decode(
2567            &mut self,
2568            decoder: &mut fidl::encoding::Decoder<'_, D>,
2569            offset: usize,
2570            _depth: fidl::encoding::Depth,
2571        ) -> fidl::Result<()> {
2572            decoder.debug_check_bounds::<Self>(offset);
2573            let prim = decoder.read_num::<u32>(offset);
2574
2575            *self = Self::from_primitive_allow_unknown(prim);
2576            Ok(())
2577        }
2578    }
2579    unsafe impl fidl::encoding::TypeMarker for PlugState {
2580        type Owned = Self;
2581
2582        #[inline(always)]
2583        fn inline_align(_context: fidl::encoding::Context) -> usize {
2584            std::mem::align_of::<u32>()
2585        }
2586
2587        #[inline(always)]
2588        fn inline_size(_context: fidl::encoding::Context) -> usize {
2589            std::mem::size_of::<u32>()
2590        }
2591
2592        #[inline(always)]
2593        fn encode_is_copy() -> bool {
2594            false
2595        }
2596
2597        #[inline(always)]
2598        fn decode_is_copy() -> bool {
2599            false
2600        }
2601    }
2602
2603    impl fidl::encoding::ValueTypeMarker for PlugState {
2604        type Borrowed<'a> = Self;
2605        #[inline(always)]
2606        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2607            *value
2608        }
2609    }
2610
2611    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PlugState {
2612        #[inline]
2613        unsafe fn encode(
2614            self,
2615            encoder: &mut fidl::encoding::Encoder<'_, D>,
2616            offset: usize,
2617            _depth: fidl::encoding::Depth,
2618        ) -> fidl::Result<()> {
2619            encoder.debug_check_bounds::<Self>(offset);
2620            encoder.write_num(self.into_primitive(), offset);
2621            Ok(())
2622        }
2623    }
2624
2625    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlugState {
2626        #[inline(always)]
2627        fn new_empty() -> Self {
2628            Self::unknown()
2629        }
2630
2631        #[inline]
2632        unsafe fn decode(
2633            &mut self,
2634            decoder: &mut fidl::encoding::Decoder<'_, D>,
2635            offset: usize,
2636            _depth: fidl::encoding::Depth,
2637        ) -> fidl::Result<()> {
2638            decoder.debug_check_bounds::<Self>(offset);
2639            let prim = decoder.read_num::<u32>(offset);
2640
2641            *self = Self::from_primitive_allow_unknown(prim);
2642            Ok(())
2643        }
2644    }
2645    unsafe impl fidl::encoding::TypeMarker for ProviderAddDeviceError {
2646        type Owned = Self;
2647
2648        #[inline(always)]
2649        fn inline_align(_context: fidl::encoding::Context) -> usize {
2650            std::mem::align_of::<u32>()
2651        }
2652
2653        #[inline(always)]
2654        fn inline_size(_context: fidl::encoding::Context) -> usize {
2655            std::mem::size_of::<u32>()
2656        }
2657
2658        #[inline(always)]
2659        fn encode_is_copy() -> bool {
2660            false
2661        }
2662
2663        #[inline(always)]
2664        fn decode_is_copy() -> bool {
2665            false
2666        }
2667    }
2668
2669    impl fidl::encoding::ValueTypeMarker for ProviderAddDeviceError {
2670        type Borrowed<'a> = Self;
2671        #[inline(always)]
2672        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2673            *value
2674        }
2675    }
2676
2677    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2678        for ProviderAddDeviceError
2679    {
2680        #[inline]
2681        unsafe fn encode(
2682            self,
2683            encoder: &mut fidl::encoding::Encoder<'_, D>,
2684            offset: usize,
2685            _depth: fidl::encoding::Depth,
2686        ) -> fidl::Result<()> {
2687            encoder.debug_check_bounds::<Self>(offset);
2688            encoder.write_num(self.into_primitive(), offset);
2689            Ok(())
2690        }
2691    }
2692
2693    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2694        for ProviderAddDeviceError
2695    {
2696        #[inline(always)]
2697        fn new_empty() -> Self {
2698            Self::unknown()
2699        }
2700
2701        #[inline]
2702        unsafe fn decode(
2703            &mut self,
2704            decoder: &mut fidl::encoding::Decoder<'_, D>,
2705            offset: usize,
2706            _depth: fidl::encoding::Depth,
2707        ) -> fidl::Result<()> {
2708            decoder.debug_check_bounds::<Self>(offset);
2709            let prim = decoder.read_num::<u32>(offset);
2710
2711            *self = Self::from_primitive_allow_unknown(prim);
2712            Ok(())
2713        }
2714    }
2715    unsafe impl fidl::encoding::TypeMarker for RegistryCreateObserverError {
2716        type Owned = Self;
2717
2718        #[inline(always)]
2719        fn inline_align(_context: fidl::encoding::Context) -> usize {
2720            std::mem::align_of::<u32>()
2721        }
2722
2723        #[inline(always)]
2724        fn inline_size(_context: fidl::encoding::Context) -> usize {
2725            std::mem::size_of::<u32>()
2726        }
2727
2728        #[inline(always)]
2729        fn encode_is_copy() -> bool {
2730            false
2731        }
2732
2733        #[inline(always)]
2734        fn decode_is_copy() -> bool {
2735            false
2736        }
2737    }
2738
2739    impl fidl::encoding::ValueTypeMarker for RegistryCreateObserverError {
2740        type Borrowed<'a> = Self;
2741        #[inline(always)]
2742        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2743            *value
2744        }
2745    }
2746
2747    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2748        for RegistryCreateObserverError
2749    {
2750        #[inline]
2751        unsafe fn encode(
2752            self,
2753            encoder: &mut fidl::encoding::Encoder<'_, D>,
2754            offset: usize,
2755            _depth: fidl::encoding::Depth,
2756        ) -> fidl::Result<()> {
2757            encoder.debug_check_bounds::<Self>(offset);
2758            encoder.write_num(self.into_primitive(), offset);
2759            Ok(())
2760        }
2761    }
2762
2763    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2764        for RegistryCreateObserverError
2765    {
2766        #[inline(always)]
2767        fn new_empty() -> Self {
2768            Self::unknown()
2769        }
2770
2771        #[inline]
2772        unsafe fn decode(
2773            &mut self,
2774            decoder: &mut fidl::encoding::Decoder<'_, D>,
2775            offset: usize,
2776            _depth: fidl::encoding::Depth,
2777        ) -> fidl::Result<()> {
2778            decoder.debug_check_bounds::<Self>(offset);
2779            let prim = decoder.read_num::<u32>(offset);
2780
2781            *self = Self::from_primitive_allow_unknown(prim);
2782            Ok(())
2783        }
2784    }
2785    unsafe impl fidl::encoding::TypeMarker for RegistryWatchDeviceRemovedError {
2786        type Owned = Self;
2787
2788        #[inline(always)]
2789        fn inline_align(_context: fidl::encoding::Context) -> usize {
2790            std::mem::align_of::<u32>()
2791        }
2792
2793        #[inline(always)]
2794        fn inline_size(_context: fidl::encoding::Context) -> usize {
2795            std::mem::size_of::<u32>()
2796        }
2797
2798        #[inline(always)]
2799        fn encode_is_copy() -> bool {
2800            false
2801        }
2802
2803        #[inline(always)]
2804        fn decode_is_copy() -> bool {
2805            false
2806        }
2807    }
2808
2809    impl fidl::encoding::ValueTypeMarker for RegistryWatchDeviceRemovedError {
2810        type Borrowed<'a> = Self;
2811        #[inline(always)]
2812        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2813            *value
2814        }
2815    }
2816
2817    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2818        for RegistryWatchDeviceRemovedError
2819    {
2820        #[inline]
2821        unsafe fn encode(
2822            self,
2823            encoder: &mut fidl::encoding::Encoder<'_, D>,
2824            offset: usize,
2825            _depth: fidl::encoding::Depth,
2826        ) -> fidl::Result<()> {
2827            encoder.debug_check_bounds::<Self>(offset);
2828            encoder.write_num(self.into_primitive(), offset);
2829            Ok(())
2830        }
2831    }
2832
2833    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2834        for RegistryWatchDeviceRemovedError
2835    {
2836        #[inline(always)]
2837        fn new_empty() -> Self {
2838            Self::unknown()
2839        }
2840
2841        #[inline]
2842        unsafe fn decode(
2843            &mut self,
2844            decoder: &mut fidl::encoding::Decoder<'_, D>,
2845            offset: usize,
2846            _depth: fidl::encoding::Depth,
2847        ) -> fidl::Result<()> {
2848            decoder.debug_check_bounds::<Self>(offset);
2849            let prim = decoder.read_num::<u32>(offset);
2850
2851            *self = Self::from_primitive_allow_unknown(prim);
2852            Ok(())
2853        }
2854    }
2855    unsafe impl fidl::encoding::TypeMarker for RegistryWatchDevicesAddedError {
2856        type Owned = Self;
2857
2858        #[inline(always)]
2859        fn inline_align(_context: fidl::encoding::Context) -> usize {
2860            std::mem::align_of::<u32>()
2861        }
2862
2863        #[inline(always)]
2864        fn inline_size(_context: fidl::encoding::Context) -> usize {
2865            std::mem::size_of::<u32>()
2866        }
2867
2868        #[inline(always)]
2869        fn encode_is_copy() -> bool {
2870            false
2871        }
2872
2873        #[inline(always)]
2874        fn decode_is_copy() -> bool {
2875            false
2876        }
2877    }
2878
2879    impl fidl::encoding::ValueTypeMarker for RegistryWatchDevicesAddedError {
2880        type Borrowed<'a> = Self;
2881        #[inline(always)]
2882        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2883            *value
2884        }
2885    }
2886
2887    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2888        for RegistryWatchDevicesAddedError
2889    {
2890        #[inline]
2891        unsafe fn encode(
2892            self,
2893            encoder: &mut fidl::encoding::Encoder<'_, D>,
2894            offset: usize,
2895            _depth: fidl::encoding::Depth,
2896        ) -> fidl::Result<()> {
2897            encoder.debug_check_bounds::<Self>(offset);
2898            encoder.write_num(self.into_primitive(), offset);
2899            Ok(())
2900        }
2901    }
2902
2903    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2904        for RegistryWatchDevicesAddedError
2905    {
2906        #[inline(always)]
2907        fn new_empty() -> Self {
2908            Self::unknown()
2909        }
2910
2911        #[inline]
2912        unsafe fn decode(
2913            &mut self,
2914            decoder: &mut fidl::encoding::Decoder<'_, D>,
2915            offset: usize,
2916            _depth: fidl::encoding::Depth,
2917        ) -> fidl::Result<()> {
2918            decoder.debug_check_bounds::<Self>(offset);
2919            let prim = decoder.read_num::<u32>(offset);
2920
2921            *self = Self::from_primitive_allow_unknown(prim);
2922            Ok(())
2923        }
2924    }
2925    unsafe impl fidl::encoding::TypeMarker for RingBufferSetActiveChannelsError {
2926        type Owned = Self;
2927
2928        #[inline(always)]
2929        fn inline_align(_context: fidl::encoding::Context) -> usize {
2930            std::mem::align_of::<u32>()
2931        }
2932
2933        #[inline(always)]
2934        fn inline_size(_context: fidl::encoding::Context) -> usize {
2935            std::mem::size_of::<u32>()
2936        }
2937
2938        #[inline(always)]
2939        fn encode_is_copy() -> bool {
2940            false
2941        }
2942
2943        #[inline(always)]
2944        fn decode_is_copy() -> bool {
2945            false
2946        }
2947    }
2948
2949    impl fidl::encoding::ValueTypeMarker for RingBufferSetActiveChannelsError {
2950        type Borrowed<'a> = Self;
2951        #[inline(always)]
2952        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2953            *value
2954        }
2955    }
2956
2957    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2958        for RingBufferSetActiveChannelsError
2959    {
2960        #[inline]
2961        unsafe fn encode(
2962            self,
2963            encoder: &mut fidl::encoding::Encoder<'_, D>,
2964            offset: usize,
2965            _depth: fidl::encoding::Depth,
2966        ) -> fidl::Result<()> {
2967            encoder.debug_check_bounds::<Self>(offset);
2968            encoder.write_num(self.into_primitive(), offset);
2969            Ok(())
2970        }
2971    }
2972
2973    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2974        for RingBufferSetActiveChannelsError
2975    {
2976        #[inline(always)]
2977        fn new_empty() -> Self {
2978            Self::unknown()
2979        }
2980
2981        #[inline]
2982        unsafe fn decode(
2983            &mut self,
2984            decoder: &mut fidl::encoding::Decoder<'_, D>,
2985            offset: usize,
2986            _depth: fidl::encoding::Depth,
2987        ) -> fidl::Result<()> {
2988            decoder.debug_check_bounds::<Self>(offset);
2989            let prim = decoder.read_num::<u32>(offset);
2990
2991            *self = Self::from_primitive_allow_unknown(prim);
2992            Ok(())
2993        }
2994    }
2995    unsafe impl fidl::encoding::TypeMarker for RingBufferStartError {
2996        type Owned = Self;
2997
2998        #[inline(always)]
2999        fn inline_align(_context: fidl::encoding::Context) -> usize {
3000            std::mem::align_of::<u32>()
3001        }
3002
3003        #[inline(always)]
3004        fn inline_size(_context: fidl::encoding::Context) -> usize {
3005            std::mem::size_of::<u32>()
3006        }
3007
3008        #[inline(always)]
3009        fn encode_is_copy() -> bool {
3010            false
3011        }
3012
3013        #[inline(always)]
3014        fn decode_is_copy() -> bool {
3015            false
3016        }
3017    }
3018
3019    impl fidl::encoding::ValueTypeMarker for RingBufferStartError {
3020        type Borrowed<'a> = Self;
3021        #[inline(always)]
3022        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3023            *value
3024        }
3025    }
3026
3027    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3028        for RingBufferStartError
3029    {
3030        #[inline]
3031        unsafe fn encode(
3032            self,
3033            encoder: &mut fidl::encoding::Encoder<'_, D>,
3034            offset: usize,
3035            _depth: fidl::encoding::Depth,
3036        ) -> fidl::Result<()> {
3037            encoder.debug_check_bounds::<Self>(offset);
3038            encoder.write_num(self.into_primitive(), offset);
3039            Ok(())
3040        }
3041    }
3042
3043    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferStartError {
3044        #[inline(always)]
3045        fn new_empty() -> Self {
3046            Self::unknown()
3047        }
3048
3049        #[inline]
3050        unsafe fn decode(
3051            &mut self,
3052            decoder: &mut fidl::encoding::Decoder<'_, D>,
3053            offset: usize,
3054            _depth: fidl::encoding::Depth,
3055        ) -> fidl::Result<()> {
3056            decoder.debug_check_bounds::<Self>(offset);
3057            let prim = decoder.read_num::<u32>(offset);
3058
3059            *self = Self::from_primitive_allow_unknown(prim);
3060            Ok(())
3061        }
3062    }
3063    unsafe impl fidl::encoding::TypeMarker for RingBufferStopError {
3064        type Owned = Self;
3065
3066        #[inline(always)]
3067        fn inline_align(_context: fidl::encoding::Context) -> usize {
3068            std::mem::align_of::<u32>()
3069        }
3070
3071        #[inline(always)]
3072        fn inline_size(_context: fidl::encoding::Context) -> usize {
3073            std::mem::size_of::<u32>()
3074        }
3075
3076        #[inline(always)]
3077        fn encode_is_copy() -> bool {
3078            false
3079        }
3080
3081        #[inline(always)]
3082        fn decode_is_copy() -> bool {
3083            false
3084        }
3085    }
3086
3087    impl fidl::encoding::ValueTypeMarker for RingBufferStopError {
3088        type Borrowed<'a> = Self;
3089        #[inline(always)]
3090        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3091            *value
3092        }
3093    }
3094
3095    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3096        for RingBufferStopError
3097    {
3098        #[inline]
3099        unsafe fn encode(
3100            self,
3101            encoder: &mut fidl::encoding::Encoder<'_, D>,
3102            offset: usize,
3103            _depth: fidl::encoding::Depth,
3104        ) -> fidl::Result<()> {
3105            encoder.debug_check_bounds::<Self>(offset);
3106            encoder.write_num(self.into_primitive(), offset);
3107            Ok(())
3108        }
3109    }
3110
3111    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferStopError {
3112        #[inline(always)]
3113        fn new_empty() -> Self {
3114            Self::unknown()
3115        }
3116
3117        #[inline]
3118        unsafe fn decode(
3119            &mut self,
3120            decoder: &mut fidl::encoding::Decoder<'_, D>,
3121            offset: usize,
3122            _depth: fidl::encoding::Depth,
3123        ) -> fidl::Result<()> {
3124            decoder.debug_check_bounds::<Self>(offset);
3125            let prim = decoder.read_num::<u32>(offset);
3126
3127            *self = Self::from_primitive_allow_unknown(prim);
3128            Ok(())
3129        }
3130    }
3131    unsafe impl fidl::encoding::TypeMarker for RingBufferWatchDelayInfoError {
3132        type Owned = Self;
3133
3134        #[inline(always)]
3135        fn inline_align(_context: fidl::encoding::Context) -> usize {
3136            std::mem::align_of::<u32>()
3137        }
3138
3139        #[inline(always)]
3140        fn inline_size(_context: fidl::encoding::Context) -> usize {
3141            std::mem::size_of::<u32>()
3142        }
3143
3144        #[inline(always)]
3145        fn encode_is_copy() -> bool {
3146            false
3147        }
3148
3149        #[inline(always)]
3150        fn decode_is_copy() -> bool {
3151            false
3152        }
3153    }
3154
3155    impl fidl::encoding::ValueTypeMarker for RingBufferWatchDelayInfoError {
3156        type Borrowed<'a> = Self;
3157        #[inline(always)]
3158        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3159            *value
3160        }
3161    }
3162
3163    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3164        for RingBufferWatchDelayInfoError
3165    {
3166        #[inline]
3167        unsafe fn encode(
3168            self,
3169            encoder: &mut fidl::encoding::Encoder<'_, D>,
3170            offset: usize,
3171            _depth: fidl::encoding::Depth,
3172        ) -> fidl::Result<()> {
3173            encoder.debug_check_bounds::<Self>(offset);
3174            encoder.write_num(self.into_primitive(), offset);
3175            Ok(())
3176        }
3177    }
3178
3179    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3180        for RingBufferWatchDelayInfoError
3181    {
3182        #[inline(always)]
3183        fn new_empty() -> Self {
3184            Self::unknown()
3185        }
3186
3187        #[inline]
3188        unsafe fn decode(
3189            &mut self,
3190            decoder: &mut fidl::encoding::Decoder<'_, D>,
3191            offset: usize,
3192            _depth: fidl::encoding::Depth,
3193        ) -> fidl::Result<()> {
3194            decoder.debug_check_bounds::<Self>(offset);
3195            let prim = decoder.read_num::<u32>(offset);
3196
3197            *self = Self::from_primitive_allow_unknown(prim);
3198            Ok(())
3199        }
3200    }
3201
3202    impl ChannelAttributes {
3203        #[inline(always)]
3204        fn max_ordinal_present(&self) -> u64 {
3205            if let Some(_) = self.max_frequency {
3206                return 2;
3207            }
3208            if let Some(_) = self.min_frequency {
3209                return 1;
3210            }
3211            0
3212        }
3213    }
3214
3215    impl fidl::encoding::ValueTypeMarker for ChannelAttributes {
3216        type Borrowed<'a> = &'a Self;
3217        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3218            value
3219        }
3220    }
3221
3222    unsafe impl fidl::encoding::TypeMarker for ChannelAttributes {
3223        type Owned = Self;
3224
3225        #[inline(always)]
3226        fn inline_align(_context: fidl::encoding::Context) -> usize {
3227            8
3228        }
3229
3230        #[inline(always)]
3231        fn inline_size(_context: fidl::encoding::Context) -> usize {
3232            16
3233        }
3234    }
3235
3236    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChannelAttributes, D>
3237        for &ChannelAttributes
3238    {
3239        unsafe fn encode(
3240            self,
3241            encoder: &mut fidl::encoding::Encoder<'_, D>,
3242            offset: usize,
3243            mut depth: fidl::encoding::Depth,
3244        ) -> fidl::Result<()> {
3245            encoder.debug_check_bounds::<ChannelAttributes>(offset);
3246            // Vector header
3247            let max_ordinal: u64 = self.max_ordinal_present();
3248            encoder.write_num(max_ordinal, offset);
3249            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3250            // Calling encoder.out_of_line_offset(0) is not allowed.
3251            if max_ordinal == 0 {
3252                return Ok(());
3253            }
3254            depth.increment()?;
3255            let envelope_size = 8;
3256            let bytes_len = max_ordinal as usize * envelope_size;
3257            #[allow(unused_variables)]
3258            let offset = encoder.out_of_line_offset(bytes_len);
3259            let mut _prev_end_offset: usize = 0;
3260            if 1 > max_ordinal {
3261                return Ok(());
3262            }
3263
3264            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3265            // are envelope_size bytes.
3266            let cur_offset: usize = (1 - 1) * envelope_size;
3267
3268            // Zero reserved fields.
3269            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3270
3271            // Safety:
3272            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3273            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3274            //   envelope_size bytes, there is always sufficient room.
3275            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3276                self.min_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3277                encoder,
3278                offset + cur_offset,
3279                depth,
3280            )?;
3281
3282            _prev_end_offset = cur_offset + envelope_size;
3283            if 2 > max_ordinal {
3284                return Ok(());
3285            }
3286
3287            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3288            // are envelope_size bytes.
3289            let cur_offset: usize = (2 - 1) * envelope_size;
3290
3291            // Zero reserved fields.
3292            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3293
3294            // Safety:
3295            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3296            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3297            //   envelope_size bytes, there is always sufficient room.
3298            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3299                self.max_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3300                encoder,
3301                offset + cur_offset,
3302                depth,
3303            )?;
3304
3305            _prev_end_offset = cur_offset + envelope_size;
3306
3307            Ok(())
3308        }
3309    }
3310
3311    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChannelAttributes {
3312        #[inline(always)]
3313        fn new_empty() -> Self {
3314            Self::default()
3315        }
3316
3317        unsafe fn decode(
3318            &mut self,
3319            decoder: &mut fidl::encoding::Decoder<'_, D>,
3320            offset: usize,
3321            mut depth: fidl::encoding::Depth,
3322        ) -> fidl::Result<()> {
3323            decoder.debug_check_bounds::<Self>(offset);
3324            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3325                None => return Err(fidl::Error::NotNullable),
3326                Some(len) => len,
3327            };
3328            // Calling decoder.out_of_line_offset(0) is not allowed.
3329            if len == 0 {
3330                return Ok(());
3331            };
3332            depth.increment()?;
3333            let envelope_size = 8;
3334            let bytes_len = len * envelope_size;
3335            let offset = decoder.out_of_line_offset(bytes_len)?;
3336            // Decode the envelope for each type.
3337            let mut _next_ordinal_to_read = 0;
3338            let mut next_offset = offset;
3339            let end_offset = offset + bytes_len;
3340            _next_ordinal_to_read += 1;
3341            if next_offset >= end_offset {
3342                return Ok(());
3343            }
3344
3345            // Decode unknown envelopes for gaps in ordinals.
3346            while _next_ordinal_to_read < 1 {
3347                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3348                _next_ordinal_to_read += 1;
3349                next_offset += envelope_size;
3350            }
3351
3352            let next_out_of_line = decoder.next_out_of_line();
3353            let handles_before = decoder.remaining_handles();
3354            if let Some((inlined, num_bytes, num_handles)) =
3355                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3356            {
3357                let member_inline_size =
3358                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3359                if inlined != (member_inline_size <= 4) {
3360                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3361                }
3362                let inner_offset;
3363                let mut inner_depth = depth.clone();
3364                if inlined {
3365                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3366                    inner_offset = next_offset;
3367                } else {
3368                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3369                    inner_depth.increment()?;
3370                }
3371                let val_ref = self.min_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
3372                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3373                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3374                {
3375                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3376                }
3377                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3378                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3379                }
3380            }
3381
3382            next_offset += envelope_size;
3383            _next_ordinal_to_read += 1;
3384            if next_offset >= end_offset {
3385                return Ok(());
3386            }
3387
3388            // Decode unknown envelopes for gaps in ordinals.
3389            while _next_ordinal_to_read < 2 {
3390                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3391                _next_ordinal_to_read += 1;
3392                next_offset += envelope_size;
3393            }
3394
3395            let next_out_of_line = decoder.next_out_of_line();
3396            let handles_before = decoder.remaining_handles();
3397            if let Some((inlined, num_bytes, num_handles)) =
3398                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3399            {
3400                let member_inline_size =
3401                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3402                if inlined != (member_inline_size <= 4) {
3403                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3404                }
3405                let inner_offset;
3406                let mut inner_depth = depth.clone();
3407                if inlined {
3408                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3409                    inner_offset = next_offset;
3410                } else {
3411                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3412                    inner_depth.increment()?;
3413                }
3414                let val_ref = self.max_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
3415                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3416                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3417                {
3418                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3419                }
3420                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3421                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3422                }
3423            }
3424
3425            next_offset += envelope_size;
3426
3427            // Decode the remaining unknown envelopes.
3428            while next_offset < end_offset {
3429                _next_ordinal_to_read += 1;
3430                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3431                next_offset += envelope_size;
3432            }
3433
3434            Ok(())
3435        }
3436    }
3437
3438    impl ChannelSet {
3439        #[inline(always)]
3440        fn max_ordinal_present(&self) -> u64 {
3441            if let Some(_) = self.attributes {
3442                return 1;
3443            }
3444            0
3445        }
3446    }
3447
3448    impl fidl::encoding::ValueTypeMarker for ChannelSet {
3449        type Borrowed<'a> = &'a Self;
3450        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3451            value
3452        }
3453    }
3454
3455    unsafe impl fidl::encoding::TypeMarker for ChannelSet {
3456        type Owned = Self;
3457
3458        #[inline(always)]
3459        fn inline_align(_context: fidl::encoding::Context) -> usize {
3460            8
3461        }
3462
3463        #[inline(always)]
3464        fn inline_size(_context: fidl::encoding::Context) -> usize {
3465            16
3466        }
3467    }
3468
3469    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChannelSet, D>
3470        for &ChannelSet
3471    {
3472        unsafe fn encode(
3473            self,
3474            encoder: &mut fidl::encoding::Encoder<'_, D>,
3475            offset: usize,
3476            mut depth: fidl::encoding::Depth,
3477        ) -> fidl::Result<()> {
3478            encoder.debug_check_bounds::<ChannelSet>(offset);
3479            // Vector header
3480            let max_ordinal: u64 = self.max_ordinal_present();
3481            encoder.write_num(max_ordinal, offset);
3482            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3483            // Calling encoder.out_of_line_offset(0) is not allowed.
3484            if max_ordinal == 0 {
3485                return Ok(());
3486            }
3487            depth.increment()?;
3488            let envelope_size = 8;
3489            let bytes_len = max_ordinal as usize * envelope_size;
3490            #[allow(unused_variables)]
3491            let offset = encoder.out_of_line_offset(bytes_len);
3492            let mut _prev_end_offset: usize = 0;
3493            if 1 > max_ordinal {
3494                return Ok(());
3495            }
3496
3497            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3498            // are envelope_size bytes.
3499            let cur_offset: usize = (1 - 1) * envelope_size;
3500
3501            // Zero reserved fields.
3502            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3503
3504            // Safety:
3505            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3506            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3507            //   envelope_size bytes, there is always sufficient room.
3508            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ChannelAttributes, 64>, D>(
3509            self.attributes.as_ref().map(<fidl::encoding::Vector<ChannelAttributes, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3510            encoder, offset + cur_offset, depth
3511        )?;
3512
3513            _prev_end_offset = cur_offset + envelope_size;
3514
3515            Ok(())
3516        }
3517    }
3518
3519    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChannelSet {
3520        #[inline(always)]
3521        fn new_empty() -> Self {
3522            Self::default()
3523        }
3524
3525        unsafe fn decode(
3526            &mut self,
3527            decoder: &mut fidl::encoding::Decoder<'_, D>,
3528            offset: usize,
3529            mut depth: fidl::encoding::Depth,
3530        ) -> fidl::Result<()> {
3531            decoder.debug_check_bounds::<Self>(offset);
3532            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3533                None => return Err(fidl::Error::NotNullable),
3534                Some(len) => len,
3535            };
3536            // Calling decoder.out_of_line_offset(0) is not allowed.
3537            if len == 0 {
3538                return Ok(());
3539            };
3540            depth.increment()?;
3541            let envelope_size = 8;
3542            let bytes_len = len * envelope_size;
3543            let offset = decoder.out_of_line_offset(bytes_len)?;
3544            // Decode the envelope for each type.
3545            let mut _next_ordinal_to_read = 0;
3546            let mut next_offset = offset;
3547            let end_offset = offset + bytes_len;
3548            _next_ordinal_to_read += 1;
3549            if next_offset >= end_offset {
3550                return Ok(());
3551            }
3552
3553            // Decode unknown envelopes for gaps in ordinals.
3554            while _next_ordinal_to_read < 1 {
3555                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3556                _next_ordinal_to_read += 1;
3557                next_offset += envelope_size;
3558            }
3559
3560            let next_out_of_line = decoder.next_out_of_line();
3561            let handles_before = decoder.remaining_handles();
3562            if let Some((inlined, num_bytes, num_handles)) =
3563                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3564            {
3565                let member_inline_size = <fidl::encoding::Vector<ChannelAttributes, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3566                if inlined != (member_inline_size <= 4) {
3567                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3568                }
3569                let inner_offset;
3570                let mut inner_depth = depth.clone();
3571                if inlined {
3572                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3573                    inner_offset = next_offset;
3574                } else {
3575                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3576                    inner_depth.increment()?;
3577                }
3578                let val_ref = self.attributes.get_or_insert_with(
3579                    || fidl::new_empty!(fidl::encoding::Vector<ChannelAttributes, 64>, D),
3580                );
3581                fidl::decode!(fidl::encoding::Vector<ChannelAttributes, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3582                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3583                {
3584                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3585                }
3586                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3587                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3588                }
3589            }
3590
3591            next_offset += envelope_size;
3592
3593            // Decode the remaining unknown envelopes.
3594            while next_offset < end_offset {
3595                _next_ordinal_to_read += 1;
3596                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3597                next_offset += envelope_size;
3598            }
3599
3600            Ok(())
3601        }
3602    }
3603
3604    impl ControlCreatorCreateResponse {
3605        #[inline(always)]
3606        fn max_ordinal_present(&self) -> u64 {
3607            0
3608        }
3609    }
3610
3611    impl fidl::encoding::ValueTypeMarker for ControlCreatorCreateResponse {
3612        type Borrowed<'a> = &'a Self;
3613        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3614            value
3615        }
3616    }
3617
3618    unsafe impl fidl::encoding::TypeMarker for ControlCreatorCreateResponse {
3619        type Owned = Self;
3620
3621        #[inline(always)]
3622        fn inline_align(_context: fidl::encoding::Context) -> usize {
3623            8
3624        }
3625
3626        #[inline(always)]
3627        fn inline_size(_context: fidl::encoding::Context) -> usize {
3628            16
3629        }
3630    }
3631
3632    unsafe impl<D: fidl::encoding::ResourceDialect>
3633        fidl::encoding::Encode<ControlCreatorCreateResponse, D> for &ControlCreatorCreateResponse
3634    {
3635        unsafe fn encode(
3636            self,
3637            encoder: &mut fidl::encoding::Encoder<'_, D>,
3638            offset: usize,
3639            mut depth: fidl::encoding::Depth,
3640        ) -> fidl::Result<()> {
3641            encoder.debug_check_bounds::<ControlCreatorCreateResponse>(offset);
3642            // Vector header
3643            let max_ordinal: u64 = self.max_ordinal_present();
3644            encoder.write_num(max_ordinal, offset);
3645            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3646            // Calling encoder.out_of_line_offset(0) is not allowed.
3647            if max_ordinal == 0 {
3648                return Ok(());
3649            }
3650            depth.increment()?;
3651            let envelope_size = 8;
3652            let bytes_len = max_ordinal as usize * envelope_size;
3653            #[allow(unused_variables)]
3654            let offset = encoder.out_of_line_offset(bytes_len);
3655            let mut _prev_end_offset: usize = 0;
3656
3657            Ok(())
3658        }
3659    }
3660
3661    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3662        for ControlCreatorCreateResponse
3663    {
3664        #[inline(always)]
3665        fn new_empty() -> Self {
3666            Self::default()
3667        }
3668
3669        unsafe fn decode(
3670            &mut self,
3671            decoder: &mut fidl::encoding::Decoder<'_, D>,
3672            offset: usize,
3673            mut depth: fidl::encoding::Depth,
3674        ) -> fidl::Result<()> {
3675            decoder.debug_check_bounds::<Self>(offset);
3676            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3677                None => return Err(fidl::Error::NotNullable),
3678                Some(len) => len,
3679            };
3680            // Calling decoder.out_of_line_offset(0) is not allowed.
3681            if len == 0 {
3682                return Ok(());
3683            };
3684            depth.increment()?;
3685            let envelope_size = 8;
3686            let bytes_len = len * envelope_size;
3687            let offset = decoder.out_of_line_offset(bytes_len)?;
3688            // Decode the envelope for each type.
3689            let mut _next_ordinal_to_read = 0;
3690            let mut next_offset = offset;
3691            let end_offset = offset + bytes_len;
3692
3693            // Decode the remaining unknown envelopes.
3694            while next_offset < end_offset {
3695                _next_ordinal_to_read += 1;
3696                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3697                next_offset += envelope_size;
3698            }
3699
3700            Ok(())
3701        }
3702    }
3703
3704    impl ControlSetDaiFormatRequest {
3705        #[inline(always)]
3706        fn max_ordinal_present(&self) -> u64 {
3707            if let Some(_) = self.dai_format {
3708                return 2;
3709            }
3710            if let Some(_) = self.element_id {
3711                return 1;
3712            }
3713            0
3714        }
3715    }
3716
3717    impl fidl::encoding::ValueTypeMarker for ControlSetDaiFormatRequest {
3718        type Borrowed<'a> = &'a Self;
3719        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3720            value
3721        }
3722    }
3723
3724    unsafe impl fidl::encoding::TypeMarker for ControlSetDaiFormatRequest {
3725        type Owned = Self;
3726
3727        #[inline(always)]
3728        fn inline_align(_context: fidl::encoding::Context) -> usize {
3729            8
3730        }
3731
3732        #[inline(always)]
3733        fn inline_size(_context: fidl::encoding::Context) -> usize {
3734            16
3735        }
3736    }
3737
3738    unsafe impl<D: fidl::encoding::ResourceDialect>
3739        fidl::encoding::Encode<ControlSetDaiFormatRequest, D> for &ControlSetDaiFormatRequest
3740    {
3741        unsafe fn encode(
3742            self,
3743            encoder: &mut fidl::encoding::Encoder<'_, D>,
3744            offset: usize,
3745            mut depth: fidl::encoding::Depth,
3746        ) -> fidl::Result<()> {
3747            encoder.debug_check_bounds::<ControlSetDaiFormatRequest>(offset);
3748            // Vector header
3749            let max_ordinal: u64 = self.max_ordinal_present();
3750            encoder.write_num(max_ordinal, offset);
3751            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3752            // Calling encoder.out_of_line_offset(0) is not allowed.
3753            if max_ordinal == 0 {
3754                return Ok(());
3755            }
3756            depth.increment()?;
3757            let envelope_size = 8;
3758            let bytes_len = max_ordinal as usize * envelope_size;
3759            #[allow(unused_variables)]
3760            let offset = encoder.out_of_line_offset(bytes_len);
3761            let mut _prev_end_offset: usize = 0;
3762            if 1 > max_ordinal {
3763                return Ok(());
3764            }
3765
3766            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3767            // are envelope_size bytes.
3768            let cur_offset: usize = (1 - 1) * envelope_size;
3769
3770            // Zero reserved fields.
3771            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3772
3773            // Safety:
3774            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3775            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3776            //   envelope_size bytes, there is always sufficient room.
3777            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3778                self.element_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3779                encoder,
3780                offset + cur_offset,
3781                depth,
3782            )?;
3783
3784            _prev_end_offset = cur_offset + envelope_size;
3785            if 2 > max_ordinal {
3786                return Ok(());
3787            }
3788
3789            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3790            // are envelope_size bytes.
3791            let cur_offset: usize = (2 - 1) * envelope_size;
3792
3793            // Zero reserved fields.
3794            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3795
3796            // Safety:
3797            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3798            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3799            //   envelope_size bytes, there is always sufficient room.
3800            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_audio__common::DaiFormat, D>(
3801            self.dai_format.as_ref().map(<fidl_fuchsia_hardware_audio__common::DaiFormat as fidl::encoding::ValueTypeMarker>::borrow),
3802            encoder, offset + cur_offset, depth
3803        )?;
3804
3805            _prev_end_offset = cur_offset + envelope_size;
3806
3807            Ok(())
3808        }
3809    }
3810
3811    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3812        for ControlSetDaiFormatRequest
3813    {
3814        #[inline(always)]
3815        fn new_empty() -> Self {
3816            Self::default()
3817        }
3818
3819        unsafe fn decode(
3820            &mut self,
3821            decoder: &mut fidl::encoding::Decoder<'_, D>,
3822            offset: usize,
3823            mut depth: fidl::encoding::Depth,
3824        ) -> fidl::Result<()> {
3825            decoder.debug_check_bounds::<Self>(offset);
3826            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3827                None => return Err(fidl::Error::NotNullable),
3828                Some(len) => len,
3829            };
3830            // Calling decoder.out_of_line_offset(0) is not allowed.
3831            if len == 0 {
3832                return Ok(());
3833            };
3834            depth.increment()?;
3835            let envelope_size = 8;
3836            let bytes_len = len * envelope_size;
3837            let offset = decoder.out_of_line_offset(bytes_len)?;
3838            // Decode the envelope for each type.
3839            let mut _next_ordinal_to_read = 0;
3840            let mut next_offset = offset;
3841            let end_offset = offset + bytes_len;
3842            _next_ordinal_to_read += 1;
3843            if next_offset >= end_offset {
3844                return Ok(());
3845            }
3846
3847            // Decode unknown envelopes for gaps in ordinals.
3848            while _next_ordinal_to_read < 1 {
3849                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3850                _next_ordinal_to_read += 1;
3851                next_offset += envelope_size;
3852            }
3853
3854            let next_out_of_line = decoder.next_out_of_line();
3855            let handles_before = decoder.remaining_handles();
3856            if let Some((inlined, num_bytes, num_handles)) =
3857                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3858            {
3859                let member_inline_size =
3860                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3861                if inlined != (member_inline_size <= 4) {
3862                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3863                }
3864                let inner_offset;
3865                let mut inner_depth = depth.clone();
3866                if inlined {
3867                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3868                    inner_offset = next_offset;
3869                } else {
3870                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3871                    inner_depth.increment()?;
3872                }
3873                let val_ref = self.element_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
3874                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3875                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3876                {
3877                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3878                }
3879                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3880                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3881                }
3882            }
3883
3884            next_offset += envelope_size;
3885            _next_ordinal_to_read += 1;
3886            if next_offset >= end_offset {
3887                return Ok(());
3888            }
3889
3890            // Decode unknown envelopes for gaps in ordinals.
3891            while _next_ordinal_to_read < 2 {
3892                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3893                _next_ordinal_to_read += 1;
3894                next_offset += envelope_size;
3895            }
3896
3897            let next_out_of_line = decoder.next_out_of_line();
3898            let handles_before = decoder.remaining_handles();
3899            if let Some((inlined, num_bytes, num_handles)) =
3900                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3901            {
3902                let member_inline_size = <fidl_fuchsia_hardware_audio__common::DaiFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3903                if inlined != (member_inline_size <= 4) {
3904                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3905                }
3906                let inner_offset;
3907                let mut inner_depth = depth.clone();
3908                if inlined {
3909                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3910                    inner_offset = next_offset;
3911                } else {
3912                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3913                    inner_depth.increment()?;
3914                }
3915                let val_ref = self.dai_format.get_or_insert_with(|| {
3916                    fidl::new_empty!(fidl_fuchsia_hardware_audio__common::DaiFormat, D)
3917                });
3918                fidl::decode!(
3919                    fidl_fuchsia_hardware_audio__common::DaiFormat,
3920                    D,
3921                    val_ref,
3922                    decoder,
3923                    inner_offset,
3924                    inner_depth
3925                )?;
3926                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3927                {
3928                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3929                }
3930                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3931                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3932                }
3933            }
3934
3935            next_offset += envelope_size;
3936
3937            // Decode the remaining unknown envelopes.
3938            while next_offset < end_offset {
3939                _next_ordinal_to_read += 1;
3940                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3941                next_offset += envelope_size;
3942            }
3943
3944            Ok(())
3945        }
3946    }
3947
3948    impl ControlCodecStartResponse {
3949        #[inline(always)]
3950        fn max_ordinal_present(&self) -> u64 {
3951            if let Some(_) = self.start_time {
3952                return 1;
3953            }
3954            0
3955        }
3956    }
3957
3958    impl fidl::encoding::ValueTypeMarker for ControlCodecStartResponse {
3959        type Borrowed<'a> = &'a Self;
3960        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3961            value
3962        }
3963    }
3964
3965    unsafe impl fidl::encoding::TypeMarker for ControlCodecStartResponse {
3966        type Owned = Self;
3967
3968        #[inline(always)]
3969        fn inline_align(_context: fidl::encoding::Context) -> usize {
3970            8
3971        }
3972
3973        #[inline(always)]
3974        fn inline_size(_context: fidl::encoding::Context) -> usize {
3975            16
3976        }
3977    }
3978
3979    unsafe impl<D: fidl::encoding::ResourceDialect>
3980        fidl::encoding::Encode<ControlCodecStartResponse, D> for &ControlCodecStartResponse
3981    {
3982        unsafe fn encode(
3983            self,
3984            encoder: &mut fidl::encoding::Encoder<'_, D>,
3985            offset: usize,
3986            mut depth: fidl::encoding::Depth,
3987        ) -> fidl::Result<()> {
3988            encoder.debug_check_bounds::<ControlCodecStartResponse>(offset);
3989            // Vector header
3990            let max_ordinal: u64 = self.max_ordinal_present();
3991            encoder.write_num(max_ordinal, offset);
3992            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3993            // Calling encoder.out_of_line_offset(0) is not allowed.
3994            if max_ordinal == 0 {
3995                return Ok(());
3996            }
3997            depth.increment()?;
3998            let envelope_size = 8;
3999            let bytes_len = max_ordinal as usize * envelope_size;
4000            #[allow(unused_variables)]
4001            let offset = encoder.out_of_line_offset(bytes_len);
4002            let mut _prev_end_offset: usize = 0;
4003            if 1 > max_ordinal {
4004                return Ok(());
4005            }
4006
4007            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4008            // are envelope_size bytes.
4009            let cur_offset: usize = (1 - 1) * envelope_size;
4010
4011            // Zero reserved fields.
4012            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4013
4014            // Safety:
4015            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4016            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4017            //   envelope_size bytes, there is always sufficient room.
4018            fidl::encoding::encode_in_envelope_optional::<i64, D>(
4019                self.start_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4020                encoder,
4021                offset + cur_offset,
4022                depth,
4023            )?;
4024
4025            _prev_end_offset = cur_offset + envelope_size;
4026
4027            Ok(())
4028        }
4029    }
4030
4031    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4032        for ControlCodecStartResponse
4033    {
4034        #[inline(always)]
4035        fn new_empty() -> Self {
4036            Self::default()
4037        }
4038
4039        unsafe fn decode(
4040            &mut self,
4041            decoder: &mut fidl::encoding::Decoder<'_, D>,
4042            offset: usize,
4043            mut depth: fidl::encoding::Depth,
4044        ) -> fidl::Result<()> {
4045            decoder.debug_check_bounds::<Self>(offset);
4046            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4047                None => return Err(fidl::Error::NotNullable),
4048                Some(len) => len,
4049            };
4050            // Calling decoder.out_of_line_offset(0) is not allowed.
4051            if len == 0 {
4052                return Ok(());
4053            };
4054            depth.increment()?;
4055            let envelope_size = 8;
4056            let bytes_len = len * envelope_size;
4057            let offset = decoder.out_of_line_offset(bytes_len)?;
4058            // Decode the envelope for each type.
4059            let mut _next_ordinal_to_read = 0;
4060            let mut next_offset = offset;
4061            let end_offset = offset + bytes_len;
4062            _next_ordinal_to_read += 1;
4063            if next_offset >= end_offset {
4064                return Ok(());
4065            }
4066
4067            // Decode unknown envelopes for gaps in ordinals.
4068            while _next_ordinal_to_read < 1 {
4069                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4070                _next_ordinal_to_read += 1;
4071                next_offset += envelope_size;
4072            }
4073
4074            let next_out_of_line = decoder.next_out_of_line();
4075            let handles_before = decoder.remaining_handles();
4076            if let Some((inlined, num_bytes, num_handles)) =
4077                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4078            {
4079                let member_inline_size =
4080                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4081                if inlined != (member_inline_size <= 4) {
4082                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4083                }
4084                let inner_offset;
4085                let mut inner_depth = depth.clone();
4086                if inlined {
4087                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4088                    inner_offset = next_offset;
4089                } else {
4090                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4091                    inner_depth.increment()?;
4092                }
4093                let val_ref = self.start_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
4094                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4095                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4096                {
4097                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4098                }
4099                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4100                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4101                }
4102            }
4103
4104            next_offset += envelope_size;
4105
4106            // Decode the remaining unknown envelopes.
4107            while next_offset < end_offset {
4108                _next_ordinal_to_read += 1;
4109                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4110                next_offset += envelope_size;
4111            }
4112
4113            Ok(())
4114        }
4115    }
4116
4117    impl ControlCodecStopResponse {
4118        #[inline(always)]
4119        fn max_ordinal_present(&self) -> u64 {
4120            if let Some(_) = self.stop_time {
4121                return 1;
4122            }
4123            0
4124        }
4125    }
4126
4127    impl fidl::encoding::ValueTypeMarker for ControlCodecStopResponse {
4128        type Borrowed<'a> = &'a Self;
4129        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4130            value
4131        }
4132    }
4133
4134    unsafe impl fidl::encoding::TypeMarker for ControlCodecStopResponse {
4135        type Owned = Self;
4136
4137        #[inline(always)]
4138        fn inline_align(_context: fidl::encoding::Context) -> usize {
4139            8
4140        }
4141
4142        #[inline(always)]
4143        fn inline_size(_context: fidl::encoding::Context) -> usize {
4144            16
4145        }
4146    }
4147
4148    unsafe impl<D: fidl::encoding::ResourceDialect>
4149        fidl::encoding::Encode<ControlCodecStopResponse, D> for &ControlCodecStopResponse
4150    {
4151        unsafe fn encode(
4152            self,
4153            encoder: &mut fidl::encoding::Encoder<'_, D>,
4154            offset: usize,
4155            mut depth: fidl::encoding::Depth,
4156        ) -> fidl::Result<()> {
4157            encoder.debug_check_bounds::<ControlCodecStopResponse>(offset);
4158            // Vector header
4159            let max_ordinal: u64 = self.max_ordinal_present();
4160            encoder.write_num(max_ordinal, offset);
4161            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4162            // Calling encoder.out_of_line_offset(0) is not allowed.
4163            if max_ordinal == 0 {
4164                return Ok(());
4165            }
4166            depth.increment()?;
4167            let envelope_size = 8;
4168            let bytes_len = max_ordinal as usize * envelope_size;
4169            #[allow(unused_variables)]
4170            let offset = encoder.out_of_line_offset(bytes_len);
4171            let mut _prev_end_offset: usize = 0;
4172            if 1 > max_ordinal {
4173                return Ok(());
4174            }
4175
4176            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4177            // are envelope_size bytes.
4178            let cur_offset: usize = (1 - 1) * envelope_size;
4179
4180            // Zero reserved fields.
4181            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4182
4183            // Safety:
4184            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4185            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4186            //   envelope_size bytes, there is always sufficient room.
4187            fidl::encoding::encode_in_envelope_optional::<i64, D>(
4188                self.stop_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4189                encoder,
4190                offset + cur_offset,
4191                depth,
4192            )?;
4193
4194            _prev_end_offset = cur_offset + envelope_size;
4195
4196            Ok(())
4197        }
4198    }
4199
4200    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4201        for ControlCodecStopResponse
4202    {
4203        #[inline(always)]
4204        fn new_empty() -> Self {
4205            Self::default()
4206        }
4207
4208        unsafe fn decode(
4209            &mut self,
4210            decoder: &mut fidl::encoding::Decoder<'_, D>,
4211            offset: usize,
4212            mut depth: fidl::encoding::Depth,
4213        ) -> fidl::Result<()> {
4214            decoder.debug_check_bounds::<Self>(offset);
4215            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4216                None => return Err(fidl::Error::NotNullable),
4217                Some(len) => len,
4218            };
4219            // Calling decoder.out_of_line_offset(0) is not allowed.
4220            if len == 0 {
4221                return Ok(());
4222            };
4223            depth.increment()?;
4224            let envelope_size = 8;
4225            let bytes_len = len * envelope_size;
4226            let offset = decoder.out_of_line_offset(bytes_len)?;
4227            // Decode the envelope for each type.
4228            let mut _next_ordinal_to_read = 0;
4229            let mut next_offset = offset;
4230            let end_offset = offset + bytes_len;
4231            _next_ordinal_to_read += 1;
4232            if next_offset >= end_offset {
4233                return Ok(());
4234            }
4235
4236            // Decode unknown envelopes for gaps in ordinals.
4237            while _next_ordinal_to_read < 1 {
4238                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4239                _next_ordinal_to_read += 1;
4240                next_offset += envelope_size;
4241            }
4242
4243            let next_out_of_line = decoder.next_out_of_line();
4244            let handles_before = decoder.remaining_handles();
4245            if let Some((inlined, num_bytes, num_handles)) =
4246                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4247            {
4248                let member_inline_size =
4249                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4250                if inlined != (member_inline_size <= 4) {
4251                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4252                }
4253                let inner_offset;
4254                let mut inner_depth = depth.clone();
4255                if inlined {
4256                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4257                    inner_offset = next_offset;
4258                } else {
4259                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4260                    inner_depth.increment()?;
4261                }
4262                let val_ref = self.stop_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
4263                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4264                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4265                {
4266                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4267                }
4268                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4269                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4270                }
4271            }
4272
4273            next_offset += envelope_size;
4274
4275            // Decode the remaining unknown envelopes.
4276            while next_offset < end_offset {
4277                _next_ordinal_to_read += 1;
4278                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4279                next_offset += envelope_size;
4280            }
4281
4282            Ok(())
4283        }
4284    }
4285
4286    impl ControlResetResponse {
4287        #[inline(always)]
4288        fn max_ordinal_present(&self) -> u64 {
4289            0
4290        }
4291    }
4292
4293    impl fidl::encoding::ValueTypeMarker for ControlResetResponse {
4294        type Borrowed<'a> = &'a Self;
4295        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4296            value
4297        }
4298    }
4299
4300    unsafe impl fidl::encoding::TypeMarker for ControlResetResponse {
4301        type Owned = Self;
4302
4303        #[inline(always)]
4304        fn inline_align(_context: fidl::encoding::Context) -> usize {
4305            8
4306        }
4307
4308        #[inline(always)]
4309        fn inline_size(_context: fidl::encoding::Context) -> usize {
4310            16
4311        }
4312    }
4313
4314    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ControlResetResponse, D>
4315        for &ControlResetResponse
4316    {
4317        unsafe fn encode(
4318            self,
4319            encoder: &mut fidl::encoding::Encoder<'_, D>,
4320            offset: usize,
4321            mut depth: fidl::encoding::Depth,
4322        ) -> fidl::Result<()> {
4323            encoder.debug_check_bounds::<ControlResetResponse>(offset);
4324            // Vector header
4325            let max_ordinal: u64 = self.max_ordinal_present();
4326            encoder.write_num(max_ordinal, offset);
4327            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4328            // Calling encoder.out_of_line_offset(0) is not allowed.
4329            if max_ordinal == 0 {
4330                return Ok(());
4331            }
4332            depth.increment()?;
4333            let envelope_size = 8;
4334            let bytes_len = max_ordinal as usize * envelope_size;
4335            #[allow(unused_variables)]
4336            let offset = encoder.out_of_line_offset(bytes_len);
4337            let mut _prev_end_offset: usize = 0;
4338
4339            Ok(())
4340        }
4341    }
4342
4343    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlResetResponse {
4344        #[inline(always)]
4345        fn new_empty() -> Self {
4346            Self::default()
4347        }
4348
4349        unsafe fn decode(
4350            &mut self,
4351            decoder: &mut fidl::encoding::Decoder<'_, D>,
4352            offset: usize,
4353            mut depth: fidl::encoding::Depth,
4354        ) -> fidl::Result<()> {
4355            decoder.debug_check_bounds::<Self>(offset);
4356            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4357                None => return Err(fidl::Error::NotNullable),
4358                Some(len) => len,
4359            };
4360            // Calling decoder.out_of_line_offset(0) is not allowed.
4361            if len == 0 {
4362                return Ok(());
4363            };
4364            depth.increment()?;
4365            let envelope_size = 8;
4366            let bytes_len = len * envelope_size;
4367            let offset = decoder.out_of_line_offset(bytes_len)?;
4368            // Decode the envelope for each type.
4369            let mut _next_ordinal_to_read = 0;
4370            let mut next_offset = offset;
4371            let end_offset = offset + bytes_len;
4372
4373            // Decode the remaining unknown envelopes.
4374            while next_offset < end_offset {
4375                _next_ordinal_to_read += 1;
4376                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4377                next_offset += envelope_size;
4378            }
4379
4380            Ok(())
4381        }
4382    }
4383
4384    impl ControlSetDaiFormatResponse {
4385        #[inline(always)]
4386        fn max_ordinal_present(&self) -> u64 {
4387            if let Some(_) = self.state {
4388                return 1;
4389            }
4390            0
4391        }
4392    }
4393
4394    impl fidl::encoding::ValueTypeMarker for ControlSetDaiFormatResponse {
4395        type Borrowed<'a> = &'a Self;
4396        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4397            value
4398        }
4399    }
4400
4401    unsafe impl fidl::encoding::TypeMarker for ControlSetDaiFormatResponse {
4402        type Owned = Self;
4403
4404        #[inline(always)]
4405        fn inline_align(_context: fidl::encoding::Context) -> usize {
4406            8
4407        }
4408
4409        #[inline(always)]
4410        fn inline_size(_context: fidl::encoding::Context) -> usize {
4411            16
4412        }
4413    }
4414
4415    unsafe impl<D: fidl::encoding::ResourceDialect>
4416        fidl::encoding::Encode<ControlSetDaiFormatResponse, D> for &ControlSetDaiFormatResponse
4417    {
4418        unsafe fn encode(
4419            self,
4420            encoder: &mut fidl::encoding::Encoder<'_, D>,
4421            offset: usize,
4422            mut depth: fidl::encoding::Depth,
4423        ) -> fidl::Result<()> {
4424            encoder.debug_check_bounds::<ControlSetDaiFormatResponse>(offset);
4425            // Vector header
4426            let max_ordinal: u64 = self.max_ordinal_present();
4427            encoder.write_num(max_ordinal, offset);
4428            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4429            // Calling encoder.out_of_line_offset(0) is not allowed.
4430            if max_ordinal == 0 {
4431                return Ok(());
4432            }
4433            depth.increment()?;
4434            let envelope_size = 8;
4435            let bytes_len = max_ordinal as usize * envelope_size;
4436            #[allow(unused_variables)]
4437            let offset = encoder.out_of_line_offset(bytes_len);
4438            let mut _prev_end_offset: usize = 0;
4439            if 1 > max_ordinal {
4440                return Ok(());
4441            }
4442
4443            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4444            // are envelope_size bytes.
4445            let cur_offset: usize = (1 - 1) * envelope_size;
4446
4447            // Zero reserved fields.
4448            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4449
4450            // Safety:
4451            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4452            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4453            //   envelope_size bytes, there is always sufficient room.
4454            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_audio__common::CodecFormatInfo, D>(
4455            self.state.as_ref().map(<fidl_fuchsia_hardware_audio__common::CodecFormatInfo as fidl::encoding::ValueTypeMarker>::borrow),
4456            encoder, offset + cur_offset, depth
4457        )?;
4458
4459            _prev_end_offset = cur_offset + envelope_size;
4460
4461            Ok(())
4462        }
4463    }
4464
4465    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4466        for ControlSetDaiFormatResponse
4467    {
4468        #[inline(always)]
4469        fn new_empty() -> Self {
4470            Self::default()
4471        }
4472
4473        unsafe fn decode(
4474            &mut self,
4475            decoder: &mut fidl::encoding::Decoder<'_, D>,
4476            offset: usize,
4477            mut depth: fidl::encoding::Depth,
4478        ) -> fidl::Result<()> {
4479            decoder.debug_check_bounds::<Self>(offset);
4480            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4481                None => return Err(fidl::Error::NotNullable),
4482                Some(len) => len,
4483            };
4484            // Calling decoder.out_of_line_offset(0) is not allowed.
4485            if len == 0 {
4486                return Ok(());
4487            };
4488            depth.increment()?;
4489            let envelope_size = 8;
4490            let bytes_len = len * envelope_size;
4491            let offset = decoder.out_of_line_offset(bytes_len)?;
4492            // Decode the envelope for each type.
4493            let mut _next_ordinal_to_read = 0;
4494            let mut next_offset = offset;
4495            let end_offset = offset + bytes_len;
4496            _next_ordinal_to_read += 1;
4497            if next_offset >= end_offset {
4498                return Ok(());
4499            }
4500
4501            // Decode unknown envelopes for gaps in ordinals.
4502            while _next_ordinal_to_read < 1 {
4503                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4504                _next_ordinal_to_read += 1;
4505                next_offset += envelope_size;
4506            }
4507
4508            let next_out_of_line = decoder.next_out_of_line();
4509            let handles_before = decoder.remaining_handles();
4510            if let Some((inlined, num_bytes, num_handles)) =
4511                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4512            {
4513                let member_inline_size = <fidl_fuchsia_hardware_audio__common::CodecFormatInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4514                if inlined != (member_inline_size <= 4) {
4515                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4516                }
4517                let inner_offset;
4518                let mut inner_depth = depth.clone();
4519                if inlined {
4520                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4521                    inner_offset = next_offset;
4522                } else {
4523                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4524                    inner_depth.increment()?;
4525                }
4526                let val_ref = self.state.get_or_insert_with(|| {
4527                    fidl::new_empty!(fidl_fuchsia_hardware_audio__common::CodecFormatInfo, D)
4528                });
4529                fidl::decode!(
4530                    fidl_fuchsia_hardware_audio__common::CodecFormatInfo,
4531                    D,
4532                    val_ref,
4533                    decoder,
4534                    inner_offset,
4535                    inner_depth
4536                )?;
4537                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4538                {
4539                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4540                }
4541                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4542                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4543                }
4544            }
4545
4546            next_offset += envelope_size;
4547
4548            // Decode the remaining unknown envelopes.
4549            while next_offset < end_offset {
4550                _next_ordinal_to_read += 1;
4551                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4552                next_offset += envelope_size;
4553            }
4554
4555            Ok(())
4556        }
4557    }
4558
4559    impl DelayInfo {
4560        #[inline(always)]
4561        fn max_ordinal_present(&self) -> u64 {
4562            if let Some(_) = self.external_delay {
4563                return 2;
4564            }
4565            if let Some(_) = self.internal_delay {
4566                return 1;
4567            }
4568            0
4569        }
4570    }
4571
4572    impl fidl::encoding::ValueTypeMarker for DelayInfo {
4573        type Borrowed<'a> = &'a Self;
4574        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4575            value
4576        }
4577    }
4578
4579    unsafe impl fidl::encoding::TypeMarker for DelayInfo {
4580        type Owned = Self;
4581
4582        #[inline(always)]
4583        fn inline_align(_context: fidl::encoding::Context) -> usize {
4584            8
4585        }
4586
4587        #[inline(always)]
4588        fn inline_size(_context: fidl::encoding::Context) -> usize {
4589            16
4590        }
4591    }
4592
4593    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DelayInfo, D>
4594        for &DelayInfo
4595    {
4596        unsafe fn encode(
4597            self,
4598            encoder: &mut fidl::encoding::Encoder<'_, D>,
4599            offset: usize,
4600            mut depth: fidl::encoding::Depth,
4601        ) -> fidl::Result<()> {
4602            encoder.debug_check_bounds::<DelayInfo>(offset);
4603            // Vector header
4604            let max_ordinal: u64 = self.max_ordinal_present();
4605            encoder.write_num(max_ordinal, offset);
4606            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4607            // Calling encoder.out_of_line_offset(0) is not allowed.
4608            if max_ordinal == 0 {
4609                return Ok(());
4610            }
4611            depth.increment()?;
4612            let envelope_size = 8;
4613            let bytes_len = max_ordinal as usize * envelope_size;
4614            #[allow(unused_variables)]
4615            let offset = encoder.out_of_line_offset(bytes_len);
4616            let mut _prev_end_offset: usize = 0;
4617            if 1 > max_ordinal {
4618                return Ok(());
4619            }
4620
4621            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4622            // are envelope_size bytes.
4623            let cur_offset: usize = (1 - 1) * envelope_size;
4624
4625            // Zero reserved fields.
4626            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4627
4628            // Safety:
4629            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4630            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4631            //   envelope_size bytes, there is always sufficient room.
4632            fidl::encoding::encode_in_envelope_optional::<i64, D>(
4633                self.internal_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4634                encoder,
4635                offset + cur_offset,
4636                depth,
4637            )?;
4638
4639            _prev_end_offset = cur_offset + envelope_size;
4640            if 2 > max_ordinal {
4641                return Ok(());
4642            }
4643
4644            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4645            // are envelope_size bytes.
4646            let cur_offset: usize = (2 - 1) * envelope_size;
4647
4648            // Zero reserved fields.
4649            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4650
4651            // Safety:
4652            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4653            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4654            //   envelope_size bytes, there is always sufficient room.
4655            fidl::encoding::encode_in_envelope_optional::<i64, D>(
4656                self.external_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4657                encoder,
4658                offset + cur_offset,
4659                depth,
4660            )?;
4661
4662            _prev_end_offset = cur_offset + envelope_size;
4663
4664            Ok(())
4665        }
4666    }
4667
4668    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DelayInfo {
4669        #[inline(always)]
4670        fn new_empty() -> Self {
4671            Self::default()
4672        }
4673
4674        unsafe fn decode(
4675            &mut self,
4676            decoder: &mut fidl::encoding::Decoder<'_, D>,
4677            offset: usize,
4678            mut depth: fidl::encoding::Depth,
4679        ) -> fidl::Result<()> {
4680            decoder.debug_check_bounds::<Self>(offset);
4681            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4682                None => return Err(fidl::Error::NotNullable),
4683                Some(len) => len,
4684            };
4685            // Calling decoder.out_of_line_offset(0) is not allowed.
4686            if len == 0 {
4687                return Ok(());
4688            };
4689            depth.increment()?;
4690            let envelope_size = 8;
4691            let bytes_len = len * envelope_size;
4692            let offset = decoder.out_of_line_offset(bytes_len)?;
4693            // Decode the envelope for each type.
4694            let mut _next_ordinal_to_read = 0;
4695            let mut next_offset = offset;
4696            let end_offset = offset + bytes_len;
4697            _next_ordinal_to_read += 1;
4698            if next_offset >= end_offset {
4699                return Ok(());
4700            }
4701
4702            // Decode unknown envelopes for gaps in ordinals.
4703            while _next_ordinal_to_read < 1 {
4704                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4705                _next_ordinal_to_read += 1;
4706                next_offset += envelope_size;
4707            }
4708
4709            let next_out_of_line = decoder.next_out_of_line();
4710            let handles_before = decoder.remaining_handles();
4711            if let Some((inlined, num_bytes, num_handles)) =
4712                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4713            {
4714                let member_inline_size =
4715                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4716                if inlined != (member_inline_size <= 4) {
4717                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4718                }
4719                let inner_offset;
4720                let mut inner_depth = depth.clone();
4721                if inlined {
4722                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4723                    inner_offset = next_offset;
4724                } else {
4725                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4726                    inner_depth.increment()?;
4727                }
4728                let val_ref = self.internal_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
4729                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4730                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4731                {
4732                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4733                }
4734                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4735                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4736                }
4737            }
4738
4739            next_offset += envelope_size;
4740            _next_ordinal_to_read += 1;
4741            if next_offset >= end_offset {
4742                return Ok(());
4743            }
4744
4745            // Decode unknown envelopes for gaps in ordinals.
4746            while _next_ordinal_to_read < 2 {
4747                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4748                _next_ordinal_to_read += 1;
4749                next_offset += envelope_size;
4750            }
4751
4752            let next_out_of_line = decoder.next_out_of_line();
4753            let handles_before = decoder.remaining_handles();
4754            if let Some((inlined, num_bytes, num_handles)) =
4755                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4756            {
4757                let member_inline_size =
4758                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4759                if inlined != (member_inline_size <= 4) {
4760                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4761                }
4762                let inner_offset;
4763                let mut inner_depth = depth.clone();
4764                if inlined {
4765                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4766                    inner_offset = next_offset;
4767                } else {
4768                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4769                    inner_depth.increment()?;
4770                }
4771                let val_ref = self.external_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
4772                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4773                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4774                {
4775                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4776                }
4777                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4778                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4779                }
4780            }
4781
4782            next_offset += envelope_size;
4783
4784            // Decode the remaining unknown envelopes.
4785            while next_offset < end_offset {
4786                _next_ordinal_to_read += 1;
4787                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4788                next_offset += envelope_size;
4789            }
4790
4791            Ok(())
4792        }
4793    }
4794
4795    impl ElementDaiFormatSet {
4796        #[inline(always)]
4797        fn max_ordinal_present(&self) -> u64 {
4798            if let Some(_) = self.format_sets {
4799                return 2;
4800            }
4801            if let Some(_) = self.element_id {
4802                return 1;
4803            }
4804            0
4805        }
4806    }
4807
4808    impl fidl::encoding::ValueTypeMarker for ElementDaiFormatSet {
4809        type Borrowed<'a> = &'a Self;
4810        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4811            value
4812        }
4813    }
4814
4815    unsafe impl fidl::encoding::TypeMarker for ElementDaiFormatSet {
4816        type Owned = Self;
4817
4818        #[inline(always)]
4819        fn inline_align(_context: fidl::encoding::Context) -> usize {
4820            8
4821        }
4822
4823        #[inline(always)]
4824        fn inline_size(_context: fidl::encoding::Context) -> usize {
4825            16
4826        }
4827    }
4828
4829    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ElementDaiFormatSet, D>
4830        for &ElementDaiFormatSet
4831    {
4832        unsafe fn encode(
4833            self,
4834            encoder: &mut fidl::encoding::Encoder<'_, D>,
4835            offset: usize,
4836            mut depth: fidl::encoding::Depth,
4837        ) -> fidl::Result<()> {
4838            encoder.debug_check_bounds::<ElementDaiFormatSet>(offset);
4839            // Vector header
4840            let max_ordinal: u64 = self.max_ordinal_present();
4841            encoder.write_num(max_ordinal, offset);
4842            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4843            // Calling encoder.out_of_line_offset(0) is not allowed.
4844            if max_ordinal == 0 {
4845                return Ok(());
4846            }
4847            depth.increment()?;
4848            let envelope_size = 8;
4849            let bytes_len = max_ordinal as usize * envelope_size;
4850            #[allow(unused_variables)]
4851            let offset = encoder.out_of_line_offset(bytes_len);
4852            let mut _prev_end_offset: usize = 0;
4853            if 1 > max_ordinal {
4854                return Ok(());
4855            }
4856
4857            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4858            // are envelope_size bytes.
4859            let cur_offset: usize = (1 - 1) * envelope_size;
4860
4861            // Zero reserved fields.
4862            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4863
4864            // Safety:
4865            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4866            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4867            //   envelope_size bytes, there is always sufficient room.
4868            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4869                self.element_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4870                encoder,
4871                offset + cur_offset,
4872                depth,
4873            )?;
4874
4875            _prev_end_offset = cur_offset + envelope_size;
4876            if 2 > max_ordinal {
4877                return Ok(());
4878            }
4879
4880            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4881            // are envelope_size bytes.
4882            let cur_offset: usize = (2 - 1) * envelope_size;
4883
4884            // Zero reserved fields.
4885            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4886
4887            // Safety:
4888            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4889            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4890            //   envelope_size bytes, there is always sufficient room.
4891            fidl::encoding::encode_in_envelope_optional::<
4892                fidl::encoding::Vector<
4893                    fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
4894                    64,
4895                >,
4896                D,
4897            >(
4898                self.format_sets.as_ref().map(
4899                    <fidl::encoding::Vector<
4900                        fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
4901                        64,
4902                    > as fidl::encoding::ValueTypeMarker>::borrow,
4903                ),
4904                encoder,
4905                offset + cur_offset,
4906                depth,
4907            )?;
4908
4909            _prev_end_offset = cur_offset + envelope_size;
4910
4911            Ok(())
4912        }
4913    }
4914
4915    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ElementDaiFormatSet {
4916        #[inline(always)]
4917        fn new_empty() -> Self {
4918            Self::default()
4919        }
4920
4921        unsafe fn decode(
4922            &mut self,
4923            decoder: &mut fidl::encoding::Decoder<'_, D>,
4924            offset: usize,
4925            mut depth: fidl::encoding::Depth,
4926        ) -> fidl::Result<()> {
4927            decoder.debug_check_bounds::<Self>(offset);
4928            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4929                None => return Err(fidl::Error::NotNullable),
4930                Some(len) => len,
4931            };
4932            // Calling decoder.out_of_line_offset(0) is not allowed.
4933            if len == 0 {
4934                return Ok(());
4935            };
4936            depth.increment()?;
4937            let envelope_size = 8;
4938            let bytes_len = len * envelope_size;
4939            let offset = decoder.out_of_line_offset(bytes_len)?;
4940            // Decode the envelope for each type.
4941            let mut _next_ordinal_to_read = 0;
4942            let mut next_offset = offset;
4943            let end_offset = offset + bytes_len;
4944            _next_ordinal_to_read += 1;
4945            if next_offset >= end_offset {
4946                return Ok(());
4947            }
4948
4949            // Decode unknown envelopes for gaps in ordinals.
4950            while _next_ordinal_to_read < 1 {
4951                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4952                _next_ordinal_to_read += 1;
4953                next_offset += envelope_size;
4954            }
4955
4956            let next_out_of_line = decoder.next_out_of_line();
4957            let handles_before = decoder.remaining_handles();
4958            if let Some((inlined, num_bytes, num_handles)) =
4959                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4960            {
4961                let member_inline_size =
4962                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4963                if inlined != (member_inline_size <= 4) {
4964                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4965                }
4966                let inner_offset;
4967                let mut inner_depth = depth.clone();
4968                if inlined {
4969                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4970                    inner_offset = next_offset;
4971                } else {
4972                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4973                    inner_depth.increment()?;
4974                }
4975                let val_ref = self.element_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
4976                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4977                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4978                {
4979                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4980                }
4981                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4982                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4983                }
4984            }
4985
4986            next_offset += envelope_size;
4987            _next_ordinal_to_read += 1;
4988            if next_offset >= end_offset {
4989                return Ok(());
4990            }
4991
4992            // Decode unknown envelopes for gaps in ordinals.
4993            while _next_ordinal_to_read < 2 {
4994                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4995                _next_ordinal_to_read += 1;
4996                next_offset += envelope_size;
4997            }
4998
4999            let next_out_of_line = decoder.next_out_of_line();
5000            let handles_before = decoder.remaining_handles();
5001            if let Some((inlined, num_bytes, num_handles)) =
5002                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5003            {
5004                let member_inline_size = <fidl::encoding::Vector<
5005                    fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
5006                    64,
5007                > as fidl::encoding::TypeMarker>::inline_size(
5008                    decoder.context
5009                );
5010                if inlined != (member_inline_size <= 4) {
5011                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5012                }
5013                let inner_offset;
5014                let mut inner_depth = depth.clone();
5015                if inlined {
5016                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5017                    inner_offset = next_offset;
5018                } else {
5019                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5020                    inner_depth.increment()?;
5021                }
5022                let val_ref =
5023                self.format_sets.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio__common::DaiSupportedFormats, 64>, D));
5024                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio__common::DaiSupportedFormats, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
5025                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5026                {
5027                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5028                }
5029                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5030                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5031                }
5032            }
5033
5034            next_offset += envelope_size;
5035
5036            // Decode the remaining unknown envelopes.
5037            while next_offset < end_offset {
5038                _next_ordinal_to_read += 1;
5039                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5040                next_offset += envelope_size;
5041            }
5042
5043            Ok(())
5044        }
5045    }
5046
5047    impl ElementRingBufferFormatSet {
5048        #[inline(always)]
5049        fn max_ordinal_present(&self) -> u64 {
5050            if let Some(_) = self.format_sets {
5051                return 2;
5052            }
5053            if let Some(_) = self.element_id {
5054                return 1;
5055            }
5056            0
5057        }
5058    }
5059
5060    impl fidl::encoding::ValueTypeMarker for ElementRingBufferFormatSet {
5061        type Borrowed<'a> = &'a Self;
5062        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5063            value
5064        }
5065    }
5066
5067    unsafe impl fidl::encoding::TypeMarker for ElementRingBufferFormatSet {
5068        type Owned = Self;
5069
5070        #[inline(always)]
5071        fn inline_align(_context: fidl::encoding::Context) -> usize {
5072            8
5073        }
5074
5075        #[inline(always)]
5076        fn inline_size(_context: fidl::encoding::Context) -> usize {
5077            16
5078        }
5079    }
5080
5081    unsafe impl<D: fidl::encoding::ResourceDialect>
5082        fidl::encoding::Encode<ElementRingBufferFormatSet, D> for &ElementRingBufferFormatSet
5083    {
5084        unsafe fn encode(
5085            self,
5086            encoder: &mut fidl::encoding::Encoder<'_, D>,
5087            offset: usize,
5088            mut depth: fidl::encoding::Depth,
5089        ) -> fidl::Result<()> {
5090            encoder.debug_check_bounds::<ElementRingBufferFormatSet>(offset);
5091            // Vector header
5092            let max_ordinal: u64 = self.max_ordinal_present();
5093            encoder.write_num(max_ordinal, offset);
5094            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5095            // Calling encoder.out_of_line_offset(0) is not allowed.
5096            if max_ordinal == 0 {
5097                return Ok(());
5098            }
5099            depth.increment()?;
5100            let envelope_size = 8;
5101            let bytes_len = max_ordinal as usize * envelope_size;
5102            #[allow(unused_variables)]
5103            let offset = encoder.out_of_line_offset(bytes_len);
5104            let mut _prev_end_offset: usize = 0;
5105            if 1 > max_ordinal {
5106                return Ok(());
5107            }
5108
5109            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5110            // are envelope_size bytes.
5111            let cur_offset: usize = (1 - 1) * envelope_size;
5112
5113            // Zero reserved fields.
5114            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5115
5116            // Safety:
5117            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5118            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5119            //   envelope_size bytes, there is always sufficient room.
5120            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5121                self.element_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5122                encoder,
5123                offset + cur_offset,
5124                depth,
5125            )?;
5126
5127            _prev_end_offset = cur_offset + envelope_size;
5128            if 2 > max_ordinal {
5129                return Ok(());
5130            }
5131
5132            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5133            // are envelope_size bytes.
5134            let cur_offset: usize = (2 - 1) * envelope_size;
5135
5136            // Zero reserved fields.
5137            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5138
5139            // Safety:
5140            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5141            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5142            //   envelope_size bytes, there is always sufficient room.
5143            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<PcmFormatSet, 64>, D>(
5144            self.format_sets.as_ref().map(<fidl::encoding::Vector<PcmFormatSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5145            encoder, offset + cur_offset, depth
5146        )?;
5147
5148            _prev_end_offset = cur_offset + envelope_size;
5149
5150            Ok(())
5151        }
5152    }
5153
5154    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5155        for ElementRingBufferFormatSet
5156    {
5157        #[inline(always)]
5158        fn new_empty() -> Self {
5159            Self::default()
5160        }
5161
5162        unsafe fn decode(
5163            &mut self,
5164            decoder: &mut fidl::encoding::Decoder<'_, D>,
5165            offset: usize,
5166            mut depth: fidl::encoding::Depth,
5167        ) -> fidl::Result<()> {
5168            decoder.debug_check_bounds::<Self>(offset);
5169            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5170                None => return Err(fidl::Error::NotNullable),
5171                Some(len) => len,
5172            };
5173            // Calling decoder.out_of_line_offset(0) is not allowed.
5174            if len == 0 {
5175                return Ok(());
5176            };
5177            depth.increment()?;
5178            let envelope_size = 8;
5179            let bytes_len = len * envelope_size;
5180            let offset = decoder.out_of_line_offset(bytes_len)?;
5181            // Decode the envelope for each type.
5182            let mut _next_ordinal_to_read = 0;
5183            let mut next_offset = offset;
5184            let end_offset = offset + bytes_len;
5185            _next_ordinal_to_read += 1;
5186            if next_offset >= end_offset {
5187                return Ok(());
5188            }
5189
5190            // Decode unknown envelopes for gaps in ordinals.
5191            while _next_ordinal_to_read < 1 {
5192                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5193                _next_ordinal_to_read += 1;
5194                next_offset += envelope_size;
5195            }
5196
5197            let next_out_of_line = decoder.next_out_of_line();
5198            let handles_before = decoder.remaining_handles();
5199            if let Some((inlined, num_bytes, num_handles)) =
5200                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5201            {
5202                let member_inline_size =
5203                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5204                if inlined != (member_inline_size <= 4) {
5205                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5206                }
5207                let inner_offset;
5208                let mut inner_depth = depth.clone();
5209                if inlined {
5210                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5211                    inner_offset = next_offset;
5212                } else {
5213                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5214                    inner_depth.increment()?;
5215                }
5216                let val_ref = self.element_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5217                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5218                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5219                {
5220                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5221                }
5222                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5223                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5224                }
5225            }
5226
5227            next_offset += envelope_size;
5228            _next_ordinal_to_read += 1;
5229            if next_offset >= end_offset {
5230                return Ok(());
5231            }
5232
5233            // Decode unknown envelopes for gaps in ordinals.
5234            while _next_ordinal_to_read < 2 {
5235                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5236                _next_ordinal_to_read += 1;
5237                next_offset += envelope_size;
5238            }
5239
5240            let next_out_of_line = decoder.next_out_of_line();
5241            let handles_before = decoder.remaining_handles();
5242            if let Some((inlined, num_bytes, num_handles)) =
5243                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5244            {
5245                let member_inline_size = <fidl::encoding::Vector<PcmFormatSet, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5246                if inlined != (member_inline_size <= 4) {
5247                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5248                }
5249                let inner_offset;
5250                let mut inner_depth = depth.clone();
5251                if inlined {
5252                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5253                    inner_offset = next_offset;
5254                } else {
5255                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5256                    inner_depth.increment()?;
5257                }
5258                let val_ref = self.format_sets.get_or_insert_with(
5259                    || fidl::new_empty!(fidl::encoding::Vector<PcmFormatSet, 64>, D),
5260                );
5261                fidl::decode!(fidl::encoding::Vector<PcmFormatSet, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
5262                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5263                {
5264                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5265                }
5266                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5267                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5268                }
5269            }
5270
5271            next_offset += envelope_size;
5272
5273            // Decode the remaining unknown envelopes.
5274            while next_offset < end_offset {
5275                _next_ordinal_to_read += 1;
5276                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5277                next_offset += envelope_size;
5278            }
5279
5280            Ok(())
5281        }
5282    }
5283
5284    impl Info {
5285        #[inline(always)]
5286        fn max_ordinal_present(&self) -> u64 {
5287            if let Some(_) = self.signal_processing_topologies {
5288                return 13;
5289            }
5290            if let Some(_) = self.signal_processing_elements {
5291                return 12;
5292            }
5293            if let Some(_) = self.clock_domain {
5294                return 11;
5295            }
5296            if let Some(_) = self.plug_detect_caps {
5297                return 10;
5298            }
5299            if let Some(_) = self.dai_format_sets {
5300                return 9;
5301            }
5302            if let Some(_) = self.ring_buffer_format_sets {
5303                return 8;
5304            }
5305            if let Some(_) = self.is_input {
5306                return 7;
5307            }
5308            if let Some(_) = self.unique_instance_id {
5309                return 6;
5310            }
5311            if let Some(_) = self.product {
5312                return 5;
5313            }
5314            if let Some(_) = self.manufacturer {
5315                return 4;
5316            }
5317            if let Some(_) = self.device_name {
5318                return 3;
5319            }
5320            if let Some(_) = self.device_type {
5321                return 2;
5322            }
5323            if let Some(_) = self.token_id {
5324                return 1;
5325            }
5326            0
5327        }
5328    }
5329
5330    impl fidl::encoding::ValueTypeMarker for Info {
5331        type Borrowed<'a> = &'a Self;
5332        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5333            value
5334        }
5335    }
5336
5337    unsafe impl fidl::encoding::TypeMarker for Info {
5338        type Owned = Self;
5339
5340        #[inline(always)]
5341        fn inline_align(_context: fidl::encoding::Context) -> usize {
5342            8
5343        }
5344
5345        #[inline(always)]
5346        fn inline_size(_context: fidl::encoding::Context) -> usize {
5347            16
5348        }
5349    }
5350
5351    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Info, D> for &Info {
5352        unsafe fn encode(
5353            self,
5354            encoder: &mut fidl::encoding::Encoder<'_, D>,
5355            offset: usize,
5356            mut depth: fidl::encoding::Depth,
5357        ) -> fidl::Result<()> {
5358            encoder.debug_check_bounds::<Info>(offset);
5359            // Vector header
5360            let max_ordinal: u64 = self.max_ordinal_present();
5361            encoder.write_num(max_ordinal, offset);
5362            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5363            // Calling encoder.out_of_line_offset(0) is not allowed.
5364            if max_ordinal == 0 {
5365                return Ok(());
5366            }
5367            depth.increment()?;
5368            let envelope_size = 8;
5369            let bytes_len = max_ordinal as usize * envelope_size;
5370            #[allow(unused_variables)]
5371            let offset = encoder.out_of_line_offset(bytes_len);
5372            let mut _prev_end_offset: usize = 0;
5373            if 1 > max_ordinal {
5374                return Ok(());
5375            }
5376
5377            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5378            // are envelope_size bytes.
5379            let cur_offset: usize = (1 - 1) * envelope_size;
5380
5381            // Zero reserved fields.
5382            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5383
5384            // Safety:
5385            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5386            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5387            //   envelope_size bytes, there is always sufficient room.
5388            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5389                self.token_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5390                encoder,
5391                offset + cur_offset,
5392                depth,
5393            )?;
5394
5395            _prev_end_offset = cur_offset + envelope_size;
5396            if 2 > max_ordinal {
5397                return Ok(());
5398            }
5399
5400            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5401            // are envelope_size bytes.
5402            let cur_offset: usize = (2 - 1) * envelope_size;
5403
5404            // Zero reserved fields.
5405            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5406
5407            // Safety:
5408            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5409            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5410            //   envelope_size bytes, there is always sufficient room.
5411            fidl::encoding::encode_in_envelope_optional::<DeviceType, D>(
5412                self.device_type
5413                    .as_ref()
5414                    .map(<DeviceType as fidl::encoding::ValueTypeMarker>::borrow),
5415                encoder,
5416                offset + cur_offset,
5417                depth,
5418            )?;
5419
5420            _prev_end_offset = cur_offset + envelope_size;
5421            if 3 > max_ordinal {
5422                return Ok(());
5423            }
5424
5425            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5426            // are envelope_size bytes.
5427            let cur_offset: usize = (3 - 1) * envelope_size;
5428
5429            // Zero reserved fields.
5430            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5431
5432            // Safety:
5433            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5434            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5435            //   envelope_size bytes, there is always sufficient room.
5436            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
5437                self.device_name.as_ref().map(
5438                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
5439                ),
5440                encoder,
5441                offset + cur_offset,
5442                depth,
5443            )?;
5444
5445            _prev_end_offset = cur_offset + envelope_size;
5446            if 4 > max_ordinal {
5447                return Ok(());
5448            }
5449
5450            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5451            // are envelope_size bytes.
5452            let cur_offset: usize = (4 - 1) * envelope_size;
5453
5454            // Zero reserved fields.
5455            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5456
5457            // Safety:
5458            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5459            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5460            //   envelope_size bytes, there is always sufficient room.
5461            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
5462                self.manufacturer.as_ref().map(
5463                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
5464                ),
5465                encoder,
5466                offset + cur_offset,
5467                depth,
5468            )?;
5469
5470            _prev_end_offset = cur_offset + envelope_size;
5471            if 5 > max_ordinal {
5472                return Ok(());
5473            }
5474
5475            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5476            // are envelope_size bytes.
5477            let cur_offset: usize = (5 - 1) * envelope_size;
5478
5479            // Zero reserved fields.
5480            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5481
5482            // Safety:
5483            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5484            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5485            //   envelope_size bytes, there is always sufficient room.
5486            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
5487                self.product.as_ref().map(
5488                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
5489                ),
5490                encoder,
5491                offset + cur_offset,
5492                depth,
5493            )?;
5494
5495            _prev_end_offset = cur_offset + envelope_size;
5496            if 6 > max_ordinal {
5497                return Ok(());
5498            }
5499
5500            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5501            // are envelope_size bytes.
5502            let cur_offset: usize = (6 - 1) * envelope_size;
5503
5504            // Zero reserved fields.
5505            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5506
5507            // Safety:
5508            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5509            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5510            //   envelope_size bytes, there is always sufficient room.
5511            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 16>, D>(
5512                self.unique_instance_id.as_ref().map(
5513                    <fidl::encoding::Array<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
5514                ),
5515                encoder,
5516                offset + cur_offset,
5517                depth,
5518            )?;
5519
5520            _prev_end_offset = cur_offset + envelope_size;
5521            if 7 > max_ordinal {
5522                return Ok(());
5523            }
5524
5525            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5526            // are envelope_size bytes.
5527            let cur_offset: usize = (7 - 1) * envelope_size;
5528
5529            // Zero reserved fields.
5530            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5531
5532            // Safety:
5533            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5534            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5535            //   envelope_size bytes, there is always sufficient room.
5536            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5537                self.is_input.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5538                encoder,
5539                offset + cur_offset,
5540                depth,
5541            )?;
5542
5543            _prev_end_offset = cur_offset + envelope_size;
5544            if 8 > max_ordinal {
5545                return Ok(());
5546            }
5547
5548            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5549            // are envelope_size bytes.
5550            let cur_offset: usize = (8 - 1) * envelope_size;
5551
5552            // Zero reserved fields.
5553            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5554
5555            // Safety:
5556            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5557            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5558            //   envelope_size bytes, there is always sufficient room.
5559            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ElementRingBufferFormatSet, 64>, D>(
5560            self.ring_buffer_format_sets.as_ref().map(<fidl::encoding::Vector<ElementRingBufferFormatSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5561            encoder, offset + cur_offset, depth
5562        )?;
5563
5564            _prev_end_offset = cur_offset + envelope_size;
5565            if 9 > max_ordinal {
5566                return Ok(());
5567            }
5568
5569            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5570            // are envelope_size bytes.
5571            let cur_offset: usize = (9 - 1) * envelope_size;
5572
5573            // Zero reserved fields.
5574            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5575
5576            // Safety:
5577            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5578            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5579            //   envelope_size bytes, there is always sufficient room.
5580            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ElementDaiFormatSet, 64>, D>(
5581            self.dai_format_sets.as_ref().map(<fidl::encoding::Vector<ElementDaiFormatSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5582            encoder, offset + cur_offset, depth
5583        )?;
5584
5585            _prev_end_offset = cur_offset + envelope_size;
5586            if 10 > max_ordinal {
5587                return Ok(());
5588            }
5589
5590            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5591            // are envelope_size bytes.
5592            let cur_offset: usize = (10 - 1) * envelope_size;
5593
5594            // Zero reserved fields.
5595            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5596
5597            // Safety:
5598            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5599            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5600            //   envelope_size bytes, there is always sufficient room.
5601            fidl::encoding::encode_in_envelope_optional::<PlugDetectCapabilities, D>(
5602                self.plug_detect_caps
5603                    .as_ref()
5604                    .map(<PlugDetectCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
5605                encoder,
5606                offset + cur_offset,
5607                depth,
5608            )?;
5609
5610            _prev_end_offset = cur_offset + envelope_size;
5611            if 11 > max_ordinal {
5612                return Ok(());
5613            }
5614
5615            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5616            // are envelope_size bytes.
5617            let cur_offset: usize = (11 - 1) * envelope_size;
5618
5619            // Zero reserved fields.
5620            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5621
5622            // Safety:
5623            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5624            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5625            //   envelope_size bytes, there is always sufficient room.
5626            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5627                self.clock_domain.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5628                encoder,
5629                offset + cur_offset,
5630                depth,
5631            )?;
5632
5633            _prev_end_offset = cur_offset + envelope_size;
5634            if 12 > max_ordinal {
5635                return Ok(());
5636            }
5637
5638            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5639            // are envelope_size bytes.
5640            let cur_offset: usize = (12 - 1) * envelope_size;
5641
5642            // Zero reserved fields.
5643            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5644
5645            // Safety:
5646            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5647            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5648            //   envelope_size bytes, there is always sufficient room.
5649            fidl::encoding::encode_in_envelope_optional::<
5650                fidl::encoding::Vector<
5651                    fidl_fuchsia_hardware_audio_signalprocessing__common::Element,
5652                    64,
5653                >,
5654                D,
5655            >(
5656                self.signal_processing_elements.as_ref().map(
5657                    <fidl::encoding::Vector<
5658                        fidl_fuchsia_hardware_audio_signalprocessing__common::Element,
5659                        64,
5660                    > as fidl::encoding::ValueTypeMarker>::borrow,
5661                ),
5662                encoder,
5663                offset + cur_offset,
5664                depth,
5665            )?;
5666
5667            _prev_end_offset = cur_offset + envelope_size;
5668            if 13 > max_ordinal {
5669                return Ok(());
5670            }
5671
5672            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5673            // are envelope_size bytes.
5674            let cur_offset: usize = (13 - 1) * envelope_size;
5675
5676            // Zero reserved fields.
5677            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5678
5679            // Safety:
5680            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5681            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5682            //   envelope_size bytes, there is always sufficient room.
5683            fidl::encoding::encode_in_envelope_optional::<
5684                fidl::encoding::Vector<
5685                    fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
5686                    64,
5687                >,
5688                D,
5689            >(
5690                self.signal_processing_topologies.as_ref().map(
5691                    <fidl::encoding::Vector<
5692                        fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
5693                        64,
5694                    > as fidl::encoding::ValueTypeMarker>::borrow,
5695                ),
5696                encoder,
5697                offset + cur_offset,
5698                depth,
5699            )?;
5700
5701            _prev_end_offset = cur_offset + envelope_size;
5702
5703            Ok(())
5704        }
5705    }
5706
5707    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Info {
5708        #[inline(always)]
5709        fn new_empty() -> Self {
5710            Self::default()
5711        }
5712
5713        unsafe fn decode(
5714            &mut self,
5715            decoder: &mut fidl::encoding::Decoder<'_, D>,
5716            offset: usize,
5717            mut depth: fidl::encoding::Depth,
5718        ) -> fidl::Result<()> {
5719            decoder.debug_check_bounds::<Self>(offset);
5720            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5721                None => return Err(fidl::Error::NotNullable),
5722                Some(len) => len,
5723            };
5724            // Calling decoder.out_of_line_offset(0) is not allowed.
5725            if len == 0 {
5726                return Ok(());
5727            };
5728            depth.increment()?;
5729            let envelope_size = 8;
5730            let bytes_len = len * envelope_size;
5731            let offset = decoder.out_of_line_offset(bytes_len)?;
5732            // Decode the envelope for each type.
5733            let mut _next_ordinal_to_read = 0;
5734            let mut next_offset = offset;
5735            let end_offset = offset + bytes_len;
5736            _next_ordinal_to_read += 1;
5737            if next_offset >= end_offset {
5738                return Ok(());
5739            }
5740
5741            // Decode unknown envelopes for gaps in ordinals.
5742            while _next_ordinal_to_read < 1 {
5743                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5744                _next_ordinal_to_read += 1;
5745                next_offset += envelope_size;
5746            }
5747
5748            let next_out_of_line = decoder.next_out_of_line();
5749            let handles_before = decoder.remaining_handles();
5750            if let Some((inlined, num_bytes, num_handles)) =
5751                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5752            {
5753                let member_inline_size =
5754                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5755                if inlined != (member_inline_size <= 4) {
5756                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5757                }
5758                let inner_offset;
5759                let mut inner_depth = depth.clone();
5760                if inlined {
5761                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5762                    inner_offset = next_offset;
5763                } else {
5764                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5765                    inner_depth.increment()?;
5766                }
5767                let val_ref = self.token_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5768                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5769                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5770                {
5771                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5772                }
5773                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5774                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5775                }
5776            }
5777
5778            next_offset += envelope_size;
5779            _next_ordinal_to_read += 1;
5780            if next_offset >= end_offset {
5781                return Ok(());
5782            }
5783
5784            // Decode unknown envelopes for gaps in ordinals.
5785            while _next_ordinal_to_read < 2 {
5786                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5787                _next_ordinal_to_read += 1;
5788                next_offset += envelope_size;
5789            }
5790
5791            let next_out_of_line = decoder.next_out_of_line();
5792            let handles_before = decoder.remaining_handles();
5793            if let Some((inlined, num_bytes, num_handles)) =
5794                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5795            {
5796                let member_inline_size =
5797                    <DeviceType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5798                if inlined != (member_inline_size <= 4) {
5799                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5800                }
5801                let inner_offset;
5802                let mut inner_depth = depth.clone();
5803                if inlined {
5804                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5805                    inner_offset = next_offset;
5806                } else {
5807                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5808                    inner_depth.increment()?;
5809                }
5810                let val_ref =
5811                    self.device_type.get_or_insert_with(|| fidl::new_empty!(DeviceType, D));
5812                fidl::decode!(DeviceType, D, val_ref, decoder, inner_offset, inner_depth)?;
5813                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5814                {
5815                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5816                }
5817                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5818                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5819                }
5820            }
5821
5822            next_offset += envelope_size;
5823            _next_ordinal_to_read += 1;
5824            if next_offset >= end_offset {
5825                return Ok(());
5826            }
5827
5828            // Decode unknown envelopes for gaps in ordinals.
5829            while _next_ordinal_to_read < 3 {
5830                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5831                _next_ordinal_to_read += 1;
5832                next_offset += envelope_size;
5833            }
5834
5835            let next_out_of_line = decoder.next_out_of_line();
5836            let handles_before = decoder.remaining_handles();
5837            if let Some((inlined, num_bytes, num_handles)) =
5838                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5839            {
5840                let member_inline_size =
5841                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5842                        decoder.context,
5843                    );
5844                if inlined != (member_inline_size <= 4) {
5845                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5846                }
5847                let inner_offset;
5848                let mut inner_depth = depth.clone();
5849                if inlined {
5850                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5851                    inner_offset = next_offset;
5852                } else {
5853                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5854                    inner_depth.increment()?;
5855                }
5856                let val_ref = self
5857                    .device_name
5858                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
5859                fidl::decode!(
5860                    fidl::encoding::BoundedString<256>,
5861                    D,
5862                    val_ref,
5863                    decoder,
5864                    inner_offset,
5865                    inner_depth
5866                )?;
5867                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5868                {
5869                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5870                }
5871                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5872                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5873                }
5874            }
5875
5876            next_offset += envelope_size;
5877            _next_ordinal_to_read += 1;
5878            if next_offset >= end_offset {
5879                return Ok(());
5880            }
5881
5882            // Decode unknown envelopes for gaps in ordinals.
5883            while _next_ordinal_to_read < 4 {
5884                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5885                _next_ordinal_to_read += 1;
5886                next_offset += envelope_size;
5887            }
5888
5889            let next_out_of_line = decoder.next_out_of_line();
5890            let handles_before = decoder.remaining_handles();
5891            if let Some((inlined, num_bytes, num_handles)) =
5892                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5893            {
5894                let member_inline_size =
5895                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5896                        decoder.context,
5897                    );
5898                if inlined != (member_inline_size <= 4) {
5899                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5900                }
5901                let inner_offset;
5902                let mut inner_depth = depth.clone();
5903                if inlined {
5904                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5905                    inner_offset = next_offset;
5906                } else {
5907                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5908                    inner_depth.increment()?;
5909                }
5910                let val_ref = self
5911                    .manufacturer
5912                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
5913                fidl::decode!(
5914                    fidl::encoding::BoundedString<256>,
5915                    D,
5916                    val_ref,
5917                    decoder,
5918                    inner_offset,
5919                    inner_depth
5920                )?;
5921                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5922                {
5923                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5924                }
5925                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5926                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5927                }
5928            }
5929
5930            next_offset += envelope_size;
5931            _next_ordinal_to_read += 1;
5932            if next_offset >= end_offset {
5933                return Ok(());
5934            }
5935
5936            // Decode unknown envelopes for gaps in ordinals.
5937            while _next_ordinal_to_read < 5 {
5938                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5939                _next_ordinal_to_read += 1;
5940                next_offset += envelope_size;
5941            }
5942
5943            let next_out_of_line = decoder.next_out_of_line();
5944            let handles_before = decoder.remaining_handles();
5945            if let Some((inlined, num_bytes, num_handles)) =
5946                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5947            {
5948                let member_inline_size =
5949                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5950                        decoder.context,
5951                    );
5952                if inlined != (member_inline_size <= 4) {
5953                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5954                }
5955                let inner_offset;
5956                let mut inner_depth = depth.clone();
5957                if inlined {
5958                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5959                    inner_offset = next_offset;
5960                } else {
5961                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5962                    inner_depth.increment()?;
5963                }
5964                let val_ref = self
5965                    .product
5966                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
5967                fidl::decode!(
5968                    fidl::encoding::BoundedString<256>,
5969                    D,
5970                    val_ref,
5971                    decoder,
5972                    inner_offset,
5973                    inner_depth
5974                )?;
5975                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5976                {
5977                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5978                }
5979                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5980                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5981                }
5982            }
5983
5984            next_offset += envelope_size;
5985            _next_ordinal_to_read += 1;
5986            if next_offset >= end_offset {
5987                return Ok(());
5988            }
5989
5990            // Decode unknown envelopes for gaps in ordinals.
5991            while _next_ordinal_to_read < 6 {
5992                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5993                _next_ordinal_to_read += 1;
5994                next_offset += envelope_size;
5995            }
5996
5997            let next_out_of_line = decoder.next_out_of_line();
5998            let handles_before = decoder.remaining_handles();
5999            if let Some((inlined, num_bytes, num_handles)) =
6000                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6001            {
6002                let member_inline_size =
6003                    <fidl::encoding::Array<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
6004                        decoder.context,
6005                    );
6006                if inlined != (member_inline_size <= 4) {
6007                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6008                }
6009                let inner_offset;
6010                let mut inner_depth = depth.clone();
6011                if inlined {
6012                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6013                    inner_offset = next_offset;
6014                } else {
6015                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6016                    inner_depth.increment()?;
6017                }
6018                let val_ref = self
6019                    .unique_instance_id
6020                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 16>, D));
6021                fidl::decode!(fidl::encoding::Array<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
6022                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6023                {
6024                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6025                }
6026                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6027                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6028                }
6029            }
6030
6031            next_offset += envelope_size;
6032            _next_ordinal_to_read += 1;
6033            if next_offset >= end_offset {
6034                return Ok(());
6035            }
6036
6037            // Decode unknown envelopes for gaps in ordinals.
6038            while _next_ordinal_to_read < 7 {
6039                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6040                _next_ordinal_to_read += 1;
6041                next_offset += envelope_size;
6042            }
6043
6044            let next_out_of_line = decoder.next_out_of_line();
6045            let handles_before = decoder.remaining_handles();
6046            if let Some((inlined, num_bytes, num_handles)) =
6047                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6048            {
6049                let member_inline_size =
6050                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6051                if inlined != (member_inline_size <= 4) {
6052                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6053                }
6054                let inner_offset;
6055                let mut inner_depth = depth.clone();
6056                if inlined {
6057                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6058                    inner_offset = next_offset;
6059                } else {
6060                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6061                    inner_depth.increment()?;
6062                }
6063                let val_ref = self.is_input.get_or_insert_with(|| fidl::new_empty!(bool, D));
6064                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6065                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6066                {
6067                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6068                }
6069                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6070                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6071                }
6072            }
6073
6074            next_offset += envelope_size;
6075            _next_ordinal_to_read += 1;
6076            if next_offset >= end_offset {
6077                return Ok(());
6078            }
6079
6080            // Decode unknown envelopes for gaps in ordinals.
6081            while _next_ordinal_to_read < 8 {
6082                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6083                _next_ordinal_to_read += 1;
6084                next_offset += envelope_size;
6085            }
6086
6087            let next_out_of_line = decoder.next_out_of_line();
6088            let handles_before = decoder.remaining_handles();
6089            if let Some((inlined, num_bytes, num_handles)) =
6090                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6091            {
6092                let member_inline_size = <fidl::encoding::Vector<ElementRingBufferFormatSet, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6093                if inlined != (member_inline_size <= 4) {
6094                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6095                }
6096                let inner_offset;
6097                let mut inner_depth = depth.clone();
6098                if inlined {
6099                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6100                    inner_offset = next_offset;
6101                } else {
6102                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6103                    inner_depth.increment()?;
6104                }
6105                let val_ref = self.ring_buffer_format_sets.get_or_insert_with(
6106                    || fidl::new_empty!(fidl::encoding::Vector<ElementRingBufferFormatSet, 64>, D),
6107                );
6108                fidl::decode!(fidl::encoding::Vector<ElementRingBufferFormatSet, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6109                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6110                {
6111                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6112                }
6113                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6114                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6115                }
6116            }
6117
6118            next_offset += envelope_size;
6119            _next_ordinal_to_read += 1;
6120            if next_offset >= end_offset {
6121                return Ok(());
6122            }
6123
6124            // Decode unknown envelopes for gaps in ordinals.
6125            while _next_ordinal_to_read < 9 {
6126                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6127                _next_ordinal_to_read += 1;
6128                next_offset += envelope_size;
6129            }
6130
6131            let next_out_of_line = decoder.next_out_of_line();
6132            let handles_before = decoder.remaining_handles();
6133            if let Some((inlined, num_bytes, num_handles)) =
6134                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6135            {
6136                let member_inline_size = <fidl::encoding::Vector<ElementDaiFormatSet, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6137                if inlined != (member_inline_size <= 4) {
6138                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6139                }
6140                let inner_offset;
6141                let mut inner_depth = depth.clone();
6142                if inlined {
6143                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6144                    inner_offset = next_offset;
6145                } else {
6146                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6147                    inner_depth.increment()?;
6148                }
6149                let val_ref = self.dai_format_sets.get_or_insert_with(
6150                    || fidl::new_empty!(fidl::encoding::Vector<ElementDaiFormatSet, 64>, D),
6151                );
6152                fidl::decode!(fidl::encoding::Vector<ElementDaiFormatSet, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6153                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6154                {
6155                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6156                }
6157                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6158                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6159                }
6160            }
6161
6162            next_offset += envelope_size;
6163            _next_ordinal_to_read += 1;
6164            if next_offset >= end_offset {
6165                return Ok(());
6166            }
6167
6168            // Decode unknown envelopes for gaps in ordinals.
6169            while _next_ordinal_to_read < 10 {
6170                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6171                _next_ordinal_to_read += 1;
6172                next_offset += envelope_size;
6173            }
6174
6175            let next_out_of_line = decoder.next_out_of_line();
6176            let handles_before = decoder.remaining_handles();
6177            if let Some((inlined, num_bytes, num_handles)) =
6178                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6179            {
6180                let member_inline_size =
6181                    <PlugDetectCapabilities as fidl::encoding::TypeMarker>::inline_size(
6182                        decoder.context,
6183                    );
6184                if inlined != (member_inline_size <= 4) {
6185                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6186                }
6187                let inner_offset;
6188                let mut inner_depth = depth.clone();
6189                if inlined {
6190                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6191                    inner_offset = next_offset;
6192                } else {
6193                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6194                    inner_depth.increment()?;
6195                }
6196                let val_ref = self
6197                    .plug_detect_caps
6198                    .get_or_insert_with(|| fidl::new_empty!(PlugDetectCapabilities, D));
6199                fidl::decode!(
6200                    PlugDetectCapabilities,
6201                    D,
6202                    val_ref,
6203                    decoder,
6204                    inner_offset,
6205                    inner_depth
6206                )?;
6207                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6208                {
6209                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6210                }
6211                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6212                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6213                }
6214            }
6215
6216            next_offset += envelope_size;
6217            _next_ordinal_to_read += 1;
6218            if next_offset >= end_offset {
6219                return Ok(());
6220            }
6221
6222            // Decode unknown envelopes for gaps in ordinals.
6223            while _next_ordinal_to_read < 11 {
6224                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6225                _next_ordinal_to_read += 1;
6226                next_offset += envelope_size;
6227            }
6228
6229            let next_out_of_line = decoder.next_out_of_line();
6230            let handles_before = decoder.remaining_handles();
6231            if let Some((inlined, num_bytes, num_handles)) =
6232                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6233            {
6234                let member_inline_size =
6235                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6236                if inlined != (member_inline_size <= 4) {
6237                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6238                }
6239                let inner_offset;
6240                let mut inner_depth = depth.clone();
6241                if inlined {
6242                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6243                    inner_offset = next_offset;
6244                } else {
6245                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6246                    inner_depth.increment()?;
6247                }
6248                let val_ref = self.clock_domain.get_or_insert_with(|| fidl::new_empty!(u32, D));
6249                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6250                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6251                {
6252                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6253                }
6254                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6255                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6256                }
6257            }
6258
6259            next_offset += envelope_size;
6260            _next_ordinal_to_read += 1;
6261            if next_offset >= end_offset {
6262                return Ok(());
6263            }
6264
6265            // Decode unknown envelopes for gaps in ordinals.
6266            while _next_ordinal_to_read < 12 {
6267                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6268                _next_ordinal_to_read += 1;
6269                next_offset += envelope_size;
6270            }
6271
6272            let next_out_of_line = decoder.next_out_of_line();
6273            let handles_before = decoder.remaining_handles();
6274            if let Some((inlined, num_bytes, num_handles)) =
6275                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6276            {
6277                let member_inline_size = <fidl::encoding::Vector<
6278                    fidl_fuchsia_hardware_audio_signalprocessing__common::Element,
6279                    64,
6280                > as fidl::encoding::TypeMarker>::inline_size(
6281                    decoder.context
6282                );
6283                if inlined != (member_inline_size <= 4) {
6284                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6285                }
6286                let inner_offset;
6287                let mut inner_depth = depth.clone();
6288                if inlined {
6289                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6290                    inner_offset = next_offset;
6291                } else {
6292                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6293                    inner_depth.increment()?;
6294                }
6295                let val_ref =
6296                self.signal_processing_elements.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Element, 64>, D));
6297                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Element, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6298                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6299                {
6300                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6301                }
6302                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6303                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6304                }
6305            }
6306
6307            next_offset += envelope_size;
6308            _next_ordinal_to_read += 1;
6309            if next_offset >= end_offset {
6310                return Ok(());
6311            }
6312
6313            // Decode unknown envelopes for gaps in ordinals.
6314            while _next_ordinal_to_read < 13 {
6315                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6316                _next_ordinal_to_read += 1;
6317                next_offset += envelope_size;
6318            }
6319
6320            let next_out_of_line = decoder.next_out_of_line();
6321            let handles_before = decoder.remaining_handles();
6322            if let Some((inlined, num_bytes, num_handles)) =
6323                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6324            {
6325                let member_inline_size = <fidl::encoding::Vector<
6326                    fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
6327                    64,
6328                > as fidl::encoding::TypeMarker>::inline_size(
6329                    decoder.context
6330                );
6331                if inlined != (member_inline_size <= 4) {
6332                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6333                }
6334                let inner_offset;
6335                let mut inner_depth = depth.clone();
6336                if inlined {
6337                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6338                    inner_offset = next_offset;
6339                } else {
6340                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6341                    inner_depth.increment()?;
6342                }
6343                let val_ref =
6344                self.signal_processing_topologies.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Topology, 64>, D));
6345                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Topology, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6346                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6347                {
6348                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6349                }
6350                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6351                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6352                }
6353            }
6354
6355            next_offset += envelope_size;
6356
6357            // Decode the remaining unknown envelopes.
6358            while next_offset < end_offset {
6359                _next_ordinal_to_read += 1;
6360                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6361                next_offset += envelope_size;
6362            }
6363
6364            Ok(())
6365        }
6366    }
6367
6368    impl ObserverWatchPlugStateResponse {
6369        #[inline(always)]
6370        fn max_ordinal_present(&self) -> u64 {
6371            if let Some(_) = self.plug_time {
6372                return 2;
6373            }
6374            if let Some(_) = self.state {
6375                return 1;
6376            }
6377            0
6378        }
6379    }
6380
6381    impl fidl::encoding::ValueTypeMarker for ObserverWatchPlugStateResponse {
6382        type Borrowed<'a> = &'a Self;
6383        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6384            value
6385        }
6386    }
6387
6388    unsafe impl fidl::encoding::TypeMarker for ObserverWatchPlugStateResponse {
6389        type Owned = Self;
6390
6391        #[inline(always)]
6392        fn inline_align(_context: fidl::encoding::Context) -> usize {
6393            8
6394        }
6395
6396        #[inline(always)]
6397        fn inline_size(_context: fidl::encoding::Context) -> usize {
6398            16
6399        }
6400    }
6401
6402    unsafe impl<D: fidl::encoding::ResourceDialect>
6403        fidl::encoding::Encode<ObserverWatchPlugStateResponse, D>
6404        for &ObserverWatchPlugStateResponse
6405    {
6406        unsafe fn encode(
6407            self,
6408            encoder: &mut fidl::encoding::Encoder<'_, D>,
6409            offset: usize,
6410            mut depth: fidl::encoding::Depth,
6411        ) -> fidl::Result<()> {
6412            encoder.debug_check_bounds::<ObserverWatchPlugStateResponse>(offset);
6413            // Vector header
6414            let max_ordinal: u64 = self.max_ordinal_present();
6415            encoder.write_num(max_ordinal, offset);
6416            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6417            // Calling encoder.out_of_line_offset(0) is not allowed.
6418            if max_ordinal == 0 {
6419                return Ok(());
6420            }
6421            depth.increment()?;
6422            let envelope_size = 8;
6423            let bytes_len = max_ordinal as usize * envelope_size;
6424            #[allow(unused_variables)]
6425            let offset = encoder.out_of_line_offset(bytes_len);
6426            let mut _prev_end_offset: usize = 0;
6427            if 1 > max_ordinal {
6428                return Ok(());
6429            }
6430
6431            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6432            // are envelope_size bytes.
6433            let cur_offset: usize = (1 - 1) * envelope_size;
6434
6435            // Zero reserved fields.
6436            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6437
6438            // Safety:
6439            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6440            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6441            //   envelope_size bytes, there is always sufficient room.
6442            fidl::encoding::encode_in_envelope_optional::<PlugState, D>(
6443                self.state.as_ref().map(<PlugState as fidl::encoding::ValueTypeMarker>::borrow),
6444                encoder,
6445                offset + cur_offset,
6446                depth,
6447            )?;
6448
6449            _prev_end_offset = cur_offset + envelope_size;
6450            if 2 > max_ordinal {
6451                return Ok(());
6452            }
6453
6454            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6455            // are envelope_size bytes.
6456            let cur_offset: usize = (2 - 1) * envelope_size;
6457
6458            // Zero reserved fields.
6459            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6460
6461            // Safety:
6462            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6463            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6464            //   envelope_size bytes, there is always sufficient room.
6465            fidl::encoding::encode_in_envelope_optional::<i64, D>(
6466                self.plug_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6467                encoder,
6468                offset + cur_offset,
6469                depth,
6470            )?;
6471
6472            _prev_end_offset = cur_offset + envelope_size;
6473
6474            Ok(())
6475        }
6476    }
6477
6478    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6479        for ObserverWatchPlugStateResponse
6480    {
6481        #[inline(always)]
6482        fn new_empty() -> Self {
6483            Self::default()
6484        }
6485
6486        unsafe fn decode(
6487            &mut self,
6488            decoder: &mut fidl::encoding::Decoder<'_, D>,
6489            offset: usize,
6490            mut depth: fidl::encoding::Depth,
6491        ) -> fidl::Result<()> {
6492            decoder.debug_check_bounds::<Self>(offset);
6493            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6494                None => return Err(fidl::Error::NotNullable),
6495                Some(len) => len,
6496            };
6497            // Calling decoder.out_of_line_offset(0) is not allowed.
6498            if len == 0 {
6499                return Ok(());
6500            };
6501            depth.increment()?;
6502            let envelope_size = 8;
6503            let bytes_len = len * envelope_size;
6504            let offset = decoder.out_of_line_offset(bytes_len)?;
6505            // Decode the envelope for each type.
6506            let mut _next_ordinal_to_read = 0;
6507            let mut next_offset = offset;
6508            let end_offset = offset + bytes_len;
6509            _next_ordinal_to_read += 1;
6510            if next_offset >= end_offset {
6511                return Ok(());
6512            }
6513
6514            // Decode unknown envelopes for gaps in ordinals.
6515            while _next_ordinal_to_read < 1 {
6516                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6517                _next_ordinal_to_read += 1;
6518                next_offset += envelope_size;
6519            }
6520
6521            let next_out_of_line = decoder.next_out_of_line();
6522            let handles_before = decoder.remaining_handles();
6523            if let Some((inlined, num_bytes, num_handles)) =
6524                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6525            {
6526                let member_inline_size =
6527                    <PlugState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6528                if inlined != (member_inline_size <= 4) {
6529                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6530                }
6531                let inner_offset;
6532                let mut inner_depth = depth.clone();
6533                if inlined {
6534                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6535                    inner_offset = next_offset;
6536                } else {
6537                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6538                    inner_depth.increment()?;
6539                }
6540                let val_ref = self.state.get_or_insert_with(|| fidl::new_empty!(PlugState, D));
6541                fidl::decode!(PlugState, D, val_ref, decoder, inner_offset, inner_depth)?;
6542                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6543                {
6544                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6545                }
6546                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6547                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6548                }
6549            }
6550
6551            next_offset += envelope_size;
6552            _next_ordinal_to_read += 1;
6553            if next_offset >= end_offset {
6554                return Ok(());
6555            }
6556
6557            // Decode unknown envelopes for gaps in ordinals.
6558            while _next_ordinal_to_read < 2 {
6559                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6560                _next_ordinal_to_read += 1;
6561                next_offset += envelope_size;
6562            }
6563
6564            let next_out_of_line = decoder.next_out_of_line();
6565            let handles_before = decoder.remaining_handles();
6566            if let Some((inlined, num_bytes, num_handles)) =
6567                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6568            {
6569                let member_inline_size =
6570                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6571                if inlined != (member_inline_size <= 4) {
6572                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6573                }
6574                let inner_offset;
6575                let mut inner_depth = depth.clone();
6576                if inlined {
6577                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6578                    inner_offset = next_offset;
6579                } else {
6580                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6581                    inner_depth.increment()?;
6582                }
6583                let val_ref = self.plug_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
6584                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6585                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6586                {
6587                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6588                }
6589                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6590                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6591                }
6592            }
6593
6594            next_offset += envelope_size;
6595
6596            // Decode the remaining unknown envelopes.
6597            while next_offset < end_offset {
6598                _next_ordinal_to_read += 1;
6599                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6600                next_offset += envelope_size;
6601            }
6602
6603            Ok(())
6604        }
6605    }
6606
6607    impl PcmFormatSet {
6608        #[inline(always)]
6609        fn max_ordinal_present(&self) -> u64 {
6610            if let Some(_) = self.frame_rates {
6611                return 3;
6612            }
6613            if let Some(_) = self.sample_types {
6614                return 2;
6615            }
6616            if let Some(_) = self.channel_sets {
6617                return 1;
6618            }
6619            0
6620        }
6621    }
6622
6623    impl fidl::encoding::ValueTypeMarker for PcmFormatSet {
6624        type Borrowed<'a> = &'a Self;
6625        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6626            value
6627        }
6628    }
6629
6630    unsafe impl fidl::encoding::TypeMarker for PcmFormatSet {
6631        type Owned = Self;
6632
6633        #[inline(always)]
6634        fn inline_align(_context: fidl::encoding::Context) -> usize {
6635            8
6636        }
6637
6638        #[inline(always)]
6639        fn inline_size(_context: fidl::encoding::Context) -> usize {
6640            16
6641        }
6642    }
6643
6644    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PcmFormatSet, D>
6645        for &PcmFormatSet
6646    {
6647        unsafe fn encode(
6648            self,
6649            encoder: &mut fidl::encoding::Encoder<'_, D>,
6650            offset: usize,
6651            mut depth: fidl::encoding::Depth,
6652        ) -> fidl::Result<()> {
6653            encoder.debug_check_bounds::<PcmFormatSet>(offset);
6654            // Vector header
6655            let max_ordinal: u64 = self.max_ordinal_present();
6656            encoder.write_num(max_ordinal, offset);
6657            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6658            // Calling encoder.out_of_line_offset(0) is not allowed.
6659            if max_ordinal == 0 {
6660                return Ok(());
6661            }
6662            depth.increment()?;
6663            let envelope_size = 8;
6664            let bytes_len = max_ordinal as usize * envelope_size;
6665            #[allow(unused_variables)]
6666            let offset = encoder.out_of_line_offset(bytes_len);
6667            let mut _prev_end_offset: usize = 0;
6668            if 1 > max_ordinal {
6669                return Ok(());
6670            }
6671
6672            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6673            // are envelope_size bytes.
6674            let cur_offset: usize = (1 - 1) * envelope_size;
6675
6676            // Zero reserved fields.
6677            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6678
6679            // Safety:
6680            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6681            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6682            //   envelope_size bytes, there is always sufficient room.
6683            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ChannelSet, 64>, D>(
6684            self.channel_sets.as_ref().map(<fidl::encoding::Vector<ChannelSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
6685            encoder, offset + cur_offset, depth
6686        )?;
6687
6688            _prev_end_offset = cur_offset + envelope_size;
6689            if 2 > max_ordinal {
6690                return Ok(());
6691            }
6692
6693            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6694            // are envelope_size bytes.
6695            let cur_offset: usize = (2 - 1) * envelope_size;
6696
6697            // Zero reserved fields.
6698            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6699
6700            // Safety:
6701            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6702            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6703            //   envelope_size bytes, there is always sufficient room.
6704            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32>, D>(
6705            self.sample_types.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32> as fidl::encoding::ValueTypeMarker>::borrow),
6706            encoder, offset + cur_offset, depth
6707        )?;
6708
6709            _prev_end_offset = cur_offset + envelope_size;
6710            if 3 > max_ordinal {
6711                return Ok(());
6712            }
6713
6714            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6715            // are envelope_size bytes.
6716            let cur_offset: usize = (3 - 1) * envelope_size;
6717
6718            // Zero reserved fields.
6719            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6720
6721            // Safety:
6722            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6723            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6724            //   envelope_size bytes, there is always sufficient room.
6725            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u32, 64>, D>(
6726                self.frame_rates.as_ref().map(
6727                    <fidl::encoding::Vector<u32, 64> as fidl::encoding::ValueTypeMarker>::borrow,
6728                ),
6729                encoder,
6730                offset + cur_offset,
6731                depth,
6732            )?;
6733
6734            _prev_end_offset = cur_offset + envelope_size;
6735
6736            Ok(())
6737        }
6738    }
6739
6740    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PcmFormatSet {
6741        #[inline(always)]
6742        fn new_empty() -> Self {
6743            Self::default()
6744        }
6745
6746        unsafe fn decode(
6747            &mut self,
6748            decoder: &mut fidl::encoding::Decoder<'_, D>,
6749            offset: usize,
6750            mut depth: fidl::encoding::Depth,
6751        ) -> fidl::Result<()> {
6752            decoder.debug_check_bounds::<Self>(offset);
6753            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6754                None => return Err(fidl::Error::NotNullable),
6755                Some(len) => len,
6756            };
6757            // Calling decoder.out_of_line_offset(0) is not allowed.
6758            if len == 0 {
6759                return Ok(());
6760            };
6761            depth.increment()?;
6762            let envelope_size = 8;
6763            let bytes_len = len * envelope_size;
6764            let offset = decoder.out_of_line_offset(bytes_len)?;
6765            // Decode the envelope for each type.
6766            let mut _next_ordinal_to_read = 0;
6767            let mut next_offset = offset;
6768            let end_offset = offset + bytes_len;
6769            _next_ordinal_to_read += 1;
6770            if next_offset >= end_offset {
6771                return Ok(());
6772            }
6773
6774            // Decode unknown envelopes for gaps in ordinals.
6775            while _next_ordinal_to_read < 1 {
6776                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6777                _next_ordinal_to_read += 1;
6778                next_offset += envelope_size;
6779            }
6780
6781            let next_out_of_line = decoder.next_out_of_line();
6782            let handles_before = decoder.remaining_handles();
6783            if let Some((inlined, num_bytes, num_handles)) =
6784                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6785            {
6786                let member_inline_size = <fidl::encoding::Vector<ChannelSet, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6787                if inlined != (member_inline_size <= 4) {
6788                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6789                }
6790                let inner_offset;
6791                let mut inner_depth = depth.clone();
6792                if inlined {
6793                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6794                    inner_offset = next_offset;
6795                } else {
6796                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6797                    inner_depth.increment()?;
6798                }
6799                let val_ref = self.channel_sets.get_or_insert_with(
6800                    || fidl::new_empty!(fidl::encoding::Vector<ChannelSet, 64>, D),
6801                );
6802                fidl::decode!(fidl::encoding::Vector<ChannelSet, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6803                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6804                {
6805                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6806                }
6807                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6808                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6809                }
6810            }
6811
6812            next_offset += envelope_size;
6813            _next_ordinal_to_read += 1;
6814            if next_offset >= end_offset {
6815                return Ok(());
6816            }
6817
6818            // Decode unknown envelopes for gaps in ordinals.
6819            while _next_ordinal_to_read < 2 {
6820                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6821                _next_ordinal_to_read += 1;
6822                next_offset += envelope_size;
6823            }
6824
6825            let next_out_of_line = decoder.next_out_of_line();
6826            let handles_before = decoder.remaining_handles();
6827            if let Some((inlined, num_bytes, num_handles)) =
6828                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6829            {
6830                let member_inline_size = <fidl::encoding::Vector<
6831                    fidl_fuchsia_audio__common::SampleType,
6832                    32,
6833                > as fidl::encoding::TypeMarker>::inline_size(
6834                    decoder.context
6835                );
6836                if inlined != (member_inline_size <= 4) {
6837                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6838                }
6839                let inner_offset;
6840                let mut inner_depth = depth.clone();
6841                if inlined {
6842                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6843                    inner_offset = next_offset;
6844                } else {
6845                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6846                    inner_depth.increment()?;
6847                }
6848                let val_ref =
6849                self.sample_types.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32>, D));
6850                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
6851                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6852                {
6853                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6854                }
6855                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6856                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6857                }
6858            }
6859
6860            next_offset += envelope_size;
6861            _next_ordinal_to_read += 1;
6862            if next_offset >= end_offset {
6863                return Ok(());
6864            }
6865
6866            // Decode unknown envelopes for gaps in ordinals.
6867            while _next_ordinal_to_read < 3 {
6868                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6869                _next_ordinal_to_read += 1;
6870                next_offset += envelope_size;
6871            }
6872
6873            let next_out_of_line = decoder.next_out_of_line();
6874            let handles_before = decoder.remaining_handles();
6875            if let Some((inlined, num_bytes, num_handles)) =
6876                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6877            {
6878                let member_inline_size =
6879                    <fidl::encoding::Vector<u32, 64> as fidl::encoding::TypeMarker>::inline_size(
6880                        decoder.context,
6881                    );
6882                if inlined != (member_inline_size <= 4) {
6883                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6884                }
6885                let inner_offset;
6886                let mut inner_depth = depth.clone();
6887                if inlined {
6888                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6889                    inner_offset = next_offset;
6890                } else {
6891                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6892                    inner_depth.increment()?;
6893                }
6894                let val_ref = self
6895                    .frame_rates
6896                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u32, 64>, D));
6897                fidl::decode!(fidl::encoding::Vector<u32, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6898                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6899                {
6900                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6901                }
6902                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6903                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6904                }
6905            }
6906
6907            next_offset += envelope_size;
6908
6909            // Decode the remaining unknown envelopes.
6910            while next_offset < end_offset {
6911                _next_ordinal_to_read += 1;
6912                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6913                next_offset += envelope_size;
6914            }
6915
6916            Ok(())
6917        }
6918    }
6919
6920    impl ProviderAddDeviceResponse {
6921        #[inline(always)]
6922        fn max_ordinal_present(&self) -> u64 {
6923            0
6924        }
6925    }
6926
6927    impl fidl::encoding::ValueTypeMarker for ProviderAddDeviceResponse {
6928        type Borrowed<'a> = &'a Self;
6929        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6930            value
6931        }
6932    }
6933
6934    unsafe impl fidl::encoding::TypeMarker for ProviderAddDeviceResponse {
6935        type Owned = Self;
6936
6937        #[inline(always)]
6938        fn inline_align(_context: fidl::encoding::Context) -> usize {
6939            8
6940        }
6941
6942        #[inline(always)]
6943        fn inline_size(_context: fidl::encoding::Context) -> usize {
6944            16
6945        }
6946    }
6947
6948    unsafe impl<D: fidl::encoding::ResourceDialect>
6949        fidl::encoding::Encode<ProviderAddDeviceResponse, D> for &ProviderAddDeviceResponse
6950    {
6951        unsafe fn encode(
6952            self,
6953            encoder: &mut fidl::encoding::Encoder<'_, D>,
6954            offset: usize,
6955            mut depth: fidl::encoding::Depth,
6956        ) -> fidl::Result<()> {
6957            encoder.debug_check_bounds::<ProviderAddDeviceResponse>(offset);
6958            // Vector header
6959            let max_ordinal: u64 = self.max_ordinal_present();
6960            encoder.write_num(max_ordinal, offset);
6961            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6962            // Calling encoder.out_of_line_offset(0) is not allowed.
6963            if max_ordinal == 0 {
6964                return Ok(());
6965            }
6966            depth.increment()?;
6967            let envelope_size = 8;
6968            let bytes_len = max_ordinal as usize * envelope_size;
6969            #[allow(unused_variables)]
6970            let offset = encoder.out_of_line_offset(bytes_len);
6971            let mut _prev_end_offset: usize = 0;
6972
6973            Ok(())
6974        }
6975    }
6976
6977    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6978        for ProviderAddDeviceResponse
6979    {
6980        #[inline(always)]
6981        fn new_empty() -> Self {
6982            Self::default()
6983        }
6984
6985        unsafe fn decode(
6986            &mut self,
6987            decoder: &mut fidl::encoding::Decoder<'_, D>,
6988            offset: usize,
6989            mut depth: fidl::encoding::Depth,
6990        ) -> fidl::Result<()> {
6991            decoder.debug_check_bounds::<Self>(offset);
6992            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6993                None => return Err(fidl::Error::NotNullable),
6994                Some(len) => len,
6995            };
6996            // Calling decoder.out_of_line_offset(0) is not allowed.
6997            if len == 0 {
6998                return Ok(());
6999            };
7000            depth.increment()?;
7001            let envelope_size = 8;
7002            let bytes_len = len * envelope_size;
7003            let offset = decoder.out_of_line_offset(bytes_len)?;
7004            // Decode the envelope for each type.
7005            let mut _next_ordinal_to_read = 0;
7006            let mut next_offset = offset;
7007            let end_offset = offset + bytes_len;
7008
7009            // Decode the remaining unknown envelopes.
7010            while next_offset < end_offset {
7011                _next_ordinal_to_read += 1;
7012                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7013                next_offset += envelope_size;
7014            }
7015
7016            Ok(())
7017        }
7018    }
7019
7020    impl RegistryCreateObserverResponse {
7021        #[inline(always)]
7022        fn max_ordinal_present(&self) -> u64 {
7023            0
7024        }
7025    }
7026
7027    impl fidl::encoding::ValueTypeMarker for RegistryCreateObserverResponse {
7028        type Borrowed<'a> = &'a Self;
7029        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7030            value
7031        }
7032    }
7033
7034    unsafe impl fidl::encoding::TypeMarker for RegistryCreateObserverResponse {
7035        type Owned = Self;
7036
7037        #[inline(always)]
7038        fn inline_align(_context: fidl::encoding::Context) -> usize {
7039            8
7040        }
7041
7042        #[inline(always)]
7043        fn inline_size(_context: fidl::encoding::Context) -> usize {
7044            16
7045        }
7046    }
7047
7048    unsafe impl<D: fidl::encoding::ResourceDialect>
7049        fidl::encoding::Encode<RegistryCreateObserverResponse, D>
7050        for &RegistryCreateObserverResponse
7051    {
7052        unsafe fn encode(
7053            self,
7054            encoder: &mut fidl::encoding::Encoder<'_, D>,
7055            offset: usize,
7056            mut depth: fidl::encoding::Depth,
7057        ) -> fidl::Result<()> {
7058            encoder.debug_check_bounds::<RegistryCreateObserverResponse>(offset);
7059            // Vector header
7060            let max_ordinal: u64 = self.max_ordinal_present();
7061            encoder.write_num(max_ordinal, offset);
7062            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7063            // Calling encoder.out_of_line_offset(0) is not allowed.
7064            if max_ordinal == 0 {
7065                return Ok(());
7066            }
7067            depth.increment()?;
7068            let envelope_size = 8;
7069            let bytes_len = max_ordinal as usize * envelope_size;
7070            #[allow(unused_variables)]
7071            let offset = encoder.out_of_line_offset(bytes_len);
7072            let mut _prev_end_offset: usize = 0;
7073
7074            Ok(())
7075        }
7076    }
7077
7078    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7079        for RegistryCreateObserverResponse
7080    {
7081        #[inline(always)]
7082        fn new_empty() -> Self {
7083            Self::default()
7084        }
7085
7086        unsafe fn decode(
7087            &mut self,
7088            decoder: &mut fidl::encoding::Decoder<'_, D>,
7089            offset: usize,
7090            mut depth: fidl::encoding::Depth,
7091        ) -> fidl::Result<()> {
7092            decoder.debug_check_bounds::<Self>(offset);
7093            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7094                None => return Err(fidl::Error::NotNullable),
7095                Some(len) => len,
7096            };
7097            // Calling decoder.out_of_line_offset(0) is not allowed.
7098            if len == 0 {
7099                return Ok(());
7100            };
7101            depth.increment()?;
7102            let envelope_size = 8;
7103            let bytes_len = len * envelope_size;
7104            let offset = decoder.out_of_line_offset(bytes_len)?;
7105            // Decode the envelope for each type.
7106            let mut _next_ordinal_to_read = 0;
7107            let mut next_offset = offset;
7108            let end_offset = offset + bytes_len;
7109
7110            // Decode the remaining unknown envelopes.
7111            while next_offset < end_offset {
7112                _next_ordinal_to_read += 1;
7113                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7114                next_offset += envelope_size;
7115            }
7116
7117            Ok(())
7118        }
7119    }
7120
7121    impl RegistryWatchDeviceRemovedResponse {
7122        #[inline(always)]
7123        fn max_ordinal_present(&self) -> u64 {
7124            if let Some(_) = self.token_id {
7125                return 1;
7126            }
7127            0
7128        }
7129    }
7130
7131    impl fidl::encoding::ValueTypeMarker for RegistryWatchDeviceRemovedResponse {
7132        type Borrowed<'a> = &'a Self;
7133        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7134            value
7135        }
7136    }
7137
7138    unsafe impl fidl::encoding::TypeMarker for RegistryWatchDeviceRemovedResponse {
7139        type Owned = Self;
7140
7141        #[inline(always)]
7142        fn inline_align(_context: fidl::encoding::Context) -> usize {
7143            8
7144        }
7145
7146        #[inline(always)]
7147        fn inline_size(_context: fidl::encoding::Context) -> usize {
7148            16
7149        }
7150    }
7151
7152    unsafe impl<D: fidl::encoding::ResourceDialect>
7153        fidl::encoding::Encode<RegistryWatchDeviceRemovedResponse, D>
7154        for &RegistryWatchDeviceRemovedResponse
7155    {
7156        unsafe fn encode(
7157            self,
7158            encoder: &mut fidl::encoding::Encoder<'_, D>,
7159            offset: usize,
7160            mut depth: fidl::encoding::Depth,
7161        ) -> fidl::Result<()> {
7162            encoder.debug_check_bounds::<RegistryWatchDeviceRemovedResponse>(offset);
7163            // Vector header
7164            let max_ordinal: u64 = self.max_ordinal_present();
7165            encoder.write_num(max_ordinal, offset);
7166            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7167            // Calling encoder.out_of_line_offset(0) is not allowed.
7168            if max_ordinal == 0 {
7169                return Ok(());
7170            }
7171            depth.increment()?;
7172            let envelope_size = 8;
7173            let bytes_len = max_ordinal as usize * envelope_size;
7174            #[allow(unused_variables)]
7175            let offset = encoder.out_of_line_offset(bytes_len);
7176            let mut _prev_end_offset: usize = 0;
7177            if 1 > max_ordinal {
7178                return Ok(());
7179            }
7180
7181            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7182            // are envelope_size bytes.
7183            let cur_offset: usize = (1 - 1) * envelope_size;
7184
7185            // Zero reserved fields.
7186            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7187
7188            // Safety:
7189            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7190            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7191            //   envelope_size bytes, there is always sufficient room.
7192            fidl::encoding::encode_in_envelope_optional::<u64, D>(
7193                self.token_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7194                encoder,
7195                offset + cur_offset,
7196                depth,
7197            )?;
7198
7199            _prev_end_offset = cur_offset + envelope_size;
7200
7201            Ok(())
7202        }
7203    }
7204
7205    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7206        for RegistryWatchDeviceRemovedResponse
7207    {
7208        #[inline(always)]
7209        fn new_empty() -> Self {
7210            Self::default()
7211        }
7212
7213        unsafe fn decode(
7214            &mut self,
7215            decoder: &mut fidl::encoding::Decoder<'_, D>,
7216            offset: usize,
7217            mut depth: fidl::encoding::Depth,
7218        ) -> fidl::Result<()> {
7219            decoder.debug_check_bounds::<Self>(offset);
7220            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7221                None => return Err(fidl::Error::NotNullable),
7222                Some(len) => len,
7223            };
7224            // Calling decoder.out_of_line_offset(0) is not allowed.
7225            if len == 0 {
7226                return Ok(());
7227            };
7228            depth.increment()?;
7229            let envelope_size = 8;
7230            let bytes_len = len * envelope_size;
7231            let offset = decoder.out_of_line_offset(bytes_len)?;
7232            // Decode the envelope for each type.
7233            let mut _next_ordinal_to_read = 0;
7234            let mut next_offset = offset;
7235            let end_offset = offset + bytes_len;
7236            _next_ordinal_to_read += 1;
7237            if next_offset >= end_offset {
7238                return Ok(());
7239            }
7240
7241            // Decode unknown envelopes for gaps in ordinals.
7242            while _next_ordinal_to_read < 1 {
7243                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7244                _next_ordinal_to_read += 1;
7245                next_offset += envelope_size;
7246            }
7247
7248            let next_out_of_line = decoder.next_out_of_line();
7249            let handles_before = decoder.remaining_handles();
7250            if let Some((inlined, num_bytes, num_handles)) =
7251                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7252            {
7253                let member_inline_size =
7254                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7255                if inlined != (member_inline_size <= 4) {
7256                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7257                }
7258                let inner_offset;
7259                let mut inner_depth = depth.clone();
7260                if inlined {
7261                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7262                    inner_offset = next_offset;
7263                } else {
7264                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7265                    inner_depth.increment()?;
7266                }
7267                let val_ref = self.token_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
7268                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
7269                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7270                {
7271                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7272                }
7273                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7274                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7275                }
7276            }
7277
7278            next_offset += envelope_size;
7279
7280            // Decode the remaining unknown envelopes.
7281            while next_offset < end_offset {
7282                _next_ordinal_to_read += 1;
7283                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7284                next_offset += envelope_size;
7285            }
7286
7287            Ok(())
7288        }
7289    }
7290
7291    impl RegistryWatchDevicesAddedResponse {
7292        #[inline(always)]
7293        fn max_ordinal_present(&self) -> u64 {
7294            if let Some(_) = self.devices {
7295                return 1;
7296            }
7297            0
7298        }
7299    }
7300
7301    impl fidl::encoding::ValueTypeMarker for RegistryWatchDevicesAddedResponse {
7302        type Borrowed<'a> = &'a Self;
7303        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7304            value
7305        }
7306    }
7307
7308    unsafe impl fidl::encoding::TypeMarker for RegistryWatchDevicesAddedResponse {
7309        type Owned = Self;
7310
7311        #[inline(always)]
7312        fn inline_align(_context: fidl::encoding::Context) -> usize {
7313            8
7314        }
7315
7316        #[inline(always)]
7317        fn inline_size(_context: fidl::encoding::Context) -> usize {
7318            16
7319        }
7320    }
7321
7322    unsafe impl<D: fidl::encoding::ResourceDialect>
7323        fidl::encoding::Encode<RegistryWatchDevicesAddedResponse, D>
7324        for &RegistryWatchDevicesAddedResponse
7325    {
7326        unsafe fn encode(
7327            self,
7328            encoder: &mut fidl::encoding::Encoder<'_, D>,
7329            offset: usize,
7330            mut depth: fidl::encoding::Depth,
7331        ) -> fidl::Result<()> {
7332            encoder.debug_check_bounds::<RegistryWatchDevicesAddedResponse>(offset);
7333            // Vector header
7334            let max_ordinal: u64 = self.max_ordinal_present();
7335            encoder.write_num(max_ordinal, offset);
7336            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7337            // Calling encoder.out_of_line_offset(0) is not allowed.
7338            if max_ordinal == 0 {
7339                return Ok(());
7340            }
7341            depth.increment()?;
7342            let envelope_size = 8;
7343            let bytes_len = max_ordinal as usize * envelope_size;
7344            #[allow(unused_variables)]
7345            let offset = encoder.out_of_line_offset(bytes_len);
7346            let mut _prev_end_offset: usize = 0;
7347            if 1 > max_ordinal {
7348                return Ok(());
7349            }
7350
7351            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7352            // are envelope_size bytes.
7353            let cur_offset: usize = (1 - 1) * envelope_size;
7354
7355            // Zero reserved fields.
7356            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7357
7358            // Safety:
7359            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7360            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7361            //   envelope_size bytes, there is always sufficient room.
7362            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<Info, 256>, D>(
7363                self.devices.as_ref().map(
7364                    <fidl::encoding::Vector<Info, 256> as fidl::encoding::ValueTypeMarker>::borrow,
7365                ),
7366                encoder,
7367                offset + cur_offset,
7368                depth,
7369            )?;
7370
7371            _prev_end_offset = cur_offset + envelope_size;
7372
7373            Ok(())
7374        }
7375    }
7376
7377    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7378        for RegistryWatchDevicesAddedResponse
7379    {
7380        #[inline(always)]
7381        fn new_empty() -> Self {
7382            Self::default()
7383        }
7384
7385        unsafe fn decode(
7386            &mut self,
7387            decoder: &mut fidl::encoding::Decoder<'_, D>,
7388            offset: usize,
7389            mut depth: fidl::encoding::Depth,
7390        ) -> fidl::Result<()> {
7391            decoder.debug_check_bounds::<Self>(offset);
7392            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7393                None => return Err(fidl::Error::NotNullable),
7394                Some(len) => len,
7395            };
7396            // Calling decoder.out_of_line_offset(0) is not allowed.
7397            if len == 0 {
7398                return Ok(());
7399            };
7400            depth.increment()?;
7401            let envelope_size = 8;
7402            let bytes_len = len * envelope_size;
7403            let offset = decoder.out_of_line_offset(bytes_len)?;
7404            // Decode the envelope for each type.
7405            let mut _next_ordinal_to_read = 0;
7406            let mut next_offset = offset;
7407            let end_offset = offset + bytes_len;
7408            _next_ordinal_to_read += 1;
7409            if next_offset >= end_offset {
7410                return Ok(());
7411            }
7412
7413            // Decode unknown envelopes for gaps in ordinals.
7414            while _next_ordinal_to_read < 1 {
7415                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7416                _next_ordinal_to_read += 1;
7417                next_offset += envelope_size;
7418            }
7419
7420            let next_out_of_line = decoder.next_out_of_line();
7421            let handles_before = decoder.remaining_handles();
7422            if let Some((inlined, num_bytes, num_handles)) =
7423                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7424            {
7425                let member_inline_size =
7426                    <fidl::encoding::Vector<Info, 256> as fidl::encoding::TypeMarker>::inline_size(
7427                        decoder.context,
7428                    );
7429                if inlined != (member_inline_size <= 4) {
7430                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7431                }
7432                let inner_offset;
7433                let mut inner_depth = depth.clone();
7434                if inlined {
7435                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7436                    inner_offset = next_offset;
7437                } else {
7438                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7439                    inner_depth.increment()?;
7440                }
7441                let val_ref = self
7442                    .devices
7443                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<Info, 256>, D));
7444                fidl::decode!(fidl::encoding::Vector<Info, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
7445                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7446                {
7447                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7448                }
7449                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7450                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7451                }
7452            }
7453
7454            next_offset += envelope_size;
7455
7456            // Decode the remaining unknown envelopes.
7457            while next_offset < end_offset {
7458                _next_ordinal_to_read += 1;
7459                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7460                next_offset += envelope_size;
7461            }
7462
7463            Ok(())
7464        }
7465    }
7466
7467    impl RingBufferOptions {
7468        #[inline(always)]
7469        fn max_ordinal_present(&self) -> u64 {
7470            if let Some(_) = self.ring_buffer_min_bytes {
7471                return 2;
7472            }
7473            if let Some(_) = self.format {
7474                return 1;
7475            }
7476            0
7477        }
7478    }
7479
7480    impl fidl::encoding::ValueTypeMarker for RingBufferOptions {
7481        type Borrowed<'a> = &'a Self;
7482        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7483            value
7484        }
7485    }
7486
7487    unsafe impl fidl::encoding::TypeMarker for RingBufferOptions {
7488        type Owned = Self;
7489
7490        #[inline(always)]
7491        fn inline_align(_context: fidl::encoding::Context) -> usize {
7492            8
7493        }
7494
7495        #[inline(always)]
7496        fn inline_size(_context: fidl::encoding::Context) -> usize {
7497            16
7498        }
7499    }
7500
7501    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RingBufferOptions, D>
7502        for &RingBufferOptions
7503    {
7504        unsafe fn encode(
7505            self,
7506            encoder: &mut fidl::encoding::Encoder<'_, D>,
7507            offset: usize,
7508            mut depth: fidl::encoding::Depth,
7509        ) -> fidl::Result<()> {
7510            encoder.debug_check_bounds::<RingBufferOptions>(offset);
7511            // Vector header
7512            let max_ordinal: u64 = self.max_ordinal_present();
7513            encoder.write_num(max_ordinal, offset);
7514            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7515            // Calling encoder.out_of_line_offset(0) is not allowed.
7516            if max_ordinal == 0 {
7517                return Ok(());
7518            }
7519            depth.increment()?;
7520            let envelope_size = 8;
7521            let bytes_len = max_ordinal as usize * envelope_size;
7522            #[allow(unused_variables)]
7523            let offset = encoder.out_of_line_offset(bytes_len);
7524            let mut _prev_end_offset: usize = 0;
7525            if 1 > max_ordinal {
7526                return Ok(());
7527            }
7528
7529            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7530            // are envelope_size bytes.
7531            let cur_offset: usize = (1 - 1) * envelope_size;
7532
7533            // Zero reserved fields.
7534            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7535
7536            // Safety:
7537            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7538            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7539            //   envelope_size bytes, there is always sufficient room.
7540            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_audio__common::Format, D>(
7541                self.format.as_ref().map(
7542                    <fidl_fuchsia_audio__common::Format as fidl::encoding::ValueTypeMarker>::borrow,
7543                ),
7544                encoder,
7545                offset + cur_offset,
7546                depth,
7547            )?;
7548
7549            _prev_end_offset = cur_offset + envelope_size;
7550            if 2 > max_ordinal {
7551                return Ok(());
7552            }
7553
7554            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7555            // are envelope_size bytes.
7556            let cur_offset: usize = (2 - 1) * envelope_size;
7557
7558            // Zero reserved fields.
7559            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7560
7561            // Safety:
7562            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7563            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7564            //   envelope_size bytes, there is always sufficient room.
7565            fidl::encoding::encode_in_envelope_optional::<u32, D>(
7566                self.ring_buffer_min_bytes
7567                    .as_ref()
7568                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
7569                encoder,
7570                offset + cur_offset,
7571                depth,
7572            )?;
7573
7574            _prev_end_offset = cur_offset + envelope_size;
7575
7576            Ok(())
7577        }
7578    }
7579
7580    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferOptions {
7581        #[inline(always)]
7582        fn new_empty() -> Self {
7583            Self::default()
7584        }
7585
7586        unsafe fn decode(
7587            &mut self,
7588            decoder: &mut fidl::encoding::Decoder<'_, D>,
7589            offset: usize,
7590            mut depth: fidl::encoding::Depth,
7591        ) -> fidl::Result<()> {
7592            decoder.debug_check_bounds::<Self>(offset);
7593            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7594                None => return Err(fidl::Error::NotNullable),
7595                Some(len) => len,
7596            };
7597            // Calling decoder.out_of_line_offset(0) is not allowed.
7598            if len == 0 {
7599                return Ok(());
7600            };
7601            depth.increment()?;
7602            let envelope_size = 8;
7603            let bytes_len = len * envelope_size;
7604            let offset = decoder.out_of_line_offset(bytes_len)?;
7605            // Decode the envelope for each type.
7606            let mut _next_ordinal_to_read = 0;
7607            let mut next_offset = offset;
7608            let end_offset = offset + bytes_len;
7609            _next_ordinal_to_read += 1;
7610            if next_offset >= end_offset {
7611                return Ok(());
7612            }
7613
7614            // Decode unknown envelopes for gaps in ordinals.
7615            while _next_ordinal_to_read < 1 {
7616                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7617                _next_ordinal_to_read += 1;
7618                next_offset += envelope_size;
7619            }
7620
7621            let next_out_of_line = decoder.next_out_of_line();
7622            let handles_before = decoder.remaining_handles();
7623            if let Some((inlined, num_bytes, num_handles)) =
7624                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7625            {
7626                let member_inline_size =
7627                    <fidl_fuchsia_audio__common::Format as fidl::encoding::TypeMarker>::inline_size(
7628                        decoder.context,
7629                    );
7630                if inlined != (member_inline_size <= 4) {
7631                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7632                }
7633                let inner_offset;
7634                let mut inner_depth = depth.clone();
7635                if inlined {
7636                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7637                    inner_offset = next_offset;
7638                } else {
7639                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7640                    inner_depth.increment()?;
7641                }
7642                let val_ref = self
7643                    .format
7644                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_audio__common::Format, D));
7645                fidl::decode!(
7646                    fidl_fuchsia_audio__common::Format,
7647                    D,
7648                    val_ref,
7649                    decoder,
7650                    inner_offset,
7651                    inner_depth
7652                )?;
7653                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7654                {
7655                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7656                }
7657                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7658                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7659                }
7660            }
7661
7662            next_offset += envelope_size;
7663            _next_ordinal_to_read += 1;
7664            if next_offset >= end_offset {
7665                return Ok(());
7666            }
7667
7668            // Decode unknown envelopes for gaps in ordinals.
7669            while _next_ordinal_to_read < 2 {
7670                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7671                _next_ordinal_to_read += 1;
7672                next_offset += envelope_size;
7673            }
7674
7675            let next_out_of_line = decoder.next_out_of_line();
7676            let handles_before = decoder.remaining_handles();
7677            if let Some((inlined, num_bytes, num_handles)) =
7678                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7679            {
7680                let member_inline_size =
7681                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7682                if inlined != (member_inline_size <= 4) {
7683                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7684                }
7685                let inner_offset;
7686                let mut inner_depth = depth.clone();
7687                if inlined {
7688                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7689                    inner_offset = next_offset;
7690                } else {
7691                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7692                    inner_depth.increment()?;
7693                }
7694                let val_ref =
7695                    self.ring_buffer_min_bytes.get_or_insert_with(|| fidl::new_empty!(u32, D));
7696                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7697                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7698                {
7699                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7700                }
7701                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7702                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7703                }
7704            }
7705
7706            next_offset += envelope_size;
7707
7708            // Decode the remaining unknown envelopes.
7709            while next_offset < end_offset {
7710                _next_ordinal_to_read += 1;
7711                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7712                next_offset += envelope_size;
7713            }
7714
7715            Ok(())
7716        }
7717    }
7718
7719    impl RingBufferProperties {
7720        #[inline(always)]
7721        fn max_ordinal_present(&self) -> u64 {
7722            if let Some(_) = self.turn_on_delay {
7723                return 2;
7724            }
7725            if let Some(_) = self.valid_bits_per_sample {
7726                return 1;
7727            }
7728            0
7729        }
7730    }
7731
7732    impl fidl::encoding::ValueTypeMarker for RingBufferProperties {
7733        type Borrowed<'a> = &'a Self;
7734        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7735            value
7736        }
7737    }
7738
7739    unsafe impl fidl::encoding::TypeMarker for RingBufferProperties {
7740        type Owned = Self;
7741
7742        #[inline(always)]
7743        fn inline_align(_context: fidl::encoding::Context) -> usize {
7744            8
7745        }
7746
7747        #[inline(always)]
7748        fn inline_size(_context: fidl::encoding::Context) -> usize {
7749            16
7750        }
7751    }
7752
7753    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RingBufferProperties, D>
7754        for &RingBufferProperties
7755    {
7756        unsafe fn encode(
7757            self,
7758            encoder: &mut fidl::encoding::Encoder<'_, D>,
7759            offset: usize,
7760            mut depth: fidl::encoding::Depth,
7761        ) -> fidl::Result<()> {
7762            encoder.debug_check_bounds::<RingBufferProperties>(offset);
7763            // Vector header
7764            let max_ordinal: u64 = self.max_ordinal_present();
7765            encoder.write_num(max_ordinal, offset);
7766            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7767            // Calling encoder.out_of_line_offset(0) is not allowed.
7768            if max_ordinal == 0 {
7769                return Ok(());
7770            }
7771            depth.increment()?;
7772            let envelope_size = 8;
7773            let bytes_len = max_ordinal as usize * envelope_size;
7774            #[allow(unused_variables)]
7775            let offset = encoder.out_of_line_offset(bytes_len);
7776            let mut _prev_end_offset: usize = 0;
7777            if 1 > max_ordinal {
7778                return Ok(());
7779            }
7780
7781            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7782            // are envelope_size bytes.
7783            let cur_offset: usize = (1 - 1) * envelope_size;
7784
7785            // Zero reserved fields.
7786            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7787
7788            // Safety:
7789            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7790            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7791            //   envelope_size bytes, there is always sufficient room.
7792            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7793                self.valid_bits_per_sample
7794                    .as_ref()
7795                    .map(<u8 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 2 > 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 = (2 - 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::<i64, D>(
7818                self.turn_on_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
7819                encoder,
7820                offset + cur_offset,
7821                depth,
7822            )?;
7823
7824            _prev_end_offset = cur_offset + envelope_size;
7825
7826            Ok(())
7827        }
7828    }
7829
7830    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferProperties {
7831        #[inline(always)]
7832        fn new_empty() -> Self {
7833            Self::default()
7834        }
7835
7836        unsafe fn decode(
7837            &mut self,
7838            decoder: &mut fidl::encoding::Decoder<'_, D>,
7839            offset: usize,
7840            mut depth: fidl::encoding::Depth,
7841        ) -> fidl::Result<()> {
7842            decoder.debug_check_bounds::<Self>(offset);
7843            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7844                None => return Err(fidl::Error::NotNullable),
7845                Some(len) => len,
7846            };
7847            // Calling decoder.out_of_line_offset(0) is not allowed.
7848            if len == 0 {
7849                return Ok(());
7850            };
7851            depth.increment()?;
7852            let envelope_size = 8;
7853            let bytes_len = len * envelope_size;
7854            let offset = decoder.out_of_line_offset(bytes_len)?;
7855            // Decode the envelope for each type.
7856            let mut _next_ordinal_to_read = 0;
7857            let mut next_offset = offset;
7858            let end_offset = offset + bytes_len;
7859            _next_ordinal_to_read += 1;
7860            if next_offset >= end_offset {
7861                return Ok(());
7862            }
7863
7864            // Decode unknown envelopes for gaps in ordinals.
7865            while _next_ordinal_to_read < 1 {
7866                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7867                _next_ordinal_to_read += 1;
7868                next_offset += envelope_size;
7869            }
7870
7871            let next_out_of_line = decoder.next_out_of_line();
7872            let handles_before = decoder.remaining_handles();
7873            if let Some((inlined, num_bytes, num_handles)) =
7874                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7875            {
7876                let member_inline_size =
7877                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7878                if inlined != (member_inline_size <= 4) {
7879                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7880                }
7881                let inner_offset;
7882                let mut inner_depth = depth.clone();
7883                if inlined {
7884                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7885                    inner_offset = next_offset;
7886                } else {
7887                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7888                    inner_depth.increment()?;
7889                }
7890                let val_ref =
7891                    self.valid_bits_per_sample.get_or_insert_with(|| fidl::new_empty!(u8, D));
7892                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7893                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7894                {
7895                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7896                }
7897                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7898                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7899                }
7900            }
7901
7902            next_offset += envelope_size;
7903            _next_ordinal_to_read += 1;
7904            if next_offset >= end_offset {
7905                return Ok(());
7906            }
7907
7908            // Decode unknown envelopes for gaps in ordinals.
7909            while _next_ordinal_to_read < 2 {
7910                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7911                _next_ordinal_to_read += 1;
7912                next_offset += envelope_size;
7913            }
7914
7915            let next_out_of_line = decoder.next_out_of_line();
7916            let handles_before = decoder.remaining_handles();
7917            if let Some((inlined, num_bytes, num_handles)) =
7918                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7919            {
7920                let member_inline_size =
7921                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7922                if inlined != (member_inline_size <= 4) {
7923                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7924                }
7925                let inner_offset;
7926                let mut inner_depth = depth.clone();
7927                if inlined {
7928                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7929                    inner_offset = next_offset;
7930                } else {
7931                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7932                    inner_depth.increment()?;
7933                }
7934                let val_ref = self.turn_on_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
7935                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
7936                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7937                {
7938                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7939                }
7940                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7941                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7942                }
7943            }
7944
7945            next_offset += envelope_size;
7946
7947            // Decode the remaining unknown envelopes.
7948            while next_offset < end_offset {
7949                _next_ordinal_to_read += 1;
7950                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7951                next_offset += envelope_size;
7952            }
7953
7954            Ok(())
7955        }
7956    }
7957
7958    impl RingBufferSetActiveChannelsRequest {
7959        #[inline(always)]
7960        fn max_ordinal_present(&self) -> u64 {
7961            if let Some(_) = self.channel_bitmask {
7962                return 1;
7963            }
7964            0
7965        }
7966    }
7967
7968    impl fidl::encoding::ValueTypeMarker for RingBufferSetActiveChannelsRequest {
7969        type Borrowed<'a> = &'a Self;
7970        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7971            value
7972        }
7973    }
7974
7975    unsafe impl fidl::encoding::TypeMarker for RingBufferSetActiveChannelsRequest {
7976        type Owned = Self;
7977
7978        #[inline(always)]
7979        fn inline_align(_context: fidl::encoding::Context) -> usize {
7980            8
7981        }
7982
7983        #[inline(always)]
7984        fn inline_size(_context: fidl::encoding::Context) -> usize {
7985            16
7986        }
7987    }
7988
7989    unsafe impl<D: fidl::encoding::ResourceDialect>
7990        fidl::encoding::Encode<RingBufferSetActiveChannelsRequest, D>
7991        for &RingBufferSetActiveChannelsRequest
7992    {
7993        unsafe fn encode(
7994            self,
7995            encoder: &mut fidl::encoding::Encoder<'_, D>,
7996            offset: usize,
7997            mut depth: fidl::encoding::Depth,
7998        ) -> fidl::Result<()> {
7999            encoder.debug_check_bounds::<RingBufferSetActiveChannelsRequest>(offset);
8000            // Vector header
8001            let max_ordinal: u64 = self.max_ordinal_present();
8002            encoder.write_num(max_ordinal, offset);
8003            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8004            // Calling encoder.out_of_line_offset(0) is not allowed.
8005            if max_ordinal == 0 {
8006                return Ok(());
8007            }
8008            depth.increment()?;
8009            let envelope_size = 8;
8010            let bytes_len = max_ordinal as usize * envelope_size;
8011            #[allow(unused_variables)]
8012            let offset = encoder.out_of_line_offset(bytes_len);
8013            let mut _prev_end_offset: usize = 0;
8014            if 1 > max_ordinal {
8015                return Ok(());
8016            }
8017
8018            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8019            // are envelope_size bytes.
8020            let cur_offset: usize = (1 - 1) * envelope_size;
8021
8022            // Zero reserved fields.
8023            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8024
8025            // Safety:
8026            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8027            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8028            //   envelope_size bytes, there is always sufficient room.
8029            fidl::encoding::encode_in_envelope_optional::<u64, D>(
8030                self.channel_bitmask.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
8031                encoder,
8032                offset + cur_offset,
8033                depth,
8034            )?;
8035
8036            _prev_end_offset = cur_offset + envelope_size;
8037
8038            Ok(())
8039        }
8040    }
8041
8042    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8043        for RingBufferSetActiveChannelsRequest
8044    {
8045        #[inline(always)]
8046        fn new_empty() -> Self {
8047            Self::default()
8048        }
8049
8050        unsafe fn decode(
8051            &mut self,
8052            decoder: &mut fidl::encoding::Decoder<'_, D>,
8053            offset: usize,
8054            mut depth: fidl::encoding::Depth,
8055        ) -> fidl::Result<()> {
8056            decoder.debug_check_bounds::<Self>(offset);
8057            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8058                None => return Err(fidl::Error::NotNullable),
8059                Some(len) => len,
8060            };
8061            // Calling decoder.out_of_line_offset(0) is not allowed.
8062            if len == 0 {
8063                return Ok(());
8064            };
8065            depth.increment()?;
8066            let envelope_size = 8;
8067            let bytes_len = len * envelope_size;
8068            let offset = decoder.out_of_line_offset(bytes_len)?;
8069            // Decode the envelope for each type.
8070            let mut _next_ordinal_to_read = 0;
8071            let mut next_offset = offset;
8072            let end_offset = offset + bytes_len;
8073            _next_ordinal_to_read += 1;
8074            if next_offset >= end_offset {
8075                return Ok(());
8076            }
8077
8078            // Decode unknown envelopes for gaps in ordinals.
8079            while _next_ordinal_to_read < 1 {
8080                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8081                _next_ordinal_to_read += 1;
8082                next_offset += envelope_size;
8083            }
8084
8085            let next_out_of_line = decoder.next_out_of_line();
8086            let handles_before = decoder.remaining_handles();
8087            if let Some((inlined, num_bytes, num_handles)) =
8088                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8089            {
8090                let member_inline_size =
8091                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8092                if inlined != (member_inline_size <= 4) {
8093                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8094                }
8095                let inner_offset;
8096                let mut inner_depth = depth.clone();
8097                if inlined {
8098                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8099                    inner_offset = next_offset;
8100                } else {
8101                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8102                    inner_depth.increment()?;
8103                }
8104                let val_ref = self.channel_bitmask.get_or_insert_with(|| fidl::new_empty!(u64, D));
8105                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
8106                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8107                {
8108                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8109                }
8110                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8111                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8112                }
8113            }
8114
8115            next_offset += envelope_size;
8116
8117            // Decode the remaining unknown envelopes.
8118            while next_offset < end_offset {
8119                _next_ordinal_to_read += 1;
8120                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8121                next_offset += envelope_size;
8122            }
8123
8124            Ok(())
8125        }
8126    }
8127
8128    impl RingBufferStartRequest {
8129        #[inline(always)]
8130        fn max_ordinal_present(&self) -> u64 {
8131            0
8132        }
8133    }
8134
8135    impl fidl::encoding::ValueTypeMarker for RingBufferStartRequest {
8136        type Borrowed<'a> = &'a Self;
8137        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8138            value
8139        }
8140    }
8141
8142    unsafe impl fidl::encoding::TypeMarker for RingBufferStartRequest {
8143        type Owned = Self;
8144
8145        #[inline(always)]
8146        fn inline_align(_context: fidl::encoding::Context) -> usize {
8147            8
8148        }
8149
8150        #[inline(always)]
8151        fn inline_size(_context: fidl::encoding::Context) -> usize {
8152            16
8153        }
8154    }
8155
8156    unsafe impl<D: fidl::encoding::ResourceDialect>
8157        fidl::encoding::Encode<RingBufferStartRequest, D> for &RingBufferStartRequest
8158    {
8159        unsafe fn encode(
8160            self,
8161            encoder: &mut fidl::encoding::Encoder<'_, D>,
8162            offset: usize,
8163            mut depth: fidl::encoding::Depth,
8164        ) -> fidl::Result<()> {
8165            encoder.debug_check_bounds::<RingBufferStartRequest>(offset);
8166            // Vector header
8167            let max_ordinal: u64 = self.max_ordinal_present();
8168            encoder.write_num(max_ordinal, offset);
8169            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8170            // Calling encoder.out_of_line_offset(0) is not allowed.
8171            if max_ordinal == 0 {
8172                return Ok(());
8173            }
8174            depth.increment()?;
8175            let envelope_size = 8;
8176            let bytes_len = max_ordinal as usize * envelope_size;
8177            #[allow(unused_variables)]
8178            let offset = encoder.out_of_line_offset(bytes_len);
8179            let mut _prev_end_offset: usize = 0;
8180
8181            Ok(())
8182        }
8183    }
8184
8185    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8186        for RingBufferStartRequest
8187    {
8188        #[inline(always)]
8189        fn new_empty() -> Self {
8190            Self::default()
8191        }
8192
8193        unsafe fn decode(
8194            &mut self,
8195            decoder: &mut fidl::encoding::Decoder<'_, D>,
8196            offset: usize,
8197            mut depth: fidl::encoding::Depth,
8198        ) -> fidl::Result<()> {
8199            decoder.debug_check_bounds::<Self>(offset);
8200            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8201                None => return Err(fidl::Error::NotNullable),
8202                Some(len) => len,
8203            };
8204            // Calling decoder.out_of_line_offset(0) is not allowed.
8205            if len == 0 {
8206                return Ok(());
8207            };
8208            depth.increment()?;
8209            let envelope_size = 8;
8210            let bytes_len = len * envelope_size;
8211            let offset = decoder.out_of_line_offset(bytes_len)?;
8212            // Decode the envelope for each type.
8213            let mut _next_ordinal_to_read = 0;
8214            let mut next_offset = offset;
8215            let end_offset = offset + bytes_len;
8216
8217            // Decode the remaining unknown envelopes.
8218            while next_offset < end_offset {
8219                _next_ordinal_to_read += 1;
8220                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8221                next_offset += envelope_size;
8222            }
8223
8224            Ok(())
8225        }
8226    }
8227
8228    impl RingBufferStopRequest {
8229        #[inline(always)]
8230        fn max_ordinal_present(&self) -> u64 {
8231            0
8232        }
8233    }
8234
8235    impl fidl::encoding::ValueTypeMarker for RingBufferStopRequest {
8236        type Borrowed<'a> = &'a Self;
8237        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8238            value
8239        }
8240    }
8241
8242    unsafe impl fidl::encoding::TypeMarker for RingBufferStopRequest {
8243        type Owned = Self;
8244
8245        #[inline(always)]
8246        fn inline_align(_context: fidl::encoding::Context) -> usize {
8247            8
8248        }
8249
8250        #[inline(always)]
8251        fn inline_size(_context: fidl::encoding::Context) -> usize {
8252            16
8253        }
8254    }
8255
8256    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RingBufferStopRequest, D>
8257        for &RingBufferStopRequest
8258    {
8259        unsafe fn encode(
8260            self,
8261            encoder: &mut fidl::encoding::Encoder<'_, D>,
8262            offset: usize,
8263            mut depth: fidl::encoding::Depth,
8264        ) -> fidl::Result<()> {
8265            encoder.debug_check_bounds::<RingBufferStopRequest>(offset);
8266            // Vector header
8267            let max_ordinal: u64 = self.max_ordinal_present();
8268            encoder.write_num(max_ordinal, offset);
8269            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8270            // Calling encoder.out_of_line_offset(0) is not allowed.
8271            if max_ordinal == 0 {
8272                return Ok(());
8273            }
8274            depth.increment()?;
8275            let envelope_size = 8;
8276            let bytes_len = max_ordinal as usize * envelope_size;
8277            #[allow(unused_variables)]
8278            let offset = encoder.out_of_line_offset(bytes_len);
8279            let mut _prev_end_offset: usize = 0;
8280
8281            Ok(())
8282        }
8283    }
8284
8285    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferStopRequest {
8286        #[inline(always)]
8287        fn new_empty() -> Self {
8288            Self::default()
8289        }
8290
8291        unsafe fn decode(
8292            &mut self,
8293            decoder: &mut fidl::encoding::Decoder<'_, D>,
8294            offset: usize,
8295            mut depth: fidl::encoding::Depth,
8296        ) -> fidl::Result<()> {
8297            decoder.debug_check_bounds::<Self>(offset);
8298            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8299                None => return Err(fidl::Error::NotNullable),
8300                Some(len) => len,
8301            };
8302            // Calling decoder.out_of_line_offset(0) is not allowed.
8303            if len == 0 {
8304                return Ok(());
8305            };
8306            depth.increment()?;
8307            let envelope_size = 8;
8308            let bytes_len = len * envelope_size;
8309            let offset = decoder.out_of_line_offset(bytes_len)?;
8310            // Decode the envelope for each type.
8311            let mut _next_ordinal_to_read = 0;
8312            let mut next_offset = offset;
8313            let end_offset = offset + bytes_len;
8314
8315            // Decode the remaining unknown envelopes.
8316            while next_offset < end_offset {
8317                _next_ordinal_to_read += 1;
8318                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8319                next_offset += envelope_size;
8320            }
8321
8322            Ok(())
8323        }
8324    }
8325
8326    impl RingBufferSetActiveChannelsResponse {
8327        #[inline(always)]
8328        fn max_ordinal_present(&self) -> u64 {
8329            if let Some(_) = self.set_time {
8330                return 1;
8331            }
8332            0
8333        }
8334    }
8335
8336    impl fidl::encoding::ValueTypeMarker for RingBufferSetActiveChannelsResponse {
8337        type Borrowed<'a> = &'a Self;
8338        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8339            value
8340        }
8341    }
8342
8343    unsafe impl fidl::encoding::TypeMarker for RingBufferSetActiveChannelsResponse {
8344        type Owned = Self;
8345
8346        #[inline(always)]
8347        fn inline_align(_context: fidl::encoding::Context) -> usize {
8348            8
8349        }
8350
8351        #[inline(always)]
8352        fn inline_size(_context: fidl::encoding::Context) -> usize {
8353            16
8354        }
8355    }
8356
8357    unsafe impl<D: fidl::encoding::ResourceDialect>
8358        fidl::encoding::Encode<RingBufferSetActiveChannelsResponse, D>
8359        for &RingBufferSetActiveChannelsResponse
8360    {
8361        unsafe fn encode(
8362            self,
8363            encoder: &mut fidl::encoding::Encoder<'_, D>,
8364            offset: usize,
8365            mut depth: fidl::encoding::Depth,
8366        ) -> fidl::Result<()> {
8367            encoder.debug_check_bounds::<RingBufferSetActiveChannelsResponse>(offset);
8368            // Vector header
8369            let max_ordinal: u64 = self.max_ordinal_present();
8370            encoder.write_num(max_ordinal, offset);
8371            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8372            // Calling encoder.out_of_line_offset(0) is not allowed.
8373            if max_ordinal == 0 {
8374                return Ok(());
8375            }
8376            depth.increment()?;
8377            let envelope_size = 8;
8378            let bytes_len = max_ordinal as usize * envelope_size;
8379            #[allow(unused_variables)]
8380            let offset = encoder.out_of_line_offset(bytes_len);
8381            let mut _prev_end_offset: usize = 0;
8382            if 1 > max_ordinal {
8383                return Ok(());
8384            }
8385
8386            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8387            // are envelope_size bytes.
8388            let cur_offset: usize = (1 - 1) * envelope_size;
8389
8390            // Zero reserved fields.
8391            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8392
8393            // Safety:
8394            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8395            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8396            //   envelope_size bytes, there is always sufficient room.
8397            fidl::encoding::encode_in_envelope_optional::<i64, D>(
8398                self.set_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8399                encoder,
8400                offset + cur_offset,
8401                depth,
8402            )?;
8403
8404            _prev_end_offset = cur_offset + envelope_size;
8405
8406            Ok(())
8407        }
8408    }
8409
8410    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8411        for RingBufferSetActiveChannelsResponse
8412    {
8413        #[inline(always)]
8414        fn new_empty() -> Self {
8415            Self::default()
8416        }
8417
8418        unsafe fn decode(
8419            &mut self,
8420            decoder: &mut fidl::encoding::Decoder<'_, D>,
8421            offset: usize,
8422            mut depth: fidl::encoding::Depth,
8423        ) -> fidl::Result<()> {
8424            decoder.debug_check_bounds::<Self>(offset);
8425            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8426                None => return Err(fidl::Error::NotNullable),
8427                Some(len) => len,
8428            };
8429            // Calling decoder.out_of_line_offset(0) is not allowed.
8430            if len == 0 {
8431                return Ok(());
8432            };
8433            depth.increment()?;
8434            let envelope_size = 8;
8435            let bytes_len = len * envelope_size;
8436            let offset = decoder.out_of_line_offset(bytes_len)?;
8437            // Decode the envelope for each type.
8438            let mut _next_ordinal_to_read = 0;
8439            let mut next_offset = offset;
8440            let end_offset = offset + bytes_len;
8441            _next_ordinal_to_read += 1;
8442            if next_offset >= end_offset {
8443                return Ok(());
8444            }
8445
8446            // Decode unknown envelopes for gaps in ordinals.
8447            while _next_ordinal_to_read < 1 {
8448                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8449                _next_ordinal_to_read += 1;
8450                next_offset += envelope_size;
8451            }
8452
8453            let next_out_of_line = decoder.next_out_of_line();
8454            let handles_before = decoder.remaining_handles();
8455            if let Some((inlined, num_bytes, num_handles)) =
8456                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8457            {
8458                let member_inline_size =
8459                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8460                if inlined != (member_inline_size <= 4) {
8461                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8462                }
8463                let inner_offset;
8464                let mut inner_depth = depth.clone();
8465                if inlined {
8466                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8467                    inner_offset = next_offset;
8468                } else {
8469                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8470                    inner_depth.increment()?;
8471                }
8472                let val_ref = self.set_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
8473                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8474                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8475                {
8476                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8477                }
8478                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8479                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8480                }
8481            }
8482
8483            next_offset += envelope_size;
8484
8485            // Decode the remaining unknown envelopes.
8486            while next_offset < end_offset {
8487                _next_ordinal_to_read += 1;
8488                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8489                next_offset += envelope_size;
8490            }
8491
8492            Ok(())
8493        }
8494    }
8495
8496    impl RingBufferStartResponse {
8497        #[inline(always)]
8498        fn max_ordinal_present(&self) -> u64 {
8499            if let Some(_) = self.start_time {
8500                return 1;
8501            }
8502            0
8503        }
8504    }
8505
8506    impl fidl::encoding::ValueTypeMarker for RingBufferStartResponse {
8507        type Borrowed<'a> = &'a Self;
8508        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8509            value
8510        }
8511    }
8512
8513    unsafe impl fidl::encoding::TypeMarker for RingBufferStartResponse {
8514        type Owned = Self;
8515
8516        #[inline(always)]
8517        fn inline_align(_context: fidl::encoding::Context) -> usize {
8518            8
8519        }
8520
8521        #[inline(always)]
8522        fn inline_size(_context: fidl::encoding::Context) -> usize {
8523            16
8524        }
8525    }
8526
8527    unsafe impl<D: fidl::encoding::ResourceDialect>
8528        fidl::encoding::Encode<RingBufferStartResponse, D> for &RingBufferStartResponse
8529    {
8530        unsafe fn encode(
8531            self,
8532            encoder: &mut fidl::encoding::Encoder<'_, D>,
8533            offset: usize,
8534            mut depth: fidl::encoding::Depth,
8535        ) -> fidl::Result<()> {
8536            encoder.debug_check_bounds::<RingBufferStartResponse>(offset);
8537            // Vector header
8538            let max_ordinal: u64 = self.max_ordinal_present();
8539            encoder.write_num(max_ordinal, offset);
8540            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8541            // Calling encoder.out_of_line_offset(0) is not allowed.
8542            if max_ordinal == 0 {
8543                return Ok(());
8544            }
8545            depth.increment()?;
8546            let envelope_size = 8;
8547            let bytes_len = max_ordinal as usize * envelope_size;
8548            #[allow(unused_variables)]
8549            let offset = encoder.out_of_line_offset(bytes_len);
8550            let mut _prev_end_offset: usize = 0;
8551            if 1 > max_ordinal {
8552                return Ok(());
8553            }
8554
8555            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8556            // are envelope_size bytes.
8557            let cur_offset: usize = (1 - 1) * envelope_size;
8558
8559            // Zero reserved fields.
8560            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8561
8562            // Safety:
8563            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8564            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8565            //   envelope_size bytes, there is always sufficient room.
8566            fidl::encoding::encode_in_envelope_optional::<i64, D>(
8567                self.start_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8568                encoder,
8569                offset + cur_offset,
8570                depth,
8571            )?;
8572
8573            _prev_end_offset = cur_offset + envelope_size;
8574
8575            Ok(())
8576        }
8577    }
8578
8579    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8580        for RingBufferStartResponse
8581    {
8582        #[inline(always)]
8583        fn new_empty() -> Self {
8584            Self::default()
8585        }
8586
8587        unsafe fn decode(
8588            &mut self,
8589            decoder: &mut fidl::encoding::Decoder<'_, D>,
8590            offset: usize,
8591            mut depth: fidl::encoding::Depth,
8592        ) -> fidl::Result<()> {
8593            decoder.debug_check_bounds::<Self>(offset);
8594            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8595                None => return Err(fidl::Error::NotNullable),
8596                Some(len) => len,
8597            };
8598            // Calling decoder.out_of_line_offset(0) is not allowed.
8599            if len == 0 {
8600                return Ok(());
8601            };
8602            depth.increment()?;
8603            let envelope_size = 8;
8604            let bytes_len = len * envelope_size;
8605            let offset = decoder.out_of_line_offset(bytes_len)?;
8606            // Decode the envelope for each type.
8607            let mut _next_ordinal_to_read = 0;
8608            let mut next_offset = offset;
8609            let end_offset = offset + bytes_len;
8610            _next_ordinal_to_read += 1;
8611            if next_offset >= end_offset {
8612                return Ok(());
8613            }
8614
8615            // Decode unknown envelopes for gaps in ordinals.
8616            while _next_ordinal_to_read < 1 {
8617                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8618                _next_ordinal_to_read += 1;
8619                next_offset += envelope_size;
8620            }
8621
8622            let next_out_of_line = decoder.next_out_of_line();
8623            let handles_before = decoder.remaining_handles();
8624            if let Some((inlined, num_bytes, num_handles)) =
8625                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8626            {
8627                let member_inline_size =
8628                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8629                if inlined != (member_inline_size <= 4) {
8630                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8631                }
8632                let inner_offset;
8633                let mut inner_depth = depth.clone();
8634                if inlined {
8635                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8636                    inner_offset = next_offset;
8637                } else {
8638                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8639                    inner_depth.increment()?;
8640                }
8641                let val_ref = self.start_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
8642                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8643                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8644                {
8645                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8646                }
8647                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8648                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8649                }
8650            }
8651
8652            next_offset += envelope_size;
8653
8654            // Decode the remaining unknown envelopes.
8655            while next_offset < end_offset {
8656                _next_ordinal_to_read += 1;
8657                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8658                next_offset += envelope_size;
8659            }
8660
8661            Ok(())
8662        }
8663    }
8664
8665    impl RingBufferStopResponse {
8666        #[inline(always)]
8667        fn max_ordinal_present(&self) -> u64 {
8668            0
8669        }
8670    }
8671
8672    impl fidl::encoding::ValueTypeMarker for RingBufferStopResponse {
8673        type Borrowed<'a> = &'a Self;
8674        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8675            value
8676        }
8677    }
8678
8679    unsafe impl fidl::encoding::TypeMarker for RingBufferStopResponse {
8680        type Owned = Self;
8681
8682        #[inline(always)]
8683        fn inline_align(_context: fidl::encoding::Context) -> usize {
8684            8
8685        }
8686
8687        #[inline(always)]
8688        fn inline_size(_context: fidl::encoding::Context) -> usize {
8689            16
8690        }
8691    }
8692
8693    unsafe impl<D: fidl::encoding::ResourceDialect>
8694        fidl::encoding::Encode<RingBufferStopResponse, D> for &RingBufferStopResponse
8695    {
8696        unsafe fn encode(
8697            self,
8698            encoder: &mut fidl::encoding::Encoder<'_, D>,
8699            offset: usize,
8700            mut depth: fidl::encoding::Depth,
8701        ) -> fidl::Result<()> {
8702            encoder.debug_check_bounds::<RingBufferStopResponse>(offset);
8703            // Vector header
8704            let max_ordinal: u64 = self.max_ordinal_present();
8705            encoder.write_num(max_ordinal, offset);
8706            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8707            // Calling encoder.out_of_line_offset(0) is not allowed.
8708            if max_ordinal == 0 {
8709                return Ok(());
8710            }
8711            depth.increment()?;
8712            let envelope_size = 8;
8713            let bytes_len = max_ordinal as usize * envelope_size;
8714            #[allow(unused_variables)]
8715            let offset = encoder.out_of_line_offset(bytes_len);
8716            let mut _prev_end_offset: usize = 0;
8717
8718            Ok(())
8719        }
8720    }
8721
8722    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8723        for RingBufferStopResponse
8724    {
8725        #[inline(always)]
8726        fn new_empty() -> Self {
8727            Self::default()
8728        }
8729
8730        unsafe fn decode(
8731            &mut self,
8732            decoder: &mut fidl::encoding::Decoder<'_, D>,
8733            offset: usize,
8734            mut depth: fidl::encoding::Depth,
8735        ) -> fidl::Result<()> {
8736            decoder.debug_check_bounds::<Self>(offset);
8737            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8738                None => return Err(fidl::Error::NotNullable),
8739                Some(len) => len,
8740            };
8741            // Calling decoder.out_of_line_offset(0) is not allowed.
8742            if len == 0 {
8743                return Ok(());
8744            };
8745            depth.increment()?;
8746            let envelope_size = 8;
8747            let bytes_len = len * envelope_size;
8748            let offset = decoder.out_of_line_offset(bytes_len)?;
8749            // Decode the envelope for each type.
8750            let mut _next_ordinal_to_read = 0;
8751            let mut next_offset = offset;
8752            let end_offset = offset + bytes_len;
8753
8754            // Decode the remaining unknown envelopes.
8755            while next_offset < end_offset {
8756                _next_ordinal_to_read += 1;
8757                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8758                next_offset += envelope_size;
8759            }
8760
8761            Ok(())
8762        }
8763    }
8764
8765    impl RingBufferWatchDelayInfoResponse {
8766        #[inline(always)]
8767        fn max_ordinal_present(&self) -> u64 {
8768            if let Some(_) = self.delay_info {
8769                return 1;
8770            }
8771            0
8772        }
8773    }
8774
8775    impl fidl::encoding::ValueTypeMarker for RingBufferWatchDelayInfoResponse {
8776        type Borrowed<'a> = &'a Self;
8777        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8778            value
8779        }
8780    }
8781
8782    unsafe impl fidl::encoding::TypeMarker for RingBufferWatchDelayInfoResponse {
8783        type Owned = Self;
8784
8785        #[inline(always)]
8786        fn inline_align(_context: fidl::encoding::Context) -> usize {
8787            8
8788        }
8789
8790        #[inline(always)]
8791        fn inline_size(_context: fidl::encoding::Context) -> usize {
8792            16
8793        }
8794    }
8795
8796    unsafe impl<D: fidl::encoding::ResourceDialect>
8797        fidl::encoding::Encode<RingBufferWatchDelayInfoResponse, D>
8798        for &RingBufferWatchDelayInfoResponse
8799    {
8800        unsafe fn encode(
8801            self,
8802            encoder: &mut fidl::encoding::Encoder<'_, D>,
8803            offset: usize,
8804            mut depth: fidl::encoding::Depth,
8805        ) -> fidl::Result<()> {
8806            encoder.debug_check_bounds::<RingBufferWatchDelayInfoResponse>(offset);
8807            // Vector header
8808            let max_ordinal: u64 = self.max_ordinal_present();
8809            encoder.write_num(max_ordinal, offset);
8810            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8811            // Calling encoder.out_of_line_offset(0) is not allowed.
8812            if max_ordinal == 0 {
8813                return Ok(());
8814            }
8815            depth.increment()?;
8816            let envelope_size = 8;
8817            let bytes_len = max_ordinal as usize * envelope_size;
8818            #[allow(unused_variables)]
8819            let offset = encoder.out_of_line_offset(bytes_len);
8820            let mut _prev_end_offset: usize = 0;
8821            if 1 > max_ordinal {
8822                return Ok(());
8823            }
8824
8825            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8826            // are envelope_size bytes.
8827            let cur_offset: usize = (1 - 1) * envelope_size;
8828
8829            // Zero reserved fields.
8830            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8831
8832            // Safety:
8833            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8834            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8835            //   envelope_size bytes, there is always sufficient room.
8836            fidl::encoding::encode_in_envelope_optional::<DelayInfo, D>(
8837                self.delay_info
8838                    .as_ref()
8839                    .map(<DelayInfo as fidl::encoding::ValueTypeMarker>::borrow),
8840                encoder,
8841                offset + cur_offset,
8842                depth,
8843            )?;
8844
8845            _prev_end_offset = cur_offset + envelope_size;
8846
8847            Ok(())
8848        }
8849    }
8850
8851    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8852        for RingBufferWatchDelayInfoResponse
8853    {
8854        #[inline(always)]
8855        fn new_empty() -> Self {
8856            Self::default()
8857        }
8858
8859        unsafe fn decode(
8860            &mut self,
8861            decoder: &mut fidl::encoding::Decoder<'_, D>,
8862            offset: usize,
8863            mut depth: fidl::encoding::Depth,
8864        ) -> fidl::Result<()> {
8865            decoder.debug_check_bounds::<Self>(offset);
8866            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8867                None => return Err(fidl::Error::NotNullable),
8868                Some(len) => len,
8869            };
8870            // Calling decoder.out_of_line_offset(0) is not allowed.
8871            if len == 0 {
8872                return Ok(());
8873            };
8874            depth.increment()?;
8875            let envelope_size = 8;
8876            let bytes_len = len * envelope_size;
8877            let offset = decoder.out_of_line_offset(bytes_len)?;
8878            // Decode the envelope for each type.
8879            let mut _next_ordinal_to_read = 0;
8880            let mut next_offset = offset;
8881            let end_offset = offset + bytes_len;
8882            _next_ordinal_to_read += 1;
8883            if next_offset >= end_offset {
8884                return Ok(());
8885            }
8886
8887            // Decode unknown envelopes for gaps in ordinals.
8888            while _next_ordinal_to_read < 1 {
8889                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8890                _next_ordinal_to_read += 1;
8891                next_offset += envelope_size;
8892            }
8893
8894            let next_out_of_line = decoder.next_out_of_line();
8895            let handles_before = decoder.remaining_handles();
8896            if let Some((inlined, num_bytes, num_handles)) =
8897                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8898            {
8899                let member_inline_size =
8900                    <DelayInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8901                if inlined != (member_inline_size <= 4) {
8902                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8903                }
8904                let inner_offset;
8905                let mut inner_depth = depth.clone();
8906                if inlined {
8907                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8908                    inner_offset = next_offset;
8909                } else {
8910                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8911                    inner_depth.increment()?;
8912                }
8913                let val_ref = self.delay_info.get_or_insert_with(|| fidl::new_empty!(DelayInfo, D));
8914                fidl::decode!(DelayInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
8915                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8916                {
8917                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8918                }
8919                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8920                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8921                }
8922            }
8923
8924            next_offset += envelope_size;
8925
8926            // Decode the remaining unknown envelopes.
8927            while next_offset < end_offset {
8928                _next_ordinal_to_read += 1;
8929                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8930                next_offset += envelope_size;
8931            }
8932
8933            Ok(())
8934        }
8935    }
8936}